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         proto_config(PROTO_MONITOR, 0, 0., NULL);
 601
 602         for (;;) {
 603                 if (tok == CONFIG_END)
 604                         break;
 605                 if (fp[includelevel])
 606                         tok = gettokens(fp[includelevel], line, tokens, &ntokens);
 607 #ifdef HAVE_NETINFO
 608                 else
 609                         tok = gettokens_netinfo(config_netinfo, tokens, &ntokens);
 610 #endif /* HAVE_NETINFO */
 611
 612                 if (tok == CONFIG_UNKNOWN) {
 613                     if (includelevel > 0) {
 614                         fclose(fp[includelevel--]);
 615                         continue;
 616                     } else {
 617                         break;
 618                     }
 619                 }
 620
 621                 switch(tok) {
 622                     case CONFIG_PEER:
 623                     case CONFIG_SERVER:
 624                     case CONFIG_MANYCASTCLIENT:
 625                     case CONFIG_BROADCAST:
 626                         if (tok == CONFIG_PEER)
 627                             hmode = MODE_ACTIVE;
 628                         else if (tok == CONFIG_SERVER)
 629                             hmode = MODE_CLIENT;
 630                         else if (tok == CONFIG_MANYCASTCLIENT)
 631                             hmode = MODE_CLIENT;
 632                         else
 633                             hmode = MODE_BROADCAST;
 634
 635                         if (ntokens < 2) {
 636                                 msyslog(LOG_ERR,
 637                                         "No address for %s, line ignored",
 638                                         tokens[0]);
 639                                 break;
 640                         }
 641
 642                         istart = 1;
 643                         memset((char *)&peeraddr, 0, sizeof(peeraddr));
 644                         peeraddr.ss_family = default_ai_family;
 645                         switch (matchkey(tokens[istart], addr_type, 0)) {
 646                         case CONF_ADDR_IPV4:
 647                                 peeraddr.ss_family = AF_INET;
 648                                 istart++;
 649                                 break;
 650                         case CONF_ADDR_IPV6:
 651                                 peeraddr.ss_family = AF_INET6;
 652                                 istart++;
 653                                 break;
 654                         }
 655
 656                         status = getnetnum(tokens[istart], &peeraddr, 0, t_UNK);
 657                         if (status == -1)
 658                                 break;          /* Found IPv6 address */
 659                         if(status != 1) {
 660                                 errflg = -1;
 661                         } else {
 662                                 errflg = 0;
 663
 664                                 if (
 665 #ifdef REFCLOCK
 666                                         !ISREFCLOCKADR(&peeraddr) &&
 667 #endif
 668                                         ISBADADR(&peeraddr)) {
 669                                         msyslog(LOG_ERR,
 670                                                 "attempt to configure invalid address %s",
 671                                                 stoa(&peeraddr));
 672                                         break;
 673                                 }
 674                                 /*
 675                                  * Shouldn't be able to specify multicast
 676                                  * address for server/peer!
 677                                  * and unicast address for manycastclient!
 678                                  */
 679                                 if (peeraddr.ss_family == AF_INET) {
 680                                         if (((tok == CONFIG_SERVER) ||
 681                                         (tok == CONFIG_PEER)) &&
 682 #ifdef REFCLOCK
 683                                         !ISREFCLOCKADR(&peeraddr) &&
 684 #endif
 685                                         IN_CLASSD(ntohl(((struct sockaddr_in*)&peeraddr)->sin_addr.s_addr))) {
 686                                                 msyslog(LOG_ERR,
 687                                                         "attempt to configure invalid address %s",
 688                                                         stoa(&peeraddr));
 689                                                 break;
 690                                         }
 691                                         if ((tok == CONFIG_MANYCASTCLIENT) &&
 692                                         !IN_CLASSD(ntohl(((struct sockaddr_in*)&peeraddr)->sin_addr.s_addr))) {
 693                                                 msyslog(LOG_ERR,
 694                                                         "attempt to configure invalid address %s",
 695                                                         stoa(&peeraddr));
 696                                                 break;
 697                                         }
 698                                 }
 699                                 else if(peeraddr.ss_family == AF_INET6) {
 700                                 if (((tok == CONFIG_SERVER) ||
 701                                      (tok == CONFIG_PEER)) &&
 702 #ifdef REFCLOCK
 703                                     !ISREFCLOCKADR(&peeraddr) &&
 704 #endif
 705                                         IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)&peeraddr)->sin6_addr)) {
 706                                                 msyslog(LOG_ERR,
 707                                                         "attempt to configure in valid address %s",
 708                                                         stoa(&peeraddr));
 709                                                 break;
 710                                         }
 711                                         if ((tok == CONFIG_MANYCASTCLIENT) &&
 712                                             !IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)&peeraddr)->sin6_addr)) {
 713                                                         msyslog(LOG_ERR,
 714                                                         "attempt to configure in valid address %s",
 715                                                         stoa(&peeraddr));
 716                                                 break;
 717                                         }
 718                                 }
 719                         }
 720                         if (peeraddr.ss_family == AF_INET6 &&
 721                             isc_net_probeipv6() != ISC_R_SUCCESS)
 722                                 break;
 723
 724                         peerversion = NTP_VERSION;
 725                         minpoll = NTP_MINDPOLL;
 726                         maxpoll = NTP_MAXDPOLL;
 727                         peerkey = 0;
 728                         peerkeystr = (u_char *)"*";
 729                         peerflags = 0;
 730                         ttl = 0;
 731                         istart++;
 732                         for (i = istart; i < ntokens; i++)
 733                             switch (matchkey(tokens[i], mod_keywords, 1)) {
 734                                 case CONF_MOD_VERSION:
 735                                     if (i >= ntokens-1) {
 736                                             msyslog(LOG_ERR,
 737                                                     "peer/server version requires an argument");
 738                                             errflg = 1;
 739                                             break;
 740                                     }
 741                                     peerversion = atoi(tokens[++i]);
 742                                     if ((u_char)peerversion > NTP_VERSION
 743                                         || (u_char)peerversion < NTP_OLDVERSION) {
 744                                             msyslog(LOG_ERR,
 745                                                     "inappropriate version number %s, line ignored",
 746                                                     tokens[i]);
 747                                             errflg = 1;
 748                                     }
 749                                     break;
 750
 751                                 case CONF_MOD_KEY:
 752                                     if (i >= ntokens-1) {
 753                                             msyslog(LOG_ERR,
 754                                                     "key: argument required");
 755                                             errflg = 1;
 756                                             break;
 757                                     }
 758                                     peerkey = (int)atol(tokens[++i]);
 759                                     peerflags |= FLAG_AUTHENABLE;
 760                                     break;
 761
 762                                 case CONF_MOD_MINPOLL:
 763                                     if (i >= ntokens-1) {
 764                                             msyslog(LOG_ERR,
 765                                                     "minpoll: argument required");
 766                                             errflg = 1;
 767                                             break;
 768                                     }
 769                                     minpoll = atoi(tokens[++i]);
 770                                     if (minpoll < NTP_MINPOLL) {
 771                                             msyslog(LOG_INFO,
 772                                                     "minpoll: provided value (%d) is below minimum (%d)",
 773                                                     minpoll, NTP_MINPOLL);
 774                                         minpoll = NTP_MINPOLL;
 775                                     }
 776                                     break;
 777
 778                                 case CONF_MOD_MAXPOLL:
 779                                     if (i >= ntokens-1) {
 780                                             msyslog(LOG_ERR,
 781                                                     "maxpoll: argument required"
 782                                                     );
 783                                             errflg = 1;
 784                                             break;
 785                                     }
 786                                     maxpoll = atoi(tokens[++i]);
 787                                     if (maxpoll > NTP_MAXPOLL) {
 788                                             msyslog(LOG_INFO,
 789                                                     "maxpoll: provided value (%d) is above maximum (%d)",
 790                                                     maxpoll, NTP_MAXPOLL);
 791                                         maxpoll = NTP_MAXPOLL;
 792                                     }
 793                                     break;
 794
 795                                 case CONF_MOD_PREFER:
 796                                     peerflags |= FLAG_PREFER;
 797                                     break;
 798
 799                                 case CONF_MOD_PREEMPT:
 800                                     peerflags |= FLAG_PREEMPT;
 801                                     break;
 802
 803                                 case CONF_MOD_NOSELECT:
 804                                     peerflags |= FLAG_NOSELECT;
 805                                     break;
 806
 807                                 case CONF_MOD_TRUE:
 808                                     peerflags |= FLAG_TRUE;
 809
 810                                 case CONF_MOD_BURST:
 811                                     peerflags |= FLAG_BURST;
 812                                     break;
 813
 814                                 case CONF_MOD_IBURST:
 815                                     peerflags |= FLAG_IBURST;
 816                                     break;
 817
 818                                 case CONF_MOD_DYNAMIC:
 819                                     msyslog(LOG_WARNING,
 820                                         "Warning: the \"dynamic\" keyword has been obsoleted"
 821                                         " and will be removed in the next release\n");
 822                                     break;
 823
 824 #ifdef OPENSSL
 825                                 case CONF_MOD_SKEY:
 826                                     peerflags |= FLAG_SKEY |
 827                                         FLAG_AUTHENABLE;
 828                                     break;
 829 #endif /* OPENSSL */
 830
 831                                 case CONF_MOD_TTL:
 832                                     if (i >= ntokens-1) {
 833                                         msyslog(LOG_ERR,
 834                                             "ttl: argument required");
 835                                         errflg = 1;
 836                                         break;
 837                                     }
 838                                     ttl = atoi(tokens[++i]);
 839                                     if (ttl >= MAX_TTL) {
 840                                         msyslog(LOG_ERR,
 841                                             "ttl: invalid argument");
 842                                         errflg = 1;
 843                                     }
 844                                     break;
 845
 846                                 case CONF_MOD_MODE:
 847                                     if (i >= ntokens-1) {
 848                                         msyslog(LOG_ERR,
 849                                             "mode: argument required");
 850                                         errflg = 1;
 851                                         break;
 852                                     }
 853                                     ttl = atoi(tokens[++i]);
 854                                     break;
 855
 856                                 case CONFIG_UNKNOWN:
 857                                     errflg = 1;
 858                                     break;
 859                             }
 860                         if (minpoll > maxpoll) {
 861                                 msyslog(LOG_ERR,
 862                                     "config error: minpoll > maxpoll");
 863                                 errflg = 1;
 864                         }
 865                         if (errflg == 0) {
 866                             if (peer_config(&peeraddr,
 867                                 ANY_INTERFACE_CHOOSE(&peeraddr), hmode,
 868                                 peerversion, minpoll, maxpoll, peerflags,
 869                                 ttl, peerkey, peerkeystr) == 0) {
 870                                         msyslog(LOG_ERR,
 871                                                 "configuration of %s failed",
 872                                                 stoa(&peeraddr));
 873                             }
 874                         } else if (errflg == -1) {
 875                                 save_resolve(tokens[istart - 1], hmode, peerversion,
 876                                     minpoll, maxpoll, peerflags, ttl,
 877                                     peerkey, peerkeystr, peeraddr.ss_family);
 878                         }
 879                         break;
 880
 881                     case CONFIG_DRIFTFILE:
 882                         if (ntokens >= 2)
 883                             stats_config(STATS_FREQ_FILE, tokens[1]);
 884                         else
 885                             stats_config(STATS_FREQ_FILE, (char *)0);
 886                         stats_write_period = stats_write_tolerance = 0;
 887                         if (ntokens >= 3)
 888                              stats_write_period = 60 * atol(tokens[2]);
 889                         if (stats_write_period <= 0)
 890                              stats_write_period = 3600;
 891                         if (ntokens >= 4) {
 892                              double ftemp;
 893                              sscanf(tokens[3], "%lf", &ftemp);
 894                              stats_write_tolerance = ftemp / 100;
 895                         }
 896                         break;
 897
 898                     case CONFIG_PIDFILE:
 899                         if (ntokens >= 2)
 900                             stats_config(STATS_PID_FILE, tokens[1]);
 901                         else
 902                             stats_config(STATS_PID_FILE, (char *)0);
 903                         break;
 904
 905                     case CONFIG_END:
 906                         for ( i = 0; i <= includelevel; i++ ) {
 907                                 fclose(fp[i]);
 908                         }
 909                         break;
 910
 911                     case CONFIG_INCLUDEFILE:
 912                         if (ntokens < 2) {
 913                             msyslog(LOG_ERR, "includefile needs one argument");
 914                             break;
 915                         }
 916                         if (includelevel >= MAXINCLUDELEVEL) {
 917                             fprintf(stderr, "getconfig: Maximum include file level exceeded.\n");
 918                             msyslog(LOG_INFO, "getconfig: Maximum include file level exceeded.");
 919                             break;
 920                         }
 921                         includefile = fopen(FindConfig(tokens[1]), "r");
 922                         if (includefile == NULL) {
 923                             fprintf(stderr, "getconfig: Couldn't open <%s>\n", FindConfig(tokens[1]));
 924                             msyslog(LOG_INFO, "getconfig: Couldn't open <%s>", FindConfig(tokens[1]));
 925                             break;
 926                         }
 927                         fp[++includelevel] = includefile;
 928                         break;
 929
 930                     case CONFIG_LOGFILE:
 931                         if (ntokens >= 2) {
 932                                 FILE *new_file;
 933
 934                                 new_file = fopen(tokens[1], "a");
 935                                 if (new_file != NULL) {
 936                                         NLOG(NLOG_SYSINFO) /* conditional if clause for conditional syslog */
 937                                             msyslog(LOG_NOTICE, "logging to file %s", tokens[1]);
 938                                         if (syslog_file != NULL &&
 939                                             fileno(syslog_file) != fileno(new_file))
 940                                             (void)fclose(syslog_file);
 941
 942                                         syslog_file = new_file;
 943                                         syslogit = 0;
 944                                 }
 945                                 else
 946                                     msyslog(LOG_ERR,
 947                                             "Cannot open log file %s",
 948                                             tokens[1]);
 949                         }
 950                         else
 951                             msyslog(LOG_ERR, "logfile needs one argument");
 952                         break;
 953
 954                     case CONFIG_LOGCONFIG:
 955                         for (i = 1; i < ntokens; i++)
 956                         {
 957                                 int add = 1;
 958                                 int equals = 0;
 959                                 char * s = &tokens[i][0];
 960
 961                                 switch (*s) {
 962                                     case '+':
 963                                     case '-':
 964                                     case '=':
 965                                         add = *s == '+';
 966                                         equals = *s == '=';
 967                                         s++;
 968                                         break;
 969
 970                                     default:
 971                                         break;
 972                                 }
 973                                 if (equals) {
 974                                         ntp_syslogmask = get_logmask(s);
 975                                 } else {
 976                                         if (add) {
 977                                                 ntp_syslogmask |= get_logmask(s);
 978                                         } else {
 979                                                 ntp_syslogmask &= ~get_logmask(s);
 980                                         }
 981                                 }
 982 #ifdef DEBUG
 983                                 if (debug)
 984                                     printf("ntp_syslogmask = 0x%08lx (%s)\n", ntp_syslogmask, tokens[i]);
 985 #endif
 986                         }
 987                         break;
 988
 989                     case CONFIG_BROADCASTCLIENT:
 990                         if (ntokens == 1) {
 991                                 proto_config(PROTO_BROADCLIENT, 1, 0., NULL);
 992                         } else {
 993                                 proto_config(PROTO_BROADCLIENT, 2, 0., NULL);
 994                         }
 995                         break;
 996
 997                     case CONFIG_MULTICASTCLIENT:
 998                     case CONFIG_MANYCASTSERVER:
 999                         if (ntokens > 1) {
1000                                 istart = 1;
1001                                 memset((char *)&peeraddr, 0, sizeof(peeraddr));
1002                                 peeraddr.ss_family = default_ai_family;
1003                                 switch (matchkey(tokens[istart],
1004                                     addr_type, 0)) {
1005                                 case CONF_ADDR_IPV4:
1006                                         peeraddr.ss_family = AF_INET;
1007                                         istart++;
1008                                         break;
1009                                 case CONF_ADDR_IPV6:
1010                                         peeraddr.ss_family = AF_INET6;
1011                                         istart++;
1012                                         break;
1013                                 }
1014                                 /*
1015                                  * Abuse maskaddr to store the prefered ip
1016                                  * version.
1017                                  */
1018                                 memset((char *)&maskaddr, 0, sizeof(maskaddr));
1019                                 maskaddr.ss_family = peeraddr.ss_family;
1020
1021                                 for (i = istart; i < ntokens; i++) {
1022                                         memset((char *)&peeraddr, 0,
1023                                             sizeof(peeraddr));
1024                                         peeraddr.ss_family = maskaddr.ss_family;
1025                                         if (getnetnum(tokens[i], &peeraddr, 1,
1026                                                       t_UNK)  == 1)
1027                                             proto_config(PROTO_MULTICAST_ADD,
1028                                                          0, 0., &peeraddr);
1029                                 }
1030                         } else
1031                             proto_config(PROTO_MULTICAST_ADD,
1032                                          0, 0., NULL);
1033                         if (tok == CONFIG_MULTICASTCLIENT)
1034                                 proto_config(PROTO_MULTICAST_ADD, 1, 0., NULL);
1035                         else if (tok == CONFIG_MANYCASTSERVER)
1036                                 sys_manycastserver = 1;
1037                         break;
1038
1039                     case CONFIG_KEYS:
1040                         if (ntokens >= 2) {
1041                                 getauthkeys(tokens[1]);
1042                         }
1043                         break;
1044
1045                     case CONFIG_KEYSDIR:
1046                         if (ntokens < 2) {
1047                             msyslog(LOG_ERR,
1048                                 "Keys directory name required");
1049                             break;
1050                         }
1051                         keysdir = (char *)emalloc(strlen(tokens[1]) + 1);
1052                         strcpy(keysdir, tokens[1]);
1053                         break;
1054
1055                     case CONFIG_TINKER:
1056                         for (i = 1; i < ntokens; i++) {
1057                             int temp;
1058                             double ftemp;
1059
1060                             temp = matchkey(tokens[i++], tinker_keywords, 1);
1061                             if (i > ntokens - 1) {
1062                                 msyslog(LOG_ERR,
1063                                     "tinker: missing argument");
1064                                 errflg++;
1065                                 break;
1066                             }
1067                             sscanf(tokens[i], "%lf", &ftemp);
1068                             switch(temp) {
1069
1070                             case CONF_CLOCK_MAX:
1071                                 loop_config(LOOP_MAX, ftemp);
1072                                 break;
1073
1074                             case CONF_CLOCK_PANIC:
1075                                 loop_config(LOOP_PANIC, ftemp);
1076                                 break;
1077
1078                             case CONF_CLOCK_PHI:
1079                                 loop_config(LOOP_PHI, ftemp);
1080                                 break;
1081
1082                             case CONF_CLOCK_MINSTEP:
1083                                 loop_config(LOOP_MINSTEP, ftemp);
1084                                 break;
1085
1086                             case CONF_CLOCK_ALLAN:
1087                                 loop_config(LOOP_ALLAN, ftemp);
1088                                 break;
1089
1090                             case CONF_CLOCK_HUFFPUFF:
1091                                 loop_config(LOOP_HUFFPUFF, ftemp);
1092                                 break;
1093
1094                             case CONF_CLOCK_FREQ:
1095                                 loop_config(LOOP_FREQ, ftemp);
1096                                 break;
1097                             }
1098                         }
1099                         break;
1100
1101                     case CONFIG_TOS:
1102                         for (i = 1; i < ntokens; i++) {
1103                             int temp;
1104                             double ftemp;
1105
1106                             temp = matchkey(tokens[i++], tos_keywords, 1);
1107                             if (i > ntokens - 1) {
1108                                 msyslog(LOG_ERR,
1109                                     "tos: missing argument");
1110                                 errflg++;
1111                                 break;
1112                             }
1113                             sscanf(tokens[i], "%lf", &ftemp);
1114                             switch(temp) {
1115
1116                             case CONF_TOS_MINCLOCK:
1117                                 proto_config(PROTO_MINCLOCK, 0, ftemp, NULL);
1118                                 break;
1119
1120                             case CONF_TOS_MAXCLOCK:
1121                                 proto_config(PROTO_MAXCLOCK, 0, ftemp, NULL);
1122                                 break;
1123
1124                             case CONF_TOS_MINSANE:
1125                                 proto_config(PROTO_MINSANE, 0, ftemp, NULL);
1126                                 break;
1127
1128                             case CONF_TOS_FLOOR:
1129                                 proto_config(PROTO_FLOOR, 0, ftemp, NULL);
1130                                 break;
1131
1132                             case CONF_TOS_CEILING:
1133                                 proto_config(PROTO_CEILING, 0, ftemp, NULL);
1134                                 break;
1135
1136                             case CONF_TOS_COHORT:
1137                                 proto_config(PROTO_COHORT, 0, ftemp, NULL);
1138                                 break;
1139
1140                             case CONF_TOS_MINDISP:
1141                                 proto_config(PROTO_MINDISP, 0, ftemp, NULL);
1142                                 break;
1143
1144                             case CONF_TOS_MAXDIST:
1145                                 proto_config(PROTO_MAXDIST, 0, ftemp, NULL);
1146                                 break;
1147
1148                             case CONF_TOS_MAXHOP:
1149                                 proto_config(PROTO_MAXHOP, 0, ftemp, NULL);
1150                                 break;
1151
1152                             case CONF_TOS_ORPHAN:
1153                                 proto_config(PROTO_ORPHAN, 0, ftemp, NULL);
1154                                 break;
1155
1156                             case CONF_TOS_BEACON:
1157                                 proto_config(PROTO_BEACON, 0, ftemp, NULL);
1158                                 break;
1159                             }
1160                         }
1161                         break;
1162
1163                     case CONFIG_TTL:
1164                         for (i = 1; i < ntokens && i < MAX_TTL; i++) {
1165                             sys_ttl[i - 1] = (u_char) atoi(tokens[i]);
1166                             sys_ttlmax = i - 1;
1167                         }
1168                         break;
1169
1170                     case CONFIG_DISCARD:
1171                         for (i = 1; i < ntokens; i++) {
1172                             int temp;
1173
1174                             temp = matchkey(tokens[i++],
1175                                 discard_keywords, 1);
1176                             if (i > ntokens - 1) {
1177                                 msyslog(LOG_ERR,
1178                                     "discard: missing argument");
1179                                 errflg++;
1180                                 break;
1181                             }
1182                             switch(temp) {
1183                             case CONF_DISCARD_AVERAGE:
1184                                 res_avg_interval = atoi(tokens[i]);
1185                                 break;
1186
1187                             case CONF_DISCARD_MINIMUM:
1188                                 res_min_interval = atoi(tokens[i]);
1189                                 break;
1190
1191                             case CONF_DISCARD_MONITOR:
1192                                 mon_age = atoi(tokens[i]);
1193                                 break;
1194
1195                             default:
1196                                 msyslog(LOG_ERR,
1197                                     "discard: unknown keyword");
1198                                 break;
1199                             }
1200                         }
1201                         break;
1202
1203 #ifdef OPENSSL
1204                     case CONFIG_REVOKE:
1205                         if (ntokens >= 2)
1206                             sys_revoke = (u_char) max(atoi(tokens[1]), KEY_REVOKE);
1207                         break;
1208
1209                     case CONFIG_AUTOMAX:
1210                         if (ntokens >= 2)
1211                             sys_automax = 1 << max(atoi(tokens[1]), 10);
1212                         break;
1213
1214                     case CONFIG_CRYPTO:
1215                         if (ntokens == 1) {
1216                                 crypto_config(CRYPTO_CONF_NONE, NULL);
1217                                 break;
1218                         }
1219                         for (i = 1; i < ntokens; i++) {
1220                             int temp;
1221
1222                             temp = matchkey(tokens[i++],
1223                                  crypto_keywords, 1);
1224                             if (i > ntokens - 1) {
1225                                 msyslog(LOG_ERR,
1226                                     "crypto: missing argument");
1227                                 errflg++;
1228                                 break;
1229                             }
1230                             switch(temp) {
1231
1232                             case CONF_CRYPTO_CERT:
1233                                 crypto_config(CRYPTO_CONF_CERT,
1234                                     tokens[i]);
1235                                 break;
1236
1237                             case CONF_CRYPTO_RSA:
1238                                 crypto_config(CRYPTO_CONF_PRIV,
1239                                     tokens[i]);
1240                                 break;
1241
1242                             case CONF_CRYPTO_IDENT:
1243                                 crypto_config(CRYPTO_CONF_IDENT,
1244                                     tokens[i]);
1245                                 break;
1246
1247                             case CONF_CRYPTO_IFFPAR:
1248                                 crypto_config(CRYPTO_CONF_IFFPAR,
1249                                     tokens[i]);
1250                                 break;
1251
1252                             case CONF_CRYPTO_GQPAR:
1253                                 crypto_config(CRYPTO_CONF_GQPAR,
1254                                     tokens[i]);
1255                                 break;
1256
1257                             case CONF_CRYPTO_MVPAR:
1258                                 crypto_config(CRYPTO_CONF_MVPAR,
1259                                     tokens[i]);
1260                                 break;
1261
1262                             case CONF_CRYPTO_LEAP:
1263                                 crypto_config(CRYPTO_CONF_LEAP,
1264                                     tokens[i]);
1265                                 break;
1266
1267                             case CONF_CRYPTO_PW:
1268                                 crypto_config(CRYPTO_CONF_PW,
1269                                     tokens[i]);
1270                                 break;
1271
1272                             case CONF_CRYPTO_RAND:
1273                                 crypto_config(CRYPTO_CONF_RAND,
1274                                     tokens[i]);
1275                                 break;
1276
1277                             case CONF_CRYPTO_SIGN:
1278                                 crypto_config(CRYPTO_CONF_SIGN,
1279                                     tokens[i]);
1280                                 break;
1281
1282                             default:
1283                                 msyslog(LOG_ERR,
1284                                     "crypto: unknown keyword");
1285                                 break;
1286                             }
1287                         }
1288                         break;
1289 #endif /* OPENSSL */
1290
1291                     case CONFIG_RESTRICT:
1292                         if (ntokens < 2) {
1293                                 msyslog(LOG_ERR, "restrict requires an address");
1294                                 break;
1295                         }
1296                         istart = 1;
1297                         memset((char *)&peeraddr, 0, sizeof(peeraddr));
1298                         peeraddr.ss_family = default_ai_family;
1299                         switch (matchkey(tokens[istart], addr_type, 0)) {
1300                         case CONF_ADDR_IPV4:
1301                                 peeraddr.ss_family = AF_INET;
1302                                 istart++;
1303                                 break;
1304                         case CONF_ADDR_IPV6:
1305                                 peeraddr.ss_family = AF_INET6;
1306                                 istart++;
1307                                 break;
1308                         }
1309
1310                         /*
1311                          * Assume default means an IPv4 address, except
1312                          * if forced by a -4 or -6.
1313                          */
1314                         if (STREQ(tokens[istart], "default")) {
1315                                 if (peeraddr.ss_family == 0)
1316                                         peeraddr.ss_family = AF_INET;
1317                         } else if (getnetnum(tokens[istart], &peeraddr, 1,
1318                                               t_UNK) != 1)
1319                                 break;
1320
1321                         /*
1322                          * Use peerversion as flags, peerkey as mflags.  Ick.
1323                          */
1324                         peerversion = 0;
1325                         peerkey = 0;
1326                         errflg = 0;
1327                         SET_HOSTMASK(&maskaddr, peeraddr.ss_family);
1328                         istart++;
1329                         for (i = istart; i < ntokens; i++) {
1330                                 switch (matchkey(tokens[i], res_keywords, 1)) {
1331                                     case CONF_RES_MASK:
1332                                         if (i >= ntokens-1) {
1333                                                 msyslog(LOG_ERR,
1334                                                         "mask keyword needs argument");
1335                                                 errflg++;
1336                                                 break;
1337                                         }
1338                                         i++;
1339                                         if (getnetnum(tokens[i], &maskaddr, 1,
1340                                                        t_MSK) != 1)
1341                                             errflg++;
1342                                         break;
1343
1344                                     case CONF_RES_IGNORE:
1345                                         peerversion |= RES_IGNORE;
1346                                         break;
1347
1348                                     case CONF_RES_NOSERVE:
1349                                         peerversion |= RES_DONTSERVE;
1350                                         break;
1351
1352                                     case CONF_RES_NOTRUST:
1353                                         peerversion |= RES_DONTTRUST;
1354                                         break;
1355
1356                                     case CONF_RES_NOQUERY:
1357                                         peerversion |= RES_NOQUERY;
1358                                         break;
1359
1360                                     case CONF_RES_NOMODIFY:
1361                                         peerversion |= RES_NOMODIFY;
1362                                         break;
1363
1364                                     case CONF_RES_NOPEER:
1365                                         peerversion |= RES_NOPEER;
1366                                         break;
1367
1368                                     case CONF_RES_NOTRAP:
1369                                         peerversion |= RES_NOTRAP;
1370                                         break;
1371
1372                                     case CONF_RES_LPTRAP:
1373                                         peerversion |= RES_LPTRAP;
1374                                         break;
1375
1376                                     case CONF_RES_NTPPORT:
1377                                         peerkey |= RESM_NTPONLY;
1378                                         break;
1379
1380                                     case CONF_RES_VERSION:
1381                                         peerversion |= RES_VERSION;
1382                                         break;
1383
1384                                     case CONF_RES_DEMOBILIZE:
1385                                         peerversion |= RES_DEMOBILIZE;
1386                                         break;
1387
1388                                     case CONF_RES_LIMITED:
1389                                         peerversion |= RES_LIMITED;
1390                                         break;
1391
1392                                     case CONFIG_UNKNOWN:
1393                                         errflg++;
1394                                         break;
1395                                 }
1396                         }
1397                         if (SOCKNUL(&peeraddr))
1398                             ANYSOCK(&maskaddr);
1399                         if (!errflg)
1400                             hack_restrict(RESTRICT_FLAGS, &peeraddr, &maskaddr,
1401                                           (int)peerkey, peerversion);
1402                         break;
1403
1404                     case CONFIG_BDELAY:
1405                         if (ntokens >= 2) {
1406                                 double tmp;
1407
1408                                 if (sscanf(tokens[1], "%lf", &tmp) != 1) {
1409                                         msyslog(LOG_ERR,
1410                                                 "broadcastdelay value %s undecodable",
1411                                                 tokens[1]);
1412                                 } else {
1413                                         proto_config(PROTO_BROADDELAY, 0, tmp, NULL);
1414                                 }
1415                         }
1416                         break;
1417
1418                     case CONFIG_CDELAY:
1419                         if (ntokens >= 2) {
1420                                 u_long ui;
1421
1422                                 if (sscanf(tokens[1], "%ld", &ui) != 1)
1423                                         msyslog(LOG_ERR,
1424                                             "illegal value - line ignored");
1425                                 else
1426                                         proto_config(PROTO_CALLDELAY, ui, 0, NULL);
1427                         }
1428                         break;
1429
1430                     case CONFIG_TRUSTEDKEY:
1431                         for (i = 1; i < ntokens; i++) {
1432                                 keyid_t tkey;
1433
1434                                 tkey = atol(tokens[i]);
1435                                 if (tkey == 0) {
1436                                         msyslog(LOG_ERR,
1437                                                 "trusted key %s unlikely",
1438                                                 tokens[i]);
1439                                 } else {
1440                                         authtrust(tkey, 1);
1441                                 }
1442                         }
1443                         break;
1444
1445                     case CONFIG_REQUESTKEY:
1446                         if (ntokens >= 2) {
1447                                 if (!atouint(tokens[1], &ul)) {
1448                                         msyslog(LOG_ERR,
1449                                                 "%s is undecodable as request key",
1450                                                 tokens[1]);
1451                                 } else if (ul == 0) {
1452                                         msyslog(LOG_ERR,
1453                                                 "%s makes a poor request keyid",
1454                                                 tokens[1]);
1455                                 } else {
1456 #ifdef DEBUG
1457                                         if (debug > 3)
1458                                             printf(
1459                                                     "set info_auth_key to %08lx\n", ul);
1460 #endif
1461                                         info_auth_keyid = (keyid_t)ul;
1462                                 }
1463                         }
1464                         break;
1465
1466                     case CONFIG_CONTROLKEY:
1467                         if (ntokens >= 2) {
1468                                 keyid_t ckey;
1469
1470                                 ckey = atol(tokens[1]);
1471                                 if (ckey == 0) {
1472                                         msyslog(LOG_ERR,
1473                                                 "%s makes a poor control keyid",
1474                                                 tokens[1]);
1475                                 } else {
1476                                         ctl_auth_keyid = ckey;
1477                                 }
1478                         }
1479                         break;
1480
1481                     case CONFIG_TRAP:
1482                         if (ntokens < 2) {
1483                                 msyslog(LOG_ERR,
1484                                         "no address for trap command, line ignored");
1485                                 break;
1486                         }
1487                         istart = 1;
1488                         memset((char *)&peeraddr, 0, sizeof(peeraddr));
1489                         peeraddr.ss_family = default_ai_family;
1490                         switch (matchkey(tokens[istart], addr_type, 0)) {
1491                         case CONF_ADDR_IPV4:
1492                                 peeraddr.ss_family = AF_INET;
1493                                 istart++;
1494                                 break;
1495                         case CONF_ADDR_IPV6:
1496                                 peeraddr.ss_family = AF_INET6;
1497                                 istart++;
1498                                 break;
1499                         }
1500
1501                         if (getnetnum(tokens[istart], &peeraddr, 1, t_UNK) != 1)
1502                             break;
1503
1504                         /*
1505                          * Use peerversion for port number.  Barf.
1506                          */
1507                         errflg = 0;
1508                         peerversion = 0;
1509                         localaddr = 0;
1510                         istart++;
1511                         for (i = istart; i < ntokens-1; i++)
1512                             switch (matchkey(tokens[i], trap_keywords, 1)) {
1513                                 case CONF_TRAP_PORT:
1514                                     if (i >= ntokens-1) {
1515                                             msyslog(LOG_ERR,
1516                                                     "trap port requires an argument");
1517                                             errflg = 1;
1518                                             break;
1519                                     }
1520                                     peerversion = atoi(tokens[++i]);
1521                                     if (peerversion <= 0
1522                                         || peerversion > 32767) {
1523                                             msyslog(LOG_ERR,
1524                                                     "invalid port number %s, trap ignored",
1525                                                     tokens[i]);
1526                                             errflg = 1;
1527                                     }
1528                                     break;
1529
1530                                 case CONF_TRAP_INTERFACE:
1531                                     if (i >= ntokens-1) {
1532                                             msyslog(LOG_ERR,
1533                                                     "trap interface requires an argument");
1534                                             errflg = 1;
1535                                             break;
1536                                     }
1537
1538                                     memset((char *)&maskaddr, 0,
1539                                         sizeof(maskaddr));
1540                                     maskaddr.ss_family = peeraddr.ss_family;
1541                                     if (getnetnum(tokens[++i],
1542                                                    &maskaddr, 1, t_UNK) != 1) {
1543                                             errflg = 1;
1544                                             break;
1545                                     }
1546
1547                                     localaddr = findinterface(&maskaddr);
1548                                     if (localaddr == NULL) {
1549                                             msyslog(LOG_ERR,
1550                                                     "can't find interface with address %s",
1551                                                     stoa(&maskaddr));
1552                                             errflg = 1;
1553                                     }
1554                                     break;
1555
1556                                 case CONFIG_UNKNOWN:
1557                                     errflg++;
1558                                     break;
1559                             }
1560
1561                         if (!errflg) {
1562                                 if (peerversion != 0)
1563                                     ((struct sockaddr_in6*)&peeraddr)->sin6_port = htons( (u_short) peerversion);
1564                                 else
1565                                     ((struct sockaddr_in6*)&peeraddr)->sin6_port = htons(TRAPPORT);
1566                                 if (localaddr == NULL)
1567                                     localaddr = ANY_INTERFACE_CHOOSE(&peeraddr);
1568                                 if (!ctlsettrap(&peeraddr, localaddr, 0,
1569                                                 NTP_VERSION))
1570                                     msyslog(LOG_ERR,
1571                                             "can't set trap for %s, no resources",
1572                                             stoa(&peeraddr));
1573                         }
1574                         break;
1575
1576                     case CONFIG_FUDGE:
1577                         if (ntokens < 2) {
1578                                 msyslog(LOG_ERR,
1579                                         "no address for fudge command, line ignored");
1580                                 break;
1581                         }
1582                         memset((char *)&peeraddr, 0, sizeof(peeraddr));
1583                         if (getnetnum(tokens[1], &peeraddr, 1, t_REF) != 1)
1584                             break;
1585
1586                         if (!ISREFCLOCKADR(&peeraddr)) {
1587                                 msyslog(LOG_ERR,
1588                                         "%s is inappropriate address for the fudge command, line ignored",
1589                                         stoa(&peeraddr));
1590                                 break;
1591                         }
1592
1593                         memset((void *)&clock_stat, 0, sizeof clock_stat);
1594                         fudgeflag = 0;
1595                         errflg = 0;
1596                         for (i = 2; i < ntokens-1; i++) {
1597                                 switch (c = matchkey(tokens[i],
1598                                     fudge_keywords, 1)) {
1599                                     case CONF_FDG_TIME1:
1600                                         if (sscanf(tokens[++i], "%lf",
1601                                                    &clock_stat.fudgetime1) != 1) {
1602                                                 msyslog(LOG_ERR,
1603                                                         "fudge %s time1 value in error",
1604                                                         stoa(&peeraddr));
1605                                                 errflg = i;
1606                                                 break;
1607                                         }
1608                                         clock_stat.haveflags |= CLK_HAVETIME1;
1609                                         break;
1610
1611                                     case CONF_FDG_TIME2:
1612                                         if (sscanf(tokens[++i], "%lf",
1613                                                    &clock_stat.fudgetime2) != 1) {
1614                                                 msyslog(LOG_ERR,
1615                                                         "fudge %s time2 value in error",
1616                                                         stoa(&peeraddr));
1617                                                 errflg = i;
1618                                                 break;
1619                                         }
1620                                         clock_stat.haveflags |= CLK_HAVETIME2;
1621                                         break;
1622
1623
1624                                     case CONF_FDG_STRATUM:
1625                                       if (!atoint(tokens[++i], &stratum))
1626                                         {
1627                                                 msyslog(LOG_ERR,
1628                                                         "fudge %s stratum value in error",
1629                                                         stoa(&peeraddr));
1630                                                 errflg = i;
1631                                                 break;
1632                                         }
1633                                         clock_stat.fudgeval1 = stratum;
1634                                         clock_stat.haveflags |= CLK_HAVEVAL1;
1635                                         break;
1636
1637                                     case CONF_FDG_REFID:
1638                                         i++;
1639                                         memcpy(&clock_stat.fudgeval2,
1640                                             tokens[i], min(strlen(tokens[i]),
1641                                             4));
1642                                         clock_stat.haveflags |= CLK_HAVEVAL2;
1643                                         break;
1644
1645                                     case CONF_FDG_FLAG1:
1646                                     case CONF_FDG_FLAG2:
1647                                     case CONF_FDG_FLAG3:
1648                                     case CONF_FDG_FLAG4:
1649                                         if (!atouint(tokens[++i], &fudgeflag)
1650                                             || fudgeflag > 1) {
1651                                                 msyslog(LOG_ERR,
1652                                                         "fudge %s flag value in error",
1653                                                         stoa(&peeraddr));
1654                                                 errflg = i;
1655                                                 break;
1656                                         }
1657                                         switch(c) {
1658                                             case CONF_FDG_FLAG1:
1659                                                 c = CLK_FLAG1;
1660                                                 clock_stat.haveflags|=CLK_HAVEFLAG1;
1661                                                 break;
1662                                             case CONF_FDG_FLAG2:
1663                                                 c = CLK_FLAG2;
1664                                                 clock_stat.haveflags|=CLK_HAVEFLAG2;
1665                                                 break;
1666                                             case CONF_FDG_FLAG3:
1667                                                 c = CLK_FLAG3;
1668                                                 clock_stat.haveflags|=CLK_HAVEFLAG3;
1669                                                 break;
1670                                             case CONF_FDG_FLAG4:
1671                                                 c = CLK_FLAG4;
1672                                                 clock_stat.haveflags|=CLK_HAVEFLAG4;
1673                                                 break;
1674                                         }
1675                                         if (fudgeflag == 0)
1676                                             clock_stat.flags &= ~c;
1677                                         else
1678                                             clock_stat.flags |= c;
1679                                         break;
1680
1681                                     case CONFIG_UNKNOWN:
1682                                         errflg = -1;
1683                                         break;
1684                                 }
1685                         }
1686
1687 #ifdef REFCLOCK
1688                         /*
1689                          * If reference clock support isn't defined the
1690                          * fudge line will still be accepted and syntax
1691                          * checked, but will essentially do nothing.
1692                          */
1693                         if (!errflg) {
1694                                 refclock_control(&peeraddr, &clock_stat,
1695                                     (struct refclockstat *)0);
1696                         }
1697 #endif
1698                         break;
1699
1700                     case CONFIG_STATSDIR:
1701                         if (ntokens >= 2)
1702                                 stats_config(STATS_STATSDIR,tokens[1]);
1703                         break;
1704
1705                     case CONFIG_STATISTICS:
1706                         for (i = 1; i < ntokens; i++) {
1707                                 filegen = filegen_get(tokens[i]);
1708
1709                                 if (filegen == NULL) {
1710                                         msyslog(LOG_ERR,
1711                                                 "no statistics named %s available",
1712                                                 tokens[i]);
1713                                         continue;
1714                                 }
1715 #ifdef DEBUG
1716                                 if (debug > 3)
1717                                     printf("enabling filegen for %s statistics \"%s%s\"\n",
1718                                            tokens[i], filegen->prefix, filegen->basename);
1719 #endif
1720                                 filegen->flag |= FGEN_FLAG_ENABLED;
1721                         }
1722                         break;
1723
1724                     case CONFIG_FILEGEN:
1725                         if (ntokens < 2) {
1726                                 msyslog(LOG_ERR,
1727                                         "no id for filegen command, line ignored");
1728                                 break;
1729                         }
1730
1731                         filegen = filegen_get(tokens[1]);
1732                         if (filegen == NULL) {
1733                                 msyslog(LOG_ERR,
1734                                         "unknown filegen \"%s\" ignored",
1735                                         tokens[1]);
1736                                 break;
1737                         }
1738                         /*
1739                          * peerversion is (ab)used for filegen file (index)
1740                          * peerkey         is (ab)used for filegen type
1741                          * peerflags   is (ab)used for filegen flags
1742                          */
1743                         peerversion = 0;
1744                         peerkey =         filegen->type;
1745                         peerflags =   filegen->flag;
1746                         errflg = 0;
1747
1748                         for (i = 2; i < ntokens; i++) {
1749                                 switch (matchkey(tokens[i],
1750                                     filegen_keywords, 1)) {
1751                                     case CONF_FGEN_FILE:
1752                                         if (i >= ntokens - 1) {
1753                                                 msyslog(LOG_ERR,
1754                                                         "filegen %s file requires argument",
1755                                                         tokens[1]);
1756                                                 errflg = i;
1757                                                 break;
1758                                         }
1759                                         peerversion = ++i;
1760                                         break;
1761                                     case CONF_FGEN_TYPE:
1762                                         if (i >= ntokens -1) {
1763                                                 msyslog(LOG_ERR,
1764                                                         "filegen %s type requires argument",
1765                                                         tokens[1]);
1766                                                 errflg = i;
1767                                                 break;
1768                                         }
1769                                         peerkey = matchkey(tokens[++i],
1770                                             fgen_types, 1);
1771                                         if (peerkey == CONFIG_UNKNOWN) {
1772                                                 msyslog(LOG_ERR,
1773                                                         "filegen %s unknown type \"%s\"",
1774                                                         tokens[1], tokens[i]);
1775                                                 errflg = i;
1776                                                 break;
1777                                         }
1778                                         break;
1779
1780                                     case CONF_FGEN_FLAG_LINK:
1781                                         peerflags |= FGEN_FLAG_LINK;
1782                                         break;
1783
1784                                     case CONF_FGEN_FLAG_NOLINK:
1785                                         peerflags &= ~FGEN_FLAG_LINK;
1786                                         break;
1787
1788                                     case CONF_FGEN_FLAG_ENABLE:
1789                                         peerflags |= FGEN_FLAG_ENABLED;
1790                                         break;
1791
1792                                     case CONF_FGEN_FLAG_DISABLE:
1793                                         peerflags &= ~FGEN_FLAG_ENABLED;
1794                                         break;
1795                                 }
1796                         }
1797                         if (!errflg)
1798                                 filegen_config(filegen, tokens[peerversion],
1799                                    (u_char)peerkey, (u_char)peerflags);
1800                         break;
1801
1802                     case CONFIG_SETVAR:
1803                         if (ntokens < 2) {
1804                                 msyslog(LOG_ERR,
1805                                         "no value for setvar command - line ignored");
1806                         } else {
1807                                 set_sys_var(tokens[1], strlen(tokens[1])+1,
1808                                             (u_short) (RW |
1809                                             ((((ntokens > 2)
1810                                                && !strcmp(tokens[2],
1811                                                           "default")))
1812                                              ? DEF
1813                                              : 0)));
1814                         }
1815                         break;
1816
1817                     case CONFIG_ENABLE:
1818                         for (i = 1; i < ntokens; i++) {
1819                                 int flag;
1820
1821                                 flag = matchkey(tokens[i], flags_keywords, 1);
1822                                 if (flag == CONFIG_UNKNOWN) {
1823                                         msyslog(LOG_ERR,
1824                                                 "enable unknown flag %s",
1825                                                 tokens[i]);
1826                                         errflg = 1;
1827                                         break;
1828                                 }
1829                                 proto_config(flag, 1, 0., NULL);
1830                         }
1831                         break;
1832
1833                     case CONFIG_DISABLE:
1834                         for (i = 1; i < ntokens; i++) {
1835                                 int flag;
1836
1837                                 flag = matchkey(tokens[i], flags_keywords, 1);
1838                                 if (flag == CONFIG_UNKNOWN) {
1839                                         msyslog(LOG_ERR,
1840                                                 "disable unknown flag %s",
1841                                                 tokens[i]);
1842                                         errflg = 1;
1843                                         break;
1844                                 }
1845                                 proto_config(flag, 0, 0., NULL);
1846                         }
1847                         break;
1848
1849                     case CONFIG_PHONE:
1850                         for (i = 1; i < ntokens && i < MAXPHONE - 1; i++) {
1851                                 sys_phone[i - 1] =
1852                                     emalloc(strlen(tokens[i]) + 1);
1853                                 strcpy(sys_phone[i - 1], tokens[i]);
1854                         }
1855                         sys_phone[i] = NULL;
1856                         break;
1857
1858                     case CONFIG_ADJ: {
1859                             double ftemp;
1860
1861                             sscanf(tokens[1], "%lf", &ftemp);
1862                             proto_config(PROTO_ADJ, 0, ftemp, NULL);
1863                         }
1864                         break;
1865
1866                 }
1867         }
1868         if (fp[0])
1869                 (void)fclose(fp[0]);
1870
1871 #ifdef HAVE_NETINFO
1872         if (config_netinfo)
1873                 free_netinfo_config(config_netinfo);
1874 #endif /* HAVE_NETINFO */
1875
1876 #if !defined(VMS) && !defined(SYS_VXWORKS)
1877         /* find a keyid */
1878         if (info_auth_keyid == 0)
1879                 req_keyid = 65535;
1880         else
1881                 req_keyid = info_auth_keyid;
1882
1883         /* if doesn't exist, make up one at random */
1884         if (!authhavekey(req_keyid)) {
1885                 char rankey[9];
1886                 int j;
1887
1888                 for (i = 0; i < 8; i++)
1889                         for (j = 1; j < 100; ++j) {
1890                                 rankey[i] = (char) (arc4random() & 0xff);
1891                                 if (rankey[i] != 0) break;
1892                         }
1893                 rankey[8] = 0;
1894                 authusekey(req_keyid, KEY_TYPE_MD5, (u_char *)rankey);
1895                 authtrust(req_keyid, 1);
1896                 if (!authhavekey(req_keyid)) {
1897                         msyslog(LOG_ERR, "getconfig: Couldn't generate a valid random key!");
1898                         /* HMS: Should this be fatal? */
1899                 }
1900         }
1901
1902         /* save keyid so we will accept config requests with it */
1903         info_auth_keyid = req_keyid;
1904 #endif /* !defined(VMS) && !defined(SYS_VXWORKS) */
1905
1906         if (res_fp != NULL) {
1907                 if (call_resolver) {
1908                         /*
1909                          * Need name resolution
1910                          */
1911                         do_resolve_internal();
1912                 }
1913         }
1914 }
1915
1916
1917 #ifdef HAVE_NETINFO
1918
1919 /*
1920  * get_netinfo_config - find the nearest NetInfo domain with an ntp
1921  * configuration and initialize the configuration state.
1922  */
1923 static struct netinfo_config_state *
1924 get_netinfo_config()
1925 {
1926         ni_status status;
1927         void *domain;
1928         ni_id config_dir;
1929         struct netinfo_config_state *config;
1930
1931         if (ni_open(NULL, ".", &domain) != NI_OK) return NULL;
1932
1933         while ((status = ni_pathsearch(domain, &config_dir, NETINFO_CONFIG_DIR)) == NI_NODIR) {
1934                 void *next_domain;
1935                 if (ni_open(domain, "..", &next_domain) != NI_OK) {
1936                         ni_free(next_domain);
1937                         break;
1938                 }
1939                 ni_free(domain);
1940                 domain = next_domain;
1941         }
1942         if (status != NI_OK) {
1943                 ni_free(domain);
1944                 return NULL;
1945         }
1946
1947         config = (struct netinfo_config_state *)malloc(sizeof(struct netinfo_config_state));
1948         config->domain = domain;
1949         config->config_dir = config_dir;
1950         config->prop_index = 0;
1951         config->val_index = 0;
1952         config->val_list = NULL;
1953
1954         return config;
1955 }
1956
1957
1958
1959 /*
1960  * free_netinfo_config - release NetInfo configuration state
1961  */
1962 static void
1963 free_netinfo_config(struct netinfo_config_state *config)
1964 {
1965         ni_free(config->domain);
1966         free(config);
1967 }
1968
1969
1970
1971 /*
1972  * gettokens_netinfo - return tokens from NetInfo
1973  */
1974 static int
1975 gettokens_netinfo (
1976         struct netinfo_config_state *config,
1977         char **tokenlist,
1978         int *ntokens
1979         )
1980 {
1981         int prop_index = config->prop_index;
1982         int val_index = config->val_index;
1983         char **val_list = config->val_list;
1984
1985         /*
1986          * Iterate through each keyword and look for a property that matches it.
1987          */
1988         again:
1989         if (!val_list) {
1990                 for (; prop_index < (sizeof(keywords)/sizeof(keywords[0])); prop_index++)
1991                 {
1992                         ni_namelist namelist;
1993                         struct keyword current_prop = keywords[prop_index];
1994
1995                         /*
1996                          * For each value associated in the property, we're going to return
1997                          * a separate line. We squirrel away the values in the config state
1998                          * so the next time through, we don't need to do this lookup.
1999                          */
2000                         NI_INIT(&namelist);
2001                         if (ni_lookupprop(config->domain, &config->config_dir, current_prop.text, &namelist) == NI_OK) {
2002                                 ni_index index;
2003
2004                                 /* Found the property, but it has no values */
2005                                 if (namelist.ni_namelist_len == 0) continue;
2006
2007                                 if (! (val_list = config->val_list = (char**)malloc(sizeof(char*) * (namelist.ni_namelist_len + 1))))
2008                                         { msyslog(LOG_ERR, "out of memory while configuring"); break; }
2009
2010                                 for (index = 0; index < namelist.ni_namelist_len; index++) {
2011                                         char *value = namelist.ni_namelist_val[index];
2012
2013                                         if (! (val_list[index] = (char*)malloc(strlen(value)+1)))
2014                                                 { msyslog(LOG_ERR, "out of memory while configuring"); break; }
2015
2016                                         strcpy(val_list[index], value);
2017                                 }
2018                                 val_list[index] = NULL;
2019
2020                                 break;
2021                         }
2022                         ni_namelist_free(&namelist);
2023                 }
2024                 config->prop_index = prop_index;
2025         }
2026
2027         /* No list; we're done here. */
2028         if (!val_list) return CONFIG_UNKNOWN;
2029
2030         /*
2031          * We have a list of values for the current property.
2032          * Iterate through them and return each in order.
2033          */
2034         if (val_list[val_index])
2035         {
2036                 int ntok = 1;
2037                 int quoted = 0;
2038                 char *tokens = val_list[val_index];
2039
2040                 msyslog(LOG_INFO, "%s %s", keywords[prop_index].text, val_list[val_index]);
2041
2042                 (const char*)tokenlist[0] = keywords[prop_index].text;
2043                 for (ntok = 1; ntok < MAXTOKENS; ntok++) {
2044                         tokenlist[ntok] = tokens;
2045                         while (!ISEOL(*tokens) && (!ISSPACE(*tokens) || quoted))
2046                                 quoted ^= (*tokens++ == '"');
2047
2048                         if (ISEOL(*tokens)) {
2049                                 *tokens = '\0';
2050                                 break;
2051                         } else {                /* must be space */
2052                                 *tokens++ = '\0';
2053                                 while (ISSPACE(*tokens)) tokens++;
2054                                 if (ISEOL(*tokens)) break;
2055                         }
2056                 }
2057
2058                 if (ntok == MAXTOKENS) {
2059                         /* HMS: chomp it to lose the EOL? */
2060                         msyslog(LOG_ERR,
2061                             "gettokens_netinfo: too many tokens.  Ignoring: %s",
2062                             tokens);
2063                 } else {
2064                         *ntokens = ntok + 1;
2065                 }
2066
2067                 config->val_index++;    /* HMS: Should this be in the 'else'? */
2068
2069                 return keywords[prop_index].keytype;
2070         }
2071
2072         /* We're done with the current property. */
2073         prop_index = ++config->prop_index;
2074
2075         /* Free val_list and reset counters. */
2076         for (val_index = 0; val_list[val_index]; val_index++)
2077                 free(val_list[val_index]);
2078         free(val_list); val_list = config->val_list = NULL; val_index = config->val_index = 0;
2079
2080         goto again;
2081 }
2082
2083 #endif /* HAVE_NETINFO */
2084
2085
2086 /*
2087  * gettokens - read a line and return tokens
2088  */
2089 static int
2090 gettokens (
2091         FILE *fp,
2092         char *line,
2093         char **tokenlist,
2094         int *ntokens
2095         )
2096 {
2097         register char *cp;
2098         register int ntok;
2099         register int quoted = 0;
2100
2101         /*
2102          * Find start of first token
2103          */
2104         again:
2105         while ((cp = fgets(line, MAXLINE, fp)) != NULL) {
2106                 cp = line;
2107                 while (ISSPACE(*cp))
2108                         cp++;
2109                 if (!ISEOL(*cp))
2110                         break;
2111         }
2112         if (cp == NULL) {
2113                 *ntokens = 0;
2114                 return CONFIG_UNKNOWN;  /* hack.  Is recognized as EOF */
2115         }
2116
2117         /*
2118          * Now separate out the tokens
2119          */
2120         for (ntok = 0; ntok < MAXTOKENS; ntok++) {
2121                 tokenlist[ntok] = cp;
2122                 while (!ISEOL(*cp) && (!ISSPACE(*cp) || quoted))
2123                         quoted ^= (*cp++ == '"');
2124
2125                 if (ISEOL(*cp)) {
2126                         *cp = '\0';
2127                         break;
2128                 } else {                /* must be space */
2129                         *cp++ = '\0';
2130                         while (ISSPACE(*cp))
2131                                 cp++;
2132                         if (ISEOL(*cp))
2133                                 break;
2134                 }
2135         }
2136
2137      /* Heiko: Remove leading and trailing quotes around tokens */
2138      {
2139             int i,j = 0;
2140
2141
2142                         for (i = 0; i < ntok; i++) {
2143                                         /* Now check if the first char is a quote and remove that */
2144                                         if ( tokenlist[ntok][0] == '"' )
2145                                                         tokenlist[ntok]++;
2146
2147                                         /* Now check the last char ... */
2148                                         j = strlen(tokenlist[ntok])-1;
2149                                         if ( tokenlist[ntok][j] == '"' )
2150                                                         tokenlist[ntok][j] = '\0';
2151                         }
2152
2153     }
2154
2155         if (ntok == MAXTOKENS) {
2156                 --ntok;
2157                 /* HMS: chomp it to lose the EOL? */
2158                 msyslog(LOG_ERR,
2159                     "gettokens: too many tokens on the line. Ignoring %s",
2160                     cp);
2161         } else {
2162                 /*
2163                  * Return the match
2164                  */
2165                 *ntokens = ntok + 1;
2166                 ntok = matchkey(tokenlist[0], keywords, 1);
2167                 if (ntok == CONFIG_UNKNOWN)
2168                         goto again;
2169         }
2170
2171         return ntok;
2172 }
2173
2174
2175
2176 /*
2177  * matchkey - match a keyword to a list
2178  */
2179 static int
2180 matchkey(
2181         register char *word,
2182         register struct keyword *keys,
2183         int complain
2184         )
2185 {
2186         for (;;) {
2187                 if (keys->keytype == CONFIG_UNKNOWN) {
2188                         if (complain)
2189                                 msyslog(LOG_ERR,
2190                                     "configure: keyword \"%s\" unknown, line ignored",
2191                                     word);
2192                         return CONFIG_UNKNOWN;
2193                 }
2194                 if (STRSAME(word, keys->text))
2195                         return keys->keytype;
2196                 keys++;
2197         }
2198 }
2199
2200
2201 /*
2202  * getnetnum - return a net number (this is crude, but careful)
2203  */
2204 static int
2205 getnetnum(
2206         const char *num,
2207         struct sockaddr_storage *addr,
2208         int complain,
2209         enum gnn_type a_type
2210         )
2211 {
2212         struct addrinfo hints;
2213         struct addrinfo *ptr;
2214         int retval;
2215
2216 #if 0
2217         printf("getnetnum: <%s> is a %s (%d)\n",
2218                 num,
2219                 (a_type == t_UNK)
2220                 ? "t_UNK"
2221                 : (a_type == t_REF)
2222                   ? "t_REF"
2223                   : (a_type == t_MSK)
2224                     ? "t_MSK"
2225                     : "???",
2226                 a_type);
2227 #endif
2228
2229         /* Get host address. Looking for UDP datagram connection */
2230         memset(&hints, 0, sizeof (hints));
2231         if (addr->ss_family == AF_INET || addr->ss_family == AF_INET6)
2232             hints.ai_family = addr->ss_family;
2233         else
2234             hints.ai_family = AF_UNSPEC;
2235         /*
2236          * If we don't have an IPv6 stack, just look up IPv4 addresses
2237          */
2238         if (isc_net_probeipv6() != ISC_R_SUCCESS)
2239                 hints.ai_family = AF_INET;
2240
2241         hints.ai_socktype = SOCK_DGRAM;
2242
2243         if (a_type != t_UNK) {
2244                 hints.ai_flags = AI_NUMERICHOST;
2245         }
2246
2247 #ifdef DEBUG
2248         if (debug > 3)
2249                 printf("getnetnum: calling getaddrinfo(%s,...)\n", num);
2250 #endif
2251         retval = getaddrinfo(num, "ntp", &hints, &ptr);
2252         if (retval != 0 ||
2253            (ptr->ai_family == AF_INET6 && isc_net_probeipv6() != ISC_R_SUCCESS)) {
2254                 if (complain)
2255                         msyslog(LOG_ERR,
2256                                 "getaddrinfo: \"%s\" invalid host address, ignored",
2257                                 num);
2258 #ifdef DEBUG
2259                 if (debug > 0)
2260                         printf(
2261                                 "getaddrinfo: \"%s\" invalid host address%s.\n",
2262                                 num, (complain)
2263                                 ? ", ignored"
2264                                 : "");
2265 #endif
2266                 if (retval == 0 &&
2267                     ptr->ai_family == AF_INET6 &&
2268                     isc_net_probeipv6() != ISC_R_SUCCESS)
2269                 {
2270                         return -1;
2271                 }
2272                 else {
2273                         return 0;
2274                 }
2275         }
2276
2277         memcpy(addr, ptr->ai_addr, ptr->ai_addrlen);
2278 #ifdef DEBUG
2279         if (debug > 1)
2280                 printf("getnetnum given %s, got %s (%s/%d)\n",
2281                    num, stoa(addr),
2282                         (a_type == t_UNK)
2283                         ? "t_UNK"
2284                         : (a_type == t_REF)
2285                           ? "t_REF"
2286                           : (a_type == t_MSK)
2287                             ? "t_MSK"
2288                             : "???",
2289                         a_type);
2290 #endif
2291         freeaddrinfo(ptr);
2292         return 1;
2293 }
2294
2295
2296 #if !defined(VMS) && !defined(SYS_WINNT)
2297 /*
2298  * catchchild - receive the resolver's exit status
2299  */
2300 static RETSIGTYPE
2301 catchchild(
2302         int sig
2303         )
2304 {
2305         /*
2306          * We only start up one child, and if we're here
2307          * it should have already exited.  Hence the following
2308          * shouldn't hang.  If it does, please tell me.
2309          */
2310 #if !defined (SYS_WINNT) && !defined(SYS_VXWORKS)
2311         (void) wait(0);
2312 #endif /* SYS_WINNT  && VXWORKS*/
2313 }
2314 #endif /* VMS */
2315
2316
2317 /*
2318  * save_resolve - save configuration info into a file for later name resolution
2319  */
2320 static void
2321 save_resolve(
2322         char *name,
2323         int mode,
2324         int version,
2325         int minpoll,
2326         int maxpoll,
2327         u_int flags,
2328         int ttl,
2329         keyid_t keyid,
2330         u_char *keystr,
2331         u_char peeraf
2332         )
2333 {
2334 #ifndef SYS_VXWORKS
2335         if (res_fp == NULL) {
2336 #ifndef SYS_WINNT
2337                 (void) strcpy(res_file, RES_TEMPFILE);
2338 #else
2339                 /* no /tmp directory under NT */
2340                 {
2341                         if(!(GetTempPath((DWORD)MAX_PATH, (LPTSTR)res_file))) {
2342                                 msyslog(LOG_ERR, "cannot get pathname for temporary directory: %m");
2343                                 return;
2344                         }
2345                         (void) strcat(res_file, "ntpdXXXXXX");
2346                 }
2347 #endif /* SYS_WINNT */
2348 #ifdef HAVE_MKSTEMP
2349                 {
2350                         int fd;
2351
2352                         res_fp = NULL;
2353                         if ((fd = mkstemp(res_file)) != -1)
2354                                 res_fp = fdopen(fd, "r+");
2355                 }
2356 #else
2357                 (void) mktemp(res_file);
2358                 res_fp = fopen(res_file, "w");
2359 #endif
2360                 if (res_fp == NULL) {
2361                         msyslog(LOG_ERR, "open failed for %s: %m", res_file);
2362                         return;
2363                 }
2364         }
2365 #ifdef DEBUG
2366         if (debug) {
2367                 printf("resolving %s\n", name);
2368         }
2369 #endif
2370
2371         (void)fprintf(res_fp, "%s %u %d %d %d %d %d %d %u %s\n", name, peeraf,
2372             mode, version, minpoll, maxpoll, flags, ttl, keyid, keystr);
2373 #ifdef DEBUG
2374         if (debug > 1)
2375                 printf("config: %s %u %d %d %d %d %x %d %u %s\n", name, peeraf, mode,
2376                     version, minpoll, maxpoll, flags, ttl, keyid, keystr);
2377 #endif
2378
2379 #else  /* SYS_VXWORKS */
2380         /* save resolve info to a struct */
2381 #endif /* SYS_VXWORKS */
2382 }
2383
2384
2385 /*
2386  * abort_resolve - terminate the resolver stuff and delete the file
2387  */
2388 static void
2389 abort_resolve(void)
2390 {
2391         /*
2392          * In an ideal world we would might reread the file and
2393          * log the hosts which aren't getting configured.  Since
2394          * this is too much work, however, just close and delete
2395          * the temp file.
2396          */
2397         if (res_fp != NULL)
2398                 (void) fclose(res_fp);
2399         res_fp = NULL;
2400
2401 #ifndef SYS_VXWORKS             /* we don't open the file to begin with */
2402 #if !defined(VMS)
2403         (void) unlink(res_file);
2404 #else
2405         (void) delete(res_file);
2406 #endif /* VMS */
2407 #endif /* SYS_VXWORKS */
2408 }
2409
2410
2411 /*
2412  * do_resolve_internal - start up the resolver function (not program)
2413  */
2414 /*
2415  * On VMS, this routine will simply refuse to resolve anything.
2416  *
2417  * Possible implementation: keep `res_file' in memory, do async
2418  * name resolution via QIO, update from within completion AST.
2419  * I'm unlikely to find the time for doing this, though. -wjm
2420  */
2421 static void
2422 do_resolve_internal(void)
2423 {
2424         int i;
2425
2426         if (res_fp == NULL) {
2427                 /* belch */
2428                 msyslog(LOG_ERR,
2429                         "do_resolve_internal: Fatal: res_fp == NULL");
2430                 exit(1);
2431         }
2432
2433         /* we are done with this now */
2434         (void) fclose(res_fp);
2435         res_fp = NULL;
2436
2437 #if !defined(VMS) && !defined (SYS_VXWORKS)
2438         req_file = res_file;    /* set up pointer to res file */
2439 #ifndef SYS_WINNT
2440         (void) signal_no_reset(SIGCHLD, catchchild);
2441
2442 #ifndef SYS_VXWORKS
2443         /* the parent process will write to the pipe
2444          * in order to wake up to child process
2445          * which may be waiting in a select() call
2446          * on the read fd */
2447         if (pipe(resolver_pipe_fd) < 0) {
2448                 msyslog(LOG_ERR,
2449                         "unable to open resolver pipe");
2450                 exit(1);
2451         }
2452
2453         i = fork();
2454         /* Shouldn't the code below be re-ordered?
2455          * I.e. first check if the fork() returned an error, then
2456          * check whether we're parent or child.
2457          *     Martin Burnicki
2458          */
2459         if (i == 0) {
2460                 /*
2461                  * this used to close everything
2462                  * I don't think this is necessary
2463                  */
2464                 /*
2465                  * To the unknown commenter above:
2466                  * Well, I think it's better to clean up
2467                  * after oneself. I have had problems with
2468                  * refclock-io when intres was running - things
2469                  * where fine again when ntpintres was gone.
2470                  * So some systems react erratic at least.
2471                  *
2472                  *                      Frank Kardel
2473                  *
2474                  * 94-11-16:
2475                  * Further debugging has proven that the above is
2476                  * absolutely harmful. The internal resolver
2477                  * is still in the SIGIO process group and the lingering
2478                  * async io information causes it to process requests from
2479                  * all file decriptor causing a race between the NTP daemon
2480                  * and the resolver. which then eats data when it wins 8-(.
2481                  * It is absolutly necessary to kill any IO associations
2482                  * shared with the NTP daemon.
2483                  *
2484                  * We also block SIGIO (currently no ports means to
2485                  * disable the signal handle for IO).
2486                  *
2487                  * Thanks to wgstuken@informatik.uni-erlangen.de to notice
2488                  * that it is the ntp-resolver child running into trouble.
2489                  *
2490                  * THUS:
2491                  */
2492
2493                 /* This is the child process who will read the pipe,
2494                  * so we close the write fd */
2495                 close(resolver_pipe_fd[1]);
2496                 closelog();
2497                 kill_asyncio(0);
2498
2499                 (void) signal_no_reset(SIGCHLD, SIG_DFL);
2500
2501 #ifdef DEBUG
2502                 if (0)
2503                     debug = 2;
2504 #endif
2505
2506 # ifndef LOG_DAEMON
2507                 openlog("ntpd_initres", LOG_PID);
2508 # else /* LOG_DAEMON */
2509
2510 #  ifndef LOG_NTP
2511 #   define      LOG_NTP LOG_DAEMON
2512 #  endif
2513                 openlog("ntpd_initres", LOG_PID | LOG_NDELAY, LOG_NTP);
2514 #ifndef SYS_CYGWIN32
2515 #  ifdef DEBUG
2516                 if (debug)
2517                     setlogmask(LOG_UPTO(LOG_DEBUG));
2518                 else
2519 #  endif /* DEBUG */
2520                     setlogmask(LOG_UPTO(LOG_DEBUG)); /* @@@ was INFO */
2521 # endif /* LOG_DAEMON */
2522 #endif
2523
2524                 ntp_intres();
2525
2526                 /*
2527                  * If we got here, the intres code screwed up.
2528                  * Print something so we don't die without complaint
2529                  */
2530                 msyslog(LOG_ERR, "call to ntp_intres lost");
2531                 abort_resolve();
2532                 exit(1);
2533         }
2534 #else
2535          /* vxWorks spawns a thread... -casey */
2536          i = sp (ntp_intres);
2537          /*i = taskSpawn("ntp_intres",100,VX_FP_TASK,20000,ntp_intres);*/
2538 #endif
2539         if (i == -1) {
2540                 msyslog(LOG_ERR, "fork() failed, can't start ntp_intres: %m");
2541                 (void) signal_no_reset(SIGCHLD, SIG_DFL);
2542                 abort_resolve();
2543         }
2544         else {
2545                 /* This is the parent process who will write to the pipe,
2546                  * so we close the read fd */
2547                 close(resolver_pipe_fd[0]);
2548         }
2549 #else /* SYS_WINNT */
2550         {
2551                 /* NT's equivalent of fork() is _spawn(), but the start point
2552                  * of the new process is an executable filename rather than
2553                  * a function name as desired here.
2554                  */
2555                 DWORD dwThreadId;
2556                 fflush(stdout);
2557                 ResolverEventHandle = CreateEvent(NULL, FALSE, FALSE, NULL);
2558                 if (ResolverEventHandle == NULL) {
2559                         msyslog(LOG_ERR, "Unable to create resolver event object, can't start ntp_intres");
2560                         abort_resolve();
2561                 }
2562                 ResolverThreadHandle = CreateThread(
2563                         NULL,                            /* no security attributes      */
2564                         0,                               /* use default stack size      */
2565                         (LPTHREAD_START_ROUTINE) ntp_intres, /* thread function         */
2566                         NULL,                            /* argument to thread function   */
2567                         0,                               /* use default creation flags    */
2568                         &dwThreadId);                    /* returns the thread identifier */
2569                 if (ResolverThreadHandle == NULL) {
2570                         msyslog(LOG_ERR, "CreateThread() failed, can't start ntp_intres");
2571                         CloseHandle(ResolverEventHandle);
2572                         ResolverEventHandle = NULL;
2573                         abort_resolve();
2574                 }
2575         }
2576 #endif /* SYS_WINNT */
2577 #else /* VMS  VX_WORKS */
2578         msyslog(LOG_ERR,
2579                 "Name resolution not implemented for VMS - use numeric addresses");
2580         abort_resolve();
2581 #endif /* VMS VX_WORKS */
2582 }