Deleted Added
sdiff udiff text old ( 106163 ) new ( 132451 )
full compact
ntp_config.c (106163) ntp_config.c (132451)
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

--- 4 unchanged lines hidden (view full) ---

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_config.h"
19#include "ntp_cmdargs.h"
20
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

--- 4 unchanged lines hidden (view full) ---

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_config.h"
19#include "ntp_cmdargs.h"
20
21#ifdef PUBKEY
22# include "ntp_crypto.h"
23#endif /* PUBKEY */
24
25#include <stdio.h>
26#include <ctype.h>
27#ifdef HAVE_SYS_PARAM_H
28#include <sys/param.h>
29#endif
30#include <signal.h>
31#ifndef SIGCHLD
32# define SIGCHLD SIGCLD

--- 4 unchanged lines hidden (view full) ---

37# endif
38#endif /* VMS */
39
40#ifdef SYS_WINNT
41# include <io.h>
42extern HANDLE ResolverThreadHandle;
43#endif /* SYS_WINNT */
44
21#include <stdio.h>
22#include <ctype.h>
23#ifdef HAVE_SYS_PARAM_H
24#include <sys/param.h>
25#endif
26#include <signal.h>
27#ifndef SIGCHLD
28# define SIGCHLD SIGCLD

--- 4 unchanged lines hidden (view full) ---

33# endif
34#endif /* VMS */
35
36#ifdef SYS_WINNT
37# include <io.h>
38extern HANDLE ResolverThreadHandle;
39#endif /* SYS_WINNT */
40
41#include <netdb.h>
42
45extern int priority_done;
46
47/*
48 * These routines are used to read the configuration file at
49 * startup time. An entry in the file must fit on a single line.
50 * Entries are processed as multiple tokens separated by white space
51 * Lines are considered terminated when a '#' is encountered. Blank
52 * lines are ignored.
53 */
43extern int priority_done;
44
45/*
46 * These routines are used to read the configuration file at
47 * startup time. An entry in the file must fit on a single line.
48 * Entries are processed as multiple tokens separated by white space
49 * Lines are considered terminated when a '#' is encountered. Blank
50 * lines are ignored.
51 */
54
55/*
52/*
56 * We understand the following configuration entries and defaults.
57 *
58 * peer [ addr ] [ version 3 ] [ key 0 ] [ minpoll 6 ] [ maxpoll 10 ]
59 * server [ addr ] [ version 3 ] [ key 0 ] [ minpoll 6 ] [ maxpoll 10 ]
60 * broadcast [ addr ] [ version 3 ] [ key 0 ] [ ttl 1 ]
61 * broadcastclient
62 * multicastclient [ 224.0.1.1 ]
63 * manycastclient [ addr ] [ version 3 ] [ key 0 ] [ minpoll 6 ] [ maxpoll 10 ]
64 * manycastserver [ 224.0.1.1 ]
65 * broadcastdelay 0.0102
66 * restrict [ addr ] [ mask 255.255.255.0 ] ignore|noserve|notrust|noquery
67 * driftfile file_name
68 * keys file_name
69 * publickey file_name
70 * privatekey file_name
71 * statsdir /var/NTP/
72 * filegen peerstats [ file peerstats ] [ type day ] [ link ]
73 * clientlimit [ n ]
74 * clientperiod [ 3600 ]
75 * trustedkey [ key ]
76 * requestkey [ key]
77 * controlkey [ key ]
78 * trap [ addr ]
79 * fudge [ addr ] [ stratum ] [ refid ] ...
80 * pidfile [ ]
81 * setvar [ ]
82 * logfile logfile
83 * logconfig [+|-|=][{sync|sys|peer|clock}{{,all}{info|statistics|events|status}}]...
84 * enable auth|bclient|pll|kernel|monitor|stats|calibrate
85 * disable auth|bclient|pll|kernel|monitor|stats|calibrate
86 * phone ...
87 * pps device [assert|clear] [hardpps]
88 * priority high|normal
89 */
90
91/*
92 * Translation table - keywords to function index
93 */
94struct keyword {
95 const char *text;
96 int keytype;
97};
98
99/*
100 * Command keywords
101 */
102static struct keyword keywords[] = {
53 * Translation table - keywords to function index
54 */
55struct keyword {
56 const char *text;
57 int keytype;
58};
59
60/*
61 * Command keywords
62 */
63static struct keyword keywords[] = {
103 { "authenticate", CONFIG_AUTHENTICATE },
104 { "automax", CONFIG_AUTOMAX },
105 { "broadcast", CONFIG_BROADCAST },
106 { "broadcastclient", CONFIG_BROADCASTCLIENT },
107 { "broadcastdelay", CONFIG_BDELAY },
64 { "automax", CONFIG_AUTOMAX },
65 { "broadcast", CONFIG_BROADCAST },
66 { "broadcastclient", CONFIG_BROADCASTCLIENT },
67 { "broadcastdelay", CONFIG_BDELAY },
108 { "clientlimit", CONFIG_CLIENTLIMIT },
109 { "clientperiod", CONFIG_CLIENTPERIOD },
110#ifdef PUBKEY
68 { "calldelay", CONFIG_CDELAY},
69#ifdef OPENSSL
111 { "crypto", CONFIG_CRYPTO },
70 { "crypto", CONFIG_CRYPTO },
112#endif /* PUBKEY */
71#endif /* OPENSSL */
113 { "controlkey", CONFIG_CONTROLKEY },
114 { "disable", CONFIG_DISABLE },
115 { "driftfile", CONFIG_DRIFTFILE },
116 { "enable", CONFIG_ENABLE },
117 { "filegen", CONFIG_FILEGEN },
118 { "fudge", CONFIG_FUDGE },
119 { "includefile", CONFIG_INCLUDEFILE },
120 { "keys", CONFIG_KEYS },
72 { "controlkey", CONFIG_CONTROLKEY },
73 { "disable", CONFIG_DISABLE },
74 { "driftfile", CONFIG_DRIFTFILE },
75 { "enable", CONFIG_ENABLE },
76 { "filegen", CONFIG_FILEGEN },
77 { "fudge", CONFIG_FUDGE },
78 { "includefile", CONFIG_INCLUDEFILE },
79 { "keys", CONFIG_KEYS },
121#ifdef PUBKEY
122 { "keysdir", CONFIG_KEYSDIR },
80 { "keysdir", CONFIG_KEYSDIR },
123#endif /* PUBKEY */
124 { "logconfig", CONFIG_LOGCONFIG },
125 { "logfile", CONFIG_LOGFILE },
126 { "manycastclient", CONFIG_MANYCASTCLIENT },
127 { "manycastserver", CONFIG_MANYCASTSERVER },
128 { "multicastclient", CONFIG_MULTICASTCLIENT },
129 { "peer", CONFIG_PEER },
130 { "phone", CONFIG_PHONE },
131 { "pidfile", CONFIG_PIDFILE },
81 { "logconfig", CONFIG_LOGCONFIG },
82 { "logfile", CONFIG_LOGFILE },
83 { "manycastclient", CONFIG_MANYCASTCLIENT },
84 { "manycastserver", CONFIG_MANYCASTSERVER },
85 { "multicastclient", CONFIG_MULTICASTCLIENT },
86 { "peer", CONFIG_PEER },
87 { "phone", CONFIG_PHONE },
88 { "pidfile", CONFIG_PIDFILE },
132 { "pps", CONFIG_PPS },
89 { "discard", CONFIG_DISCARD },
133 { "requestkey", CONFIG_REQUESTKEY },
134 { "restrict", CONFIG_RESTRICT },
135 { "revoke", CONFIG_REVOKE },
136 { "server", CONFIG_SERVER },
137 { "setvar", CONFIG_SETVAR },
138 { "statistics", CONFIG_STATISTICS },
139 { "statsdir", CONFIG_STATSDIR },
90 { "requestkey", CONFIG_REQUESTKEY },
91 { "restrict", CONFIG_RESTRICT },
92 { "revoke", CONFIG_REVOKE },
93 { "server", CONFIG_SERVER },
94 { "setvar", CONFIG_SETVAR },
95 { "statistics", CONFIG_STATISTICS },
96 { "statsdir", CONFIG_STATSDIR },
97 { "tick", CONFIG_ADJ },
140 { "tinker", CONFIG_TINKER },
98 { "tinker", CONFIG_TINKER },
99 { "tos", CONFIG_TOS },
141 { "trap", CONFIG_TRAP },
142 { "trustedkey", CONFIG_TRUSTEDKEY },
100 { "trap", CONFIG_TRAP },
101 { "trustedkey", CONFIG_TRUSTEDKEY },
102 { "ttl", CONFIG_TTL },
143 { "", CONFIG_UNKNOWN }
144};
145
146/*
147 * "peer", "server", "broadcast" modifier keywords
148 */
149static struct keyword mod_keywords[] = {
150 { "autokey", CONF_MOD_SKEY },
151 { "burst", CONF_MOD_BURST },
152 { "iburst", CONF_MOD_IBURST },
153 { "key", CONF_MOD_KEY },
154 { "maxpoll", CONF_MOD_MAXPOLL },
155 { "minpoll", CONF_MOD_MINPOLL },
156 { "mode", CONF_MOD_MODE }, /* refclocks */
157 { "noselect", CONF_MOD_NOSELECT },
158 { "prefer", CONF_MOD_PREFER },
103 { "", CONFIG_UNKNOWN }
104};
105
106/*
107 * "peer", "server", "broadcast" modifier keywords
108 */
109static struct keyword mod_keywords[] = {
110 { "autokey", CONF_MOD_SKEY },
111 { "burst", CONF_MOD_BURST },
112 { "iburst", CONF_MOD_IBURST },
113 { "key", CONF_MOD_KEY },
114 { "maxpoll", CONF_MOD_MAXPOLL },
115 { "minpoll", CONF_MOD_MINPOLL },
116 { "mode", CONF_MOD_MODE }, /* refclocks */
117 { "noselect", CONF_MOD_NOSELECT },
118 { "prefer", CONF_MOD_PREFER },
159#ifdef PUBKEY
160 { "publickey", CONF_MOD_PUBLICKEY },
161#endif /* PUBKEY */
162 { "ttl", CONF_MOD_TTL }, /* NTP peers */
163 { "version", CONF_MOD_VERSION },
164 { "", CONFIG_UNKNOWN }
165};
166
167/*
168 * "restrict" modifier keywords
169 */

--- 33 unchanged lines hidden (view full) ---

203 { "flag4", CONF_FDG_FLAG4 },
204 { "refid", CONF_FDG_REFID },
205 { "stratum", CONF_FDG_STRATUM },
206 { "time1", CONF_FDG_TIME1 },
207 { "time2", CONF_FDG_TIME2 },
208 { "", CONFIG_UNKNOWN }
209};
210
119 { "ttl", CONF_MOD_TTL }, /* NTP peers */
120 { "version", CONF_MOD_VERSION },
121 { "", CONFIG_UNKNOWN }
122};
123
124/*
125 * "restrict" modifier keywords
126 */

--- 33 unchanged lines hidden (view full) ---

160 { "flag4", CONF_FDG_FLAG4 },
161 { "refid", CONF_FDG_REFID },
162 { "stratum", CONF_FDG_STRATUM },
163 { "time1", CONF_FDG_TIME1 },
164 { "time2", CONF_FDG_TIME2 },
165 { "", CONFIG_UNKNOWN }
166};
167
211
212/*
213 * "filegen" modifier keywords
214 */
215static struct keyword filegen_keywords[] = {
216 { "disable", CONF_FGEN_FLAG_DISABLE },
217 { "enable", CONF_FGEN_FLAG_ENABLE },
218 { "file", CONF_FGEN_FILE },
219 { "link", CONF_FGEN_FLAG_LINK },

--- 27 unchanged lines hidden (view full) ---

247 { "monitor", PROTO_MONITOR },
248 { "ntp", PROTO_NTP },
249 { "pps", PROTO_PPS },
250 { "stats", PROTO_FILEGEN },
251 { "", CONFIG_UNKNOWN }
252};
253
254/*
168/*
169 * "filegen" modifier keywords
170 */
171static struct keyword filegen_keywords[] = {
172 { "disable", CONF_FGEN_FLAG_DISABLE },
173 { "enable", CONF_FGEN_FLAG_ENABLE },
174 { "file", CONF_FGEN_FILE },
175 { "link", CONF_FGEN_FLAG_LINK },

--- 27 unchanged lines hidden (view full) ---

203 { "monitor", PROTO_MONITOR },
204 { "ntp", PROTO_NTP },
205 { "pps", PROTO_PPS },
206 { "stats", PROTO_FILEGEN },
207 { "", CONFIG_UNKNOWN }
208};
209
210/*
255 * "pps" modifier keywords
211 * "discard" modifier keywords
256 */
212 */
257static struct keyword pps_keywords[] = {
258 { "assert", CONF_PPS_ASSERT },
259 { "clear", CONF_PPS_CLEAR },
260 { "hardpps", CONF_PPS_HARDPPS },
213static struct keyword discard_keywords[] = {
214 { "average", CONF_DISCARD_AVERAGE },
215 { "minimum", CONF_DISCARD_MINIMUM },
216 { "monitor", CONF_DISCARD_MONITOR },
261 { "", CONFIG_UNKNOWN }
262};
263
264/*
265 * "tinker" modifier keywords
266 */
267static struct keyword tinker_keywords[] = {
268 { "step", CONF_CLOCK_MAX },
269 { "panic", CONF_CLOCK_PANIC },
270 { "dispersion", CONF_CLOCK_PHI },
271 { "stepout", CONF_CLOCK_MINSTEP },
217 { "", CONFIG_UNKNOWN }
218};
219
220/*
221 * "tinker" modifier keywords
222 */
223static struct keyword tinker_keywords[] = {
224 { "step", CONF_CLOCK_MAX },
225 { "panic", CONF_CLOCK_PANIC },
226 { "dispersion", CONF_CLOCK_PHI },
227 { "stepout", CONF_CLOCK_MINSTEP },
272 { "minpoll", CONF_CLOCK_MINPOLL },
273 { "allan", CONF_CLOCK_ALLAN },
274 { "huffpuff", CONF_CLOCK_HUFFPUFF },
228 { "allan", CONF_CLOCK_ALLAN },
229 { "huffpuff", CONF_CLOCK_HUFFPUFF },
230 { "freq", CONF_CLOCK_FREQ },
275 { "", CONFIG_UNKNOWN }
276};
277
231 { "", CONFIG_UNKNOWN }
232};
233
278#ifdef PUBKEY
279/*
234/*
235 * "tos" modifier keywords
236 */
237static struct keyword tos_keywords[] = {
238 { "minclock", CONF_TOS_MINCLOCK },
239 { "minsane", CONF_TOS_MINSANE },
240 { "floor", CONF_TOS_FLOOR },
241 { "ceiling", CONF_TOS_CEILING },
242 { "cohort", CONF_TOS_COHORT },
243 { "", CONFIG_UNKNOWN }
244};
245
246#ifdef OPENSSL
247/*
280 * "crypto" modifier keywords
281 */
282static struct keyword crypto_keywords[] = {
248 * "crypto" modifier keywords
249 */
250static struct keyword crypto_keywords[] = {
283 { "dh", CONF_CRYPTO_DH },
284 { "flags", CONF_CRYPTO_FLAGS },
251 { "cert", CONF_CRYPTO_CERT },
252 { "gqpar", CONF_CRYPTO_GQPAR },
253 { "host", CONF_CRYPTO_RSA },
254 { "iffpar", CONF_CRYPTO_IFFPAR },
285 { "leap", CONF_CRYPTO_LEAP },
255 { "leap", CONF_CRYPTO_LEAP },
286 { "privatekey", CONF_CRYPTO_PRIVATEKEY },
287 { "publickey", CONF_CRYPTO_PUBLICKEY },
256 { "mvpar", CONF_CRYPTO_MVPAR },
257 { "pw", CONF_CRYPTO_PW },
258 { "randfile", CONF_CRYPTO_RAND },
259 { "sign", CONF_CRYPTO_SIGN },
288 { "", CONFIG_UNKNOWN }
289};
260 { "", CONFIG_UNKNOWN }
261};
290#endif /* PUBKEY */
262#endif /* OPENSSL */
291
292/*
263
264/*
265 * Address type selection, IPv4 or IPv4.
266 * Used on various lines.
267 */
268static struct keyword addr_type[] = {
269 { "-4", CONF_ADDR_IPV4 },
270 { "-6", CONF_ADDR_IPV6 },
271 { "", CONFIG_UNKNOWN }
272};
273
274/*
293 * "logconfig" building blocks
294 */
295struct masks {
296 const char *name;
297 unsigned long mask;
298};
299
300static struct masks logcfg_class[] = {

--- 39 unchanged lines hidden (view full) ---

340#define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
341
342#define KEY_TYPE_MD5 4
343
344/*
345 * File descriptor used by the resolver save routines, and temporary file
346 * name.
347 */
275 * "logconfig" building blocks
276 */
277struct masks {
278 const char *name;
279 unsigned long mask;
280};
281
282static struct masks logcfg_class[] = {

--- 39 unchanged lines hidden (view full) ---

322#define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
323
324#define KEY_TYPE_MD5 4
325
326/*
327 * File descriptor used by the resolver save routines, and temporary file
328 * name.
329 */
330int call_resolver = 1; /* ntp-genkeys sets this to 0, for example */
348static FILE *res_fp;
349#ifndef SYS_WINNT
350static char res_file[20]; /* enough for /tmp/ntpXXXXXX\0 */
351#define RES_TEMPFILE "/tmp/ntpXXXXXX"
352#else
353static char res_file[MAX_PATH];
354#endif /* SYS_WINNT */
355
356/*
357 * Definitions of things either imported from or exported to outside
358 */
359char const *progname;
360char sys_phone[MAXPHONE][MAXDIAL]; /* ACTS phone numbers */
331static FILE *res_fp;
332#ifndef SYS_WINNT
333static char res_file[20]; /* enough for /tmp/ntpXXXXXX\0 */
334#define RES_TEMPFILE "/tmp/ntpXXXXXX"
335#else
336static char res_file[MAX_PATH];
337#endif /* SYS_WINNT */
338
339/*
340 * Definitions of things either imported from or exported to outside
341 */
342char const *progname;
343char sys_phone[MAXPHONE][MAXDIAL]; /* ACTS phone numbers */
344char *keysdir = NTP_KEYSDIR; /* crypto keys directory */
361char pps_device[MAXPPS + 1]; /* PPS device name */
345char pps_device[MAXPPS + 1]; /* PPS device name */
362int pps_assert;
363int pps_hardpps;
364#if defined(HAVE_SCHED_SETSCHEDULER)
365int config_priority_override = 0;
366int config_priority;
367#endif
368
369const char *config_file;
370#ifdef HAVE_NETINFO
371 struct netinfo_config_state *config_netinfo = NULL;

--- 26 unchanged lines hidden (view full) ---

398static unsigned long get_match P((char *, struct masks *));
399static unsigned long get_logmask P((char *));
400#ifdef HAVE_NETINFO
401static struct netinfo_config_state *get_netinfo_config P((void));
402static void free_netinfo_config P((struct netinfo_config_state *));
403static int gettokens_netinfo P((struct netinfo_config_state *, char **, int *));
404#endif
405static int gettokens P((FILE *, char *, char **, int *));
346#if defined(HAVE_SCHED_SETSCHEDULER)
347int config_priority_override = 0;
348int config_priority;
349#endif
350
351const char *config_file;
352#ifdef HAVE_NETINFO
353 struct netinfo_config_state *config_netinfo = NULL;

--- 26 unchanged lines hidden (view full) ---

380static unsigned long get_match P((char *, struct masks *));
381static unsigned long get_logmask P((char *));
382#ifdef HAVE_NETINFO
383static struct netinfo_config_state *get_netinfo_config P((void));
384static void free_netinfo_config P((struct netinfo_config_state *));
385static int gettokens_netinfo P((struct netinfo_config_state *, char **, int *));
386#endif
387static int gettokens P((FILE *, char *, char **, int *));
406static int matchkey P((char *, struct keyword *));
407static int getnetnum P((const char *, struct sockaddr_in *, int));
388static int matchkey P((char *, struct keyword *, int));
389static int getnetnum P((const char *, struct sockaddr_storage *, int));
408static void save_resolve P((char *, int, int, int, int, u_int, int,
409 keyid_t, u_char *));
410static void do_resolve_internal P((void));
411static void abort_resolve P((void));
390static void save_resolve P((char *, int, int, int, int, u_int, int,
391 keyid_t, u_char *));
392static void do_resolve_internal P((void));
393static void abort_resolve P((void));
412#if !defined(VMS)
394#if !defined(VMS) && !defined(SYS_WINNT)
413static RETSIGTYPE catchchild P((int));
414#endif /* VMS */
415
416/*
417 * get_pfxmatch - find value for prefixmatch
418 * and update char * accordingly
419 */
420static unsigned long

--- 64 unchanged lines hidden (view full) ---

485getconfig(
486 int argc,
487 char *argv[]
488 )
489{
490 register int i;
491 int c;
492 int errflg;
395static RETSIGTYPE catchchild P((int));
396#endif /* VMS */
397
398/*
399 * get_pfxmatch - find value for prefixmatch
400 * and update char * accordingly
401 */
402static unsigned long

--- 64 unchanged lines hidden (view full) ---

467getconfig(
468 int argc,
469 char *argv[]
470 )
471{
472 register int i;
473 int c;
474 int errflg;
475 int istart;
493 int peerversion;
494 int minpoll;
495 int maxpoll;
496 int ttl;
497 long stratum;
498 unsigned long ul;
499 keyid_t peerkey;
500 u_char *peerkeystr;
501 u_long fudgeflag;
502 u_int peerflags;
503 int hmode;
476 int peerversion;
477 int minpoll;
478 int maxpoll;
479 int ttl;
480 long stratum;
481 unsigned long ul;
482 keyid_t peerkey;
483 u_char *peerkeystr;
484 u_long fudgeflag;
485 u_int peerflags;
486 int hmode;
504 struct sockaddr_in peeraddr;
505 struct sockaddr_in maskaddr;
487 struct sockaddr_storage peeraddr;
488 struct sockaddr_storage maskaddr;
506 FILE *fp[MAXINCLUDELEVEL+1];
507 FILE *includefile;
508 int includelevel = 0;
509 char line[MAXLINE];
510 char *(tokens[MAXTOKENS]);
489 FILE *fp[MAXINCLUDELEVEL+1];
490 FILE *includefile;
491 int includelevel = 0;
492 char line[MAXLINE];
493 char *(tokens[MAXTOKENS]);
511 int ntokens;
494 int ntokens = 0;
512 int tok = CONFIG_UNKNOWN;
513 struct interface *localaddr;
514 struct refclockstat clock_stat;
515 FILEGEN *filegen;
516
517 /*
518 * Initialize, initialize
519 */

--- 102 unchanged lines hidden (view full) ---

622
623 if (ntokens < 2) {
624 msyslog(LOG_ERR,
625 "No address for %s, line ignored",
626 tokens[0]);
627 break;
628 }
629
495 int tok = CONFIG_UNKNOWN;
496 struct interface *localaddr;
497 struct refclockstat clock_stat;
498 FILEGEN *filegen;
499
500 /*
501 * Initialize, initialize
502 */

--- 102 unchanged lines hidden (view full) ---

605
606 if (ntokens < 2) {
607 msyslog(LOG_ERR,
608 "No address for %s, line ignored",
609 tokens[0]);
610 break;
611 }
612
630 if (!getnetnum(tokens[1], &peeraddr, 0)) {
613 istart = 1;
614 memset((char *)&peeraddr, 0, sizeof(peeraddr));
615 switch (matchkey(tokens[istart], addr_type, 0)) {
616 case CONF_ADDR_IPV4:
617 peeraddr.ss_family = AF_INET;
618 istart++;
619 break;
620 case CONF_ADDR_IPV6:
621 peeraddr.ss_family = AF_INET6;
622 istart++;
623 break;
624 }
625
626 if (!getnetnum(tokens[istart], &peeraddr, 0)) {
631 errflg = -1;
632 } else {
633 errflg = 0;
634
635 if (
636#ifdef REFCLOCK
637 !ISREFCLOCKADR(&peeraddr) &&
638#endif
639 ISBADADR(&peeraddr)) {
640 msyslog(LOG_ERR,
641 "attempt to configure invalid address %s",
627 errflg = -1;
628 } else {
629 errflg = 0;
630
631 if (
632#ifdef REFCLOCK
633 !ISREFCLOCKADR(&peeraddr) &&
634#endif
635 ISBADADR(&peeraddr)) {
636 msyslog(LOG_ERR,
637 "attempt to configure invalid address %s",
642 ntoa(&peeraddr));
638 stoa(&peeraddr));
643 break;
644 }
645 /*
646 * Shouldn't be able to specify multicast
647 * address for server/peer!
648 * and unicast address for manycastclient!
649 */
639 break;
640 }
641 /*
642 * Shouldn't be able to specify multicast
643 * address for server/peer!
644 * and unicast address for manycastclient!
645 */
650 if (((tok == CONFIG_SERVER) ||
651 (tok == CONFIG_PEER)) &&
646 if (peeraddr.ss_family == AF_INET) {
647 if (((tok == CONFIG_SERVER) ||
648 (tok == CONFIG_PEER)) &&
652#ifdef REFCLOCK
649#ifdef REFCLOCK
653 !ISREFCLOCKADR(&peeraddr) &&
650 !ISREFCLOCKADR(&peeraddr) &&
654#endif
651#endif
655 IN_CLASSD(ntohl(peeraddr.sin_addr.s_addr))) {
656 msyslog(LOG_ERR,
657 "attempt to configure invalid address %s",
658 ntoa(&peeraddr));
659 break;
652 IN_CLASSD(ntohl(((struct sockaddr_in*)&peeraddr)->sin_addr.s_addr))) {
653 msyslog(LOG_ERR,
654 "attempt to configure invalid address %s",
655 stoa(&peeraddr));
656 break;
657 }
658 if ((tok == CONFIG_MANYCASTCLIENT) &&
659 !IN_CLASSD(ntohl(((struct sockaddr_in*)&peeraddr)->sin_addr.s_addr))) {
660 msyslog(LOG_ERR,
661 "attempt to configure invalid address %s",
662 stoa(&peeraddr));
663 break;
664 }
660 }
665 }
661 if ((tok == CONFIG_MANYCASTCLIENT) &&
662 !IN_CLASSD(ntohl(peeraddr.sin_addr.s_addr))) {
663 msyslog(LOG_ERR,
664 "attempt to configure invalid address %s",
665 ntoa(&peeraddr));
666 break;
666 else if(peeraddr.ss_family == AF_INET6) {
667 if (((tok == CONFIG_SERVER) ||
668 (tok == CONFIG_PEER)) &&
669#ifdef REFCLOCK
670 !ISREFCLOCKADR(&peeraddr) &&
671#endif
672 IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)&peeraddr)->sin6_addr)) {
673 msyslog(LOG_ERR,
674 "attempt to configure in valid address %s",
675 stoa(&peeraddr));
676 break;
677 }
678 if ((tok == CONFIG_MANYCASTCLIENT) &&
679 !IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)&peeraddr)->sin6_addr)) {
680 msyslog(LOG_ERR,
681 "attempt to configure in valid address %s",
682 stoa(&peeraddr));
683 break;
684 }
667 }
668 }
669
670 peerversion = NTP_VERSION;
671 minpoll = NTP_MINDPOLL;
672 maxpoll = NTP_MAXDPOLL;
673 peerkey = 0;
685 }
686 }
687
688 peerversion = NTP_VERSION;
689 minpoll = NTP_MINDPOLL;
690 maxpoll = NTP_MAXDPOLL;
691 peerkey = 0;
674 peerkeystr = "*";
692 peerkeystr = (u_char *)"*";
675 peerflags = 0;
676 ttl = 0;
693 peerflags = 0;
694 ttl = 0;
677 for (i = 2; i < ntokens; i++)
678 switch (matchkey(tokens[i], mod_keywords)) {
695 istart++;
696 for (i = istart; i < ntokens; i++)
697 switch (matchkey(tokens[i], mod_keywords, 1)) {
679 case CONF_MOD_VERSION:
680 if (i >= ntokens-1) {
681 msyslog(LOG_ERR,
682 "peer/server version requires an argument");
683 errflg = 1;
684 break;
685 }
686 peerversion = atoi(tokens[++i]);

--- 60 unchanged lines hidden (view full) ---

747
748 case CONF_MOD_BURST:
749 peerflags |= FLAG_BURST;
750 break;
751
752 case CONF_MOD_IBURST:
753 peerflags |= FLAG_IBURST;
754 break;
698 case CONF_MOD_VERSION:
699 if (i >= ntokens-1) {
700 msyslog(LOG_ERR,
701 "peer/server version requires an argument");
702 errflg = 1;
703 break;
704 }
705 peerversion = atoi(tokens[++i]);

--- 60 unchanged lines hidden (view full) ---

766
767 case CONF_MOD_BURST:
768 peerflags |= FLAG_BURST;
769 break;
770
771 case CONF_MOD_IBURST:
772 peerflags |= FLAG_IBURST;
773 break;
755#ifdef AUTOKEY
774#ifdef OPENSSL
756 case CONF_MOD_SKEY:
757 peerflags |= FLAG_SKEY |
758 FLAG_AUTHENABLE;
759 break;
775 case CONF_MOD_SKEY:
776 peerflags |= FLAG_SKEY |
777 FLAG_AUTHENABLE;
778 break;
779#endif /* OPENSSL */
760
780
761#ifdef PUBKEY
762 case CONF_MOD_PUBLICKEY:
763 if (i >= ntokens - 1) {
764 msyslog(LOG_ERR,
765 "Public key file name required");
766 errflg = 1;
767 break;
768 }
769 peerflags |= FLAG_SKEY |
770 FLAG_AUTHENABLE;
771 peerkeystr = tokens[++i];
772 break;
773#endif /* PUBKEY */
774#endif /* AUTOKEY */
775
776 case CONF_MOD_TTL:
777 if (i >= ntokens-1) {
781 case CONF_MOD_TTL:
782 if (i >= ntokens-1) {
778 msyslog(LOG_ERR,
779 "ttl: argument required");
780 errflg = 1;
781 break;
783 msyslog(LOG_ERR,
784 "ttl: argument required");
785 errflg = 1;
786 break;
782 }
783 ttl = atoi(tokens[++i]);
787 }
788 ttl = atoi(tokens[++i]);
789 if (ttl >= MAX_TTL) {
790 msyslog(LOG_ERR,
791 "ttl: invalid argument");
792 errflg = 1;
793 }
784 break;
785
786 case CONF_MOD_MODE:
787 if (i >= ntokens-1) {
794 break;
795
796 case CONF_MOD_MODE:
797 if (i >= ntokens-1) {
788 msyslog(LOG_ERR,
789 "mode: argument required");
790 errflg = 1;
791 break;
798 msyslog(LOG_ERR,
799 "mode: argument required");
800 errflg = 1;
801 break;
792 }
793 ttl = atoi(tokens[++i]);
794 break;
795
796 case CONFIG_UNKNOWN:
797 errflg = 1;
798 break;
799 }
800 if (minpoll > maxpoll) {
802 }
803 ttl = atoi(tokens[++i]);
804 break;
805
806 case CONFIG_UNKNOWN:
807 errflg = 1;
808 break;
809 }
810 if (minpoll > maxpoll) {
801 msyslog(LOG_ERR, "config error: minpoll > maxpoll");
811 msyslog(LOG_ERR,
812 "config error: minpoll > maxpoll");
802 errflg = 1;
803 }
804 if (errflg == 0) {
813 errflg = 1;
814 }
815 if (errflg == 0) {
805 if (peer_config(&peeraddr, any_interface, hmode,
806 peerversion, minpoll, maxpoll, peerflags,
807 ttl, peerkey, peerkeystr) == 0) {
816 if (peer_config(&peeraddr,
817 ANY_INTERFACE_CHOOSE(&peeraddr), hmode,
818 peerversion, minpoll, maxpoll, peerflags,
819 ttl, peerkey, peerkeystr) == 0) {
808 msyslog(LOG_ERR,
809 "configuration of %s failed",
820 msyslog(LOG_ERR,
821 "configuration of %s failed",
810 ntoa(&peeraddr));
822 stoa(&peeraddr));
811 }
823 }
824 if (tok == CONFIG_MANYCASTCLIENT)
825 proto_config(PROTO_MULTICAST_ADD,
826 0, 0., &peeraddr);
812
813 } else if (errflg == -1) {
814 save_resolve(tokens[1], hmode, peerversion,
815 minpoll, maxpoll, peerflags, ttl,
816 peerkey, peerkeystr);
817 }
818 break;
819

--- 85 unchanged lines hidden (view full) ---

905#ifdef DEBUG
906 if (debug)
907 printf("ntp_syslogmask = 0x%08lx (%s)\n", ntp_syslogmask, tokens[i]);
908#endif
909 }
910 break;
911
912 case CONFIG_BROADCASTCLIENT:
827
828 } else if (errflg == -1) {
829 save_resolve(tokens[1], hmode, peerversion,
830 minpoll, maxpoll, peerflags, ttl,
831 peerkey, peerkeystr);
832 }
833 break;
834

--- 85 unchanged lines hidden (view full) ---

920#ifdef DEBUG
921 if (debug)
922 printf("ntp_syslogmask = 0x%08lx (%s)\n", ntp_syslogmask, tokens[i]);
923#endif
924 }
925 break;
926
927 case CONFIG_BROADCASTCLIENT:
913 proto_config(PROTO_BROADCLIENT, 1, 0.);
928 proto_config(PROTO_BROADCLIENT, 1, 0., NULL);
914 break;
929 break;
915
930
916 case CONFIG_MULTICASTCLIENT:
917 case CONFIG_MANYCASTSERVER:
918 if (ntokens > 1) {
931 case CONFIG_MULTICASTCLIENT:
932 case CONFIG_MANYCASTSERVER:
933 if (ntokens > 1) {
919 for (i = 1; i < ntokens; i++) {
934 istart = 1;
935 memset((char *)&peeraddr, 0, sizeof(peeraddr));
936 switch (matchkey(tokens[istart],
937 addr_type, 0)) {
938 case CONF_ADDR_IPV4:
939 peeraddr.ss_family = AF_INET;
940 istart++;
941 break;
942 case CONF_ADDR_IPV6:
943 peeraddr.ss_family = AF_INET6;
944 istart++;
945 break;
946 }
947 /*
948 * Abuse maskaddr to store the prefered ip
949 * version.
950 */
951 memset((char *)&maskaddr, 0, sizeof(maskaddr));
952 maskaddr.ss_family = peeraddr.ss_family;
953
954 for (i = istart; i < ntokens; i++) {
955 memset((char *)&peeraddr, 0,
956 sizeof(peeraddr));
957 peeraddr.ss_family = maskaddr.ss_family;
920 if (getnetnum(tokens[i], &peeraddr, 1))
921 proto_config(PROTO_MULTICAST_ADD,
958 if (getnetnum(tokens[i], &peeraddr, 1))
959 proto_config(PROTO_MULTICAST_ADD,
922 peeraddr.sin_addr.s_addr, 0.);
960 0, 0., &peeraddr);
923 }
924 } else
925 proto_config(PROTO_MULTICAST_ADD,
961 }
962 } else
963 proto_config(PROTO_MULTICAST_ADD,
926 htonl(INADDR_NTP), 0.);
964 0, 0., NULL);
927 if (tok == CONFIG_MULTICASTCLIENT)
928 sys_bclient = 1;
929 else if (tok == CONFIG_MANYCASTSERVER)
930 sys_manycastserver = 1;
931 break;
932
965 if (tok == CONFIG_MULTICASTCLIENT)
966 sys_bclient = 1;
967 else if (tok == CONFIG_MANYCASTSERVER)
968 sys_manycastserver = 1;
969 break;
970
933 case CONFIG_AUTHENTICATE:
934 errflg = 0;
971 case CONFIG_KEYS:
935 if (ntokens >= 2) {
972 if (ntokens >= 2) {
936 if (STREQ(tokens[1], "yes"))
937 proto_config(PROTO_AUTHENTICATE, 1, 0.);
938 else if (STREQ(tokens[1], "no"))
939 proto_config(PROTO_AUTHENTICATE, 0, 0.);
940 else
941 errflg++;
942 } else {
943 errflg++;
973 getauthkeys(tokens[1]);
944 }
974 }
945
946 if (errflg)
947 msyslog(LOG_ERR,
948 "should be `authenticate yes|no'");
949 break;
950
975 break;
976
951 case CONFIG_KEYS:
952 if (ntokens >= 2) {
953 getauthkeys(tokens[1]);
977 case CONFIG_KEYSDIR:
978 if (ntokens < 2) {
979 msyslog(LOG_ERR,
980 "Keys directory name required");
981 break;
954 }
982 }
983 keysdir = emalloc(strlen(tokens[1]) + 1);
984 strcpy(keysdir, tokens[1]);
955 break;
956
957 case CONFIG_TINKER:
958 for (i = 1; i < ntokens; i++) {
959 int temp;
960 double ftemp;
961
985 break;
986
987 case CONFIG_TINKER:
988 for (i = 1; i < ntokens; i++) {
989 int temp;
990 double ftemp;
991
962 temp = matchkey(tokens[i++],
963 tinker_keywords);
992 temp = matchkey(tokens[i++], tinker_keywords, 1);
964 if (i > ntokens - 1) {
965 msyslog(LOG_ERR,
966 "tinker: missing argument");
967 errflg++;
968 break;
969 }
970 sscanf(tokens[i], "%lf", &ftemp);
971 switch(temp) {
993 if (i > ntokens - 1) {
994 msyslog(LOG_ERR,
995 "tinker: missing argument");
996 errflg++;
997 break;
998 }
999 sscanf(tokens[i], "%lf", &ftemp);
1000 switch(temp) {
1001
972 case CONF_CLOCK_MAX:
973 loop_config(LOOP_MAX, ftemp);
974 break;
975
976 case CONF_CLOCK_PANIC:
977 loop_config(LOOP_PANIC, ftemp);
978 break;
979
980 case CONF_CLOCK_PHI:
981 loop_config(LOOP_PHI, ftemp);
982 break;
983
984 case CONF_CLOCK_MINSTEP:
985 loop_config(LOOP_MINSTEP, ftemp);
986 break;
987
1002 case CONF_CLOCK_MAX:
1003 loop_config(LOOP_MAX, ftemp);
1004 break;
1005
1006 case CONF_CLOCK_PANIC:
1007 loop_config(LOOP_PANIC, ftemp);
1008 break;
1009
1010 case CONF_CLOCK_PHI:
1011 loop_config(LOOP_PHI, ftemp);
1012 break;
1013
1014 case CONF_CLOCK_MINSTEP:
1015 loop_config(LOOP_MINSTEP, ftemp);
1016 break;
1017
988 case CONF_CLOCK_MINPOLL:
989 loop_config(LOOP_MINPOLL, ftemp);
990 break;
991
992 case CONF_CLOCK_ALLAN:
993 loop_config(LOOP_ALLAN, ftemp);
994 break;
995
996 case CONF_CLOCK_HUFFPUFF:
997 loop_config(LOOP_HUFFPUFF, ftemp);
998 break;
1018 case CONF_CLOCK_ALLAN:
1019 loop_config(LOOP_ALLAN, ftemp);
1020 break;
1021
1022 case CONF_CLOCK_HUFFPUFF:
1023 loop_config(LOOP_HUFFPUFF, ftemp);
1024 break;
1025
1026 case CONF_CLOCK_FREQ:
1027 loop_config(LOOP_FREQ, ftemp);
1028 break;
999 }
1000 }
1001 break;
1002
1029 }
1030 }
1031 break;
1032
1003#ifdef AUTOKEY
1033 case CONFIG_TOS:
1034 for (i = 1; i < ntokens; i++) {
1035 int temp;
1036 double ftemp;
1037
1038 temp = matchkey(tokens[i++], tos_keywords, 1);
1039 if (i > ntokens - 1) {
1040 msyslog(LOG_ERR,
1041 "tinker: missing argument");
1042 errflg++;
1043 break;
1044 }
1045 sscanf(tokens[i], "%lf", &ftemp);
1046 switch(temp) {
1047
1048 case CONF_TOS_MINCLOCK:
1049 proto_config(PROTO_MINCLOCK, 0, ftemp, NULL);
1050 break;
1051
1052 case CONF_TOS_MINSANE:
1053 proto_config(PROTO_MINSANE, 0, ftemp, NULL);
1054 break;
1055
1056 case CONF_TOS_FLOOR:
1057 proto_config(PROTO_FLOOR, 0, ftemp, NULL);
1058 break;
1059
1060 case CONF_TOS_CEILING:
1061 proto_config(PROTO_CEILING, 0, ftemp, NULL);
1062 break;
1063
1064 case CONF_TOS_COHORT:
1065 proto_config(PROTO_COHORT, 0, ftemp, NULL);
1066 break;
1067 }
1068 }
1069 break;
1070
1071 case CONFIG_TTL:
1072 for (i = 1; i < ntokens && i < MAX_TTL; i++) {
1073 sys_ttl[i - 1] = (u_char) atoi(tokens[i]);
1074 sys_ttlmax = i - 1;
1075 }
1076 break;
1077
1078 case CONFIG_DISCARD:
1079 for (i = 1; i < ntokens; i++) {
1080 int temp;
1081
1082 temp = matchkey(tokens[i++],
1083 discard_keywords, 1);
1084 if (i > ntokens - 1) {
1085 msyslog(LOG_ERR,
1086 "discard: missing argument");
1087 errflg++;
1088 break;
1089 }
1090 switch(temp) {
1091 case CONF_DISCARD_AVERAGE:
1092 res_avg_interval = atoi(tokens[i++]);
1093 break;
1094
1095 case CONF_DISCARD_MINIMUM:
1096 res_min_interval = atoi(tokens[i++]);
1097 break;
1098
1099 case CONF_DISCARD_MONITOR:
1100 mon_age = atoi(tokens[i++]);
1101 break;
1102
1103 default:
1104 msyslog(LOG_ERR,
1105 "discard: unknown keyword");
1106 break;
1107 }
1108 }
1109 break;
1110
1111#ifdef OPENSSL
1004 case CONFIG_REVOKE:
1005 if (ntokens >= 2)
1112 case CONFIG_REVOKE:
1113 if (ntokens >= 2)
1006 sys_revoke = 1 << max(atoi(tokens[1]), 10);
1114 sys_revoke = (u_char) max(atoi(tokens[1]), KEY_REVOKE);
1007 break;
1008
1009 case CONFIG_AUTOMAX:
1010 if (ntokens >= 2)
1011 sys_automax = 1 << max(atoi(tokens[1]), 10);
1012 break;
1013
1115 break;
1116
1117 case CONFIG_AUTOMAX:
1118 if (ntokens >= 2)
1119 sys_automax = 1 << max(atoi(tokens[1]), 10);
1120 break;
1121
1014#ifdef PUBKEY
1015 case CONFIG_KEYSDIR:
1016 if (ntokens < 2) {
1017 msyslog(LOG_ERR,
1018 "Keys directory name required");
1019 break;
1020 }
1021 crypto_config(CRYPTO_CONF_KEYS, tokens[1]);
1022 break;
1023
1024 case CONFIG_CRYPTO:
1025 if (ntokens == 1) {
1122 case CONFIG_CRYPTO:
1123 if (ntokens == 1) {
1026 crypto_config(CRYPTO_CONF_FLAGS , "0");
1124 crypto_config(CRYPTO_CONF_NONE, NULL);
1027 break;
1028 }
1029 for (i = 1; i < ntokens; i++) {
1030 int temp;
1031
1125 break;
1126 }
1127 for (i = 1; i < ntokens; i++) {
1128 int temp;
1129
1032 temp = matchkey(tokens[i++], crypto_keywords);
1130 temp = matchkey(tokens[i++],
1131 crypto_keywords, 1);
1033 if (i > ntokens - 1) {
1034 msyslog(LOG_ERR,
1035 "crypto: missing argument");
1036 errflg++;
1037 break;
1038 }
1039 switch(temp) {
1132 if (i > ntokens - 1) {
1133 msyslog(LOG_ERR,
1134 "crypto: missing argument");
1135 errflg++;
1136 break;
1137 }
1138 switch(temp) {
1040 case CONF_CRYPTO_FLAGS:
1041 crypto_config(CRYPTO_CONF_FLAGS, tokens[i]);
1139
1140 case CONF_CRYPTO_CERT:
1141 crypto_config(CRYPTO_CONF_CERT,
1142 tokens[i]);
1042 break;
1043
1143 break;
1144
1044 case CONF_CRYPTO_LEAP:
1045 crypto_config(CRYPTO_CONF_LEAP, tokens[i]);
1145 case CONF_CRYPTO_RSA:
1146 crypto_config(CRYPTO_CONF_PRIV,
1147 tokens[i]);
1046 break;
1047
1148 break;
1149
1048 case CONF_CRYPTO_DH:
1049 crypto_config(CRYPTO_CONF_DH, tokens[i]);
1150 case CONF_CRYPTO_IFFPAR:
1151 crypto_config(CRYPTO_CONF_IFFPAR,
1152 tokens[i]);
1050 break;
1051
1153 break;
1154
1052 case CONF_CRYPTO_PRIVATEKEY:
1053 crypto_config(CRYPTO_CONF_PRIV, tokens[i]);
1155 case CONF_CRYPTO_GQPAR:
1156 crypto_config(CRYPTO_CONF_GQPAR,
1157 tokens[i]);
1054 break;
1055
1158 break;
1159
1056 case CONF_CRYPTO_PUBLICKEY:
1057 crypto_config(CRYPTO_CONF_PUBL, tokens[i]);
1160 case CONF_CRYPTO_MVPAR:
1161 crypto_config(CRYPTO_CONF_MVPAR,
1162 tokens[i]);
1058 break;
1059
1163 break;
1164
1060 case CONF_CRYPTO_CERT:
1061 crypto_config(CRYPTO_CONF_CERT, tokens[i]);
1165 case CONF_CRYPTO_LEAP:
1166 crypto_config(CRYPTO_CONF_LEAP,
1167 tokens[i]);
1062 break;
1063
1168 break;
1169
1170 case CONF_CRYPTO_PW:
1171 crypto_config(CRYPTO_CONF_PW,
1172 tokens[i]);
1173 break;
1174
1175 case CONF_CRYPTO_RAND:
1176 crypto_config(CRYPTO_CONF_RAND,
1177 tokens[i]);
1178 break;
1179
1180 case CONF_CRYPTO_SIGN:
1181 crypto_config(CRYPTO_CONF_SIGN,
1182 tokens[i]);
1183 break;
1184
1064 default:
1185 default:
1065 msyslog(LOG_ERR, "crypto: unknown keyword");
1186 msyslog(LOG_ERR,
1187 "crypto: unknown keyword");
1066 break;
1067 }
1068 }
1069 break;
1188 break;
1189 }
1190 }
1191 break;
1070#endif /* PUBKEY */
1071#endif /* AUTOKEY */
1192#endif /* OPENSSL */
1072
1073 case CONFIG_RESTRICT:
1074 if (ntokens < 2) {
1075 msyslog(LOG_ERR, "restrict requires an address");
1076 break;
1077 }
1193
1194 case CONFIG_RESTRICT:
1195 if (ntokens < 2) {
1196 msyslog(LOG_ERR, "restrict requires an address");
1197 break;
1198 }
1078 if (STREQ(tokens[1], "default"))
1079 peeraddr.sin_addr.s_addr = htonl(INADDR_ANY);
1080 else if (!getnetnum(tokens[1], &peeraddr, 1))
1081 break;
1199 istart = 1;
1200 memset((char *)&peeraddr, 0, sizeof(peeraddr));
1201 switch (matchkey(tokens[istart], addr_type, 0)) {
1202 case CONF_ADDR_IPV4:
1203 peeraddr.ss_family = AF_INET;
1204 istart++;
1205 break;
1206 case CONF_ADDR_IPV6:
1207 peeraddr.ss_family = AF_INET6;
1208 istart++;
1209 break;
1210 }
1082
1083 /*
1211
1212 /*
1213 * Assume default means an IPv4 address, except
1214 * if forced by a -4 or -6.
1215 */
1216 if (STREQ(tokens[istart], "default")) {
1217 if (peeraddr.ss_family == 0)
1218 peeraddr.ss_family = AF_INET;
1219 } else if (!getnetnum(tokens[istart], &peeraddr, 1))
1220 break;
1221
1222 /*
1084 * Use peerversion as flags, peerkey as mflags. Ick.
1085 */
1086 peerversion = 0;
1087 peerkey = 0;
1088 errflg = 0;
1223 * Use peerversion as flags, peerkey as mflags. Ick.
1224 */
1225 peerversion = 0;
1226 peerkey = 0;
1227 errflg = 0;
1089 maskaddr.sin_addr.s_addr = ~(u_int32)0;
1090 for (i = 2; i < ntokens; i++) {
1091 switch (matchkey(tokens[i], res_keywords)) {
1228 SET_HOSTMASK(&maskaddr, peeraddr.ss_family);
1229 istart++;
1230 for (i = istart; i < ntokens; i++) {
1231 switch (matchkey(tokens[i], res_keywords, 1)) {
1092 case CONF_RES_MASK:
1093 if (i >= ntokens-1) {
1094 msyslog(LOG_ERR,
1095 "mask keyword needs argument");
1096 errflg++;
1097 break;
1098 }
1099 i++;

--- 49 unchanged lines hidden (view full) ---

1149 peerversion |= RES_LIMITED;
1150 break;
1151
1152 case CONFIG_UNKNOWN:
1153 errflg++;
1154 break;
1155 }
1156 }
1232 case CONF_RES_MASK:
1233 if (i >= ntokens-1) {
1234 msyslog(LOG_ERR,
1235 "mask keyword needs argument");
1236 errflg++;
1237 break;
1238 }
1239 i++;

--- 49 unchanged lines hidden (view full) ---

1289 peerversion |= RES_LIMITED;
1290 break;
1291
1292 case CONFIG_UNKNOWN:
1293 errflg++;
1294 break;
1295 }
1296 }
1157 if (SRCADR(&peeraddr) == htonl(INADDR_ANY))
1158 maskaddr.sin_addr.s_addr = 0;
1297 if (SOCKNUL(&peeraddr))
1298 ANYSOCK(&maskaddr);
1159 if (!errflg)
1160 hack_restrict(RESTRICT_FLAGS, &peeraddr, &maskaddr,
1161 (int)peerkey, peerversion);
1162 break;
1163
1164 case CONFIG_BDELAY:
1165 if (ntokens >= 2) {
1166 double tmp;
1167
1168 if (sscanf(tokens[1], "%lf", &tmp) != 1) {
1169 msyslog(LOG_ERR,
1170 "broadcastdelay value %s undecodable",
1171 tokens[1]);
1172 } else {
1299 if (!errflg)
1300 hack_restrict(RESTRICT_FLAGS, &peeraddr, &maskaddr,
1301 (int)peerkey, peerversion);
1302 break;
1303
1304 case CONFIG_BDELAY:
1305 if (ntokens >= 2) {
1306 double tmp;
1307
1308 if (sscanf(tokens[1], "%lf", &tmp) != 1) {
1309 msyslog(LOG_ERR,
1310 "broadcastdelay value %s undecodable",
1311 tokens[1]);
1312 } else {
1173 proto_config(PROTO_BROADDELAY, 0, tmp);
1313 proto_config(PROTO_BROADDELAY, 0, tmp, NULL);
1174 }
1175 }
1176 break;
1177
1314 }
1315 }
1316 break;
1317
1318 case CONFIG_CDELAY:
1319 if (ntokens >= 2) {
1320 u_long ui;
1321
1322 if (sscanf(tokens[1], "%ld", &ui) != 1)
1323 msyslog(LOG_ERR,
1324 "illegal value - line ignored");
1325 else
1326 proto_config(PROTO_CALLDELAY, ui, 0, NULL);
1327 }
1328 break;
1329
1178 case CONFIG_TRUSTEDKEY:
1179 for (i = 1; i < ntokens; i++) {
1180 keyid_t tkey;
1181
1182 tkey = atol(tokens[i]);
1183 if (tkey == 0) {
1184 msyslog(LOG_ERR,
1185 "trusted key %s unlikely",

--- 41 unchanged lines hidden (view full) ---

1227 break;
1228
1229 case CONFIG_TRAP:
1230 if (ntokens < 2) {
1231 msyslog(LOG_ERR,
1232 "no address for trap command, line ignored");
1233 break;
1234 }
1330 case CONFIG_TRUSTEDKEY:
1331 for (i = 1; i < ntokens; i++) {
1332 keyid_t tkey;
1333
1334 tkey = atol(tokens[i]);
1335 if (tkey == 0) {
1336 msyslog(LOG_ERR,
1337 "trusted key %s unlikely",

--- 41 unchanged lines hidden (view full) ---

1379 break;
1380
1381 case CONFIG_TRAP:
1382 if (ntokens < 2) {
1383 msyslog(LOG_ERR,
1384 "no address for trap command, line ignored");
1385 break;
1386 }
1235 if (!getnetnum(tokens[1], &peeraddr, 1))
1387 istart = 1;
1388 memset((char *)&peeraddr, 0, sizeof(peeraddr));
1389 switch (matchkey(tokens[istart], addr_type, 0)) {
1390 case CONF_ADDR_IPV4:
1391 peeraddr.ss_family = AF_INET;
1392 istart++;
1393 break;
1394 case CONF_ADDR_IPV6:
1395 peeraddr.ss_family = AF_INET6;
1396 istart++;
1397 break;
1398 }
1399
1400 if (!getnetnum(tokens[istart], &peeraddr, 1))
1236 break;
1237
1238 /*
1239 * Use peerversion for port number. Barf.
1240 */
1241 errflg = 0;
1242 peerversion = 0;
1243 localaddr = 0;
1401 break;
1402
1403 /*
1404 * Use peerversion for port number. Barf.
1405 */
1406 errflg = 0;
1407 peerversion = 0;
1408 localaddr = 0;
1244 for (i = 2; i < ntokens-1; i++)
1245 switch (matchkey(tokens[i], trap_keywords)) {
1409 istart++;
1410 for (i = istart; i < ntokens-1; i++)
1411 switch (matchkey(tokens[i], trap_keywords, 1)) {
1246 case CONF_TRAP_PORT:
1247 if (i >= ntokens-1) {
1248 msyslog(LOG_ERR,
1249 "trap port requires an argument");
1250 errflg = 1;
1251 break;
1252 }
1253 peerversion = atoi(tokens[++i]);

--- 9 unchanged lines hidden (view full) ---

1263 case CONF_TRAP_INTERFACE:
1264 if (i >= ntokens-1) {
1265 msyslog(LOG_ERR,
1266 "trap interface requires an argument");
1267 errflg = 1;
1268 break;
1269 }
1270
1412 case CONF_TRAP_PORT:
1413 if (i >= ntokens-1) {
1414 msyslog(LOG_ERR,
1415 "trap port requires an argument");
1416 errflg = 1;
1417 break;
1418 }
1419 peerversion = atoi(tokens[++i]);

--- 9 unchanged lines hidden (view full) ---

1429 case CONF_TRAP_INTERFACE:
1430 if (i >= ntokens-1) {
1431 msyslog(LOG_ERR,
1432 "trap interface requires an argument");
1433 errflg = 1;
1434 break;
1435 }
1436
1437 memset((char *)&maskaddr, 0,
1438 sizeof(maskaddr));
1439 maskaddr.ss_family = peeraddr.ss_family;
1271 if (!getnetnum(tokens[++i],
1272 &maskaddr, 1)) {
1273 errflg = 1;
1274 break;
1275 }
1276
1277 localaddr = findinterface(&maskaddr);
1278 if (localaddr == NULL) {
1279 msyslog(LOG_ERR,
1280 "can't find interface with address %s",
1440 if (!getnetnum(tokens[++i],
1441 &maskaddr, 1)) {
1442 errflg = 1;
1443 break;
1444 }
1445
1446 localaddr = findinterface(&maskaddr);
1447 if (localaddr == NULL) {
1448 msyslog(LOG_ERR,
1449 "can't find interface with address %s",
1281 ntoa(&maskaddr));
1450 stoa(&maskaddr));
1282 errflg = 1;
1283 }
1284 break;
1285
1286 case CONFIG_UNKNOWN:
1287 errflg++;
1288 break;
1289 }
1290
1291 if (!errflg) {
1292 if (peerversion != 0)
1451 errflg = 1;
1452 }
1453 break;
1454
1455 case CONFIG_UNKNOWN:
1456 errflg++;
1457 break;
1458 }
1459
1460 if (!errflg) {
1461 if (peerversion != 0)
1293 peeraddr.sin_port = htons( (u_short) peerversion);
1462 ((struct sockaddr_in6*)&peeraddr)->sin6_port = htons( (u_short) peerversion);
1294 else
1463 else
1295 peeraddr.sin_port = htons(TRAPPORT);
1464 ((struct sockaddr_in6*)&peeraddr)->sin6_port = htons(TRAPPORT);
1296 if (localaddr == NULL)
1465 if (localaddr == NULL)
1297 localaddr = any_interface;
1466 localaddr = ANY_INTERFACE_CHOOSE(&peeraddr);
1298 if (!ctlsettrap(&peeraddr, localaddr, 0,
1299 NTP_VERSION))
1300 msyslog(LOG_ERR,
1301 "can't set trap for %s, no resources",
1467 if (!ctlsettrap(&peeraddr, localaddr, 0,
1468 NTP_VERSION))
1469 msyslog(LOG_ERR,
1470 "can't set trap for %s, no resources",
1302 ntoa(&peeraddr));
1471 stoa(&peeraddr));
1303 }
1304 break;
1305
1306 case CONFIG_FUDGE:
1307 if (ntokens < 2) {
1308 msyslog(LOG_ERR,
1309 "no address for fudge command, line ignored");
1310 break;
1311 }
1472 }
1473 break;
1474
1475 case CONFIG_FUDGE:
1476 if (ntokens < 2) {
1477 msyslog(LOG_ERR,
1478 "no address for fudge command, line ignored");
1479 break;
1480 }
1481 memset((char *)&peeraddr, 0, sizeof(peeraddr));
1312 if (!getnetnum(tokens[1], &peeraddr, 1))
1313 break;
1314
1315 if (!ISREFCLOCKADR(&peeraddr)) {
1316 msyslog(LOG_ERR,
1317 "%s is inappropriate address for the fudge command, line ignored",
1482 if (!getnetnum(tokens[1], &peeraddr, 1))
1483 break;
1484
1485 if (!ISREFCLOCKADR(&peeraddr)) {
1486 msyslog(LOG_ERR,
1487 "%s is inappropriate address for the fudge command, line ignored",
1318 ntoa(&peeraddr));
1488 stoa(&peeraddr));
1319 break;
1320 }
1321
1322 memset((void *)&clock_stat, 0, sizeof clock_stat);
1323 fudgeflag = 0;
1324 errflg = 0;
1325 for (i = 2; i < ntokens-1; i++) {
1326 switch (c = matchkey(tokens[i],
1489 break;
1490 }
1491
1492 memset((void *)&clock_stat, 0, sizeof clock_stat);
1493 fudgeflag = 0;
1494 errflg = 0;
1495 for (i = 2; i < ntokens-1; i++) {
1496 switch (c = matchkey(tokens[i],
1327 fudge_keywords)) {
1497 fudge_keywords, 1)) {
1328 case CONF_FDG_TIME1:
1329 if (sscanf(tokens[++i], "%lf",
1330 &clock_stat.fudgetime1) != 1) {
1331 msyslog(LOG_ERR,
1332 "fudge %s time1 value in error",
1498 case CONF_FDG_TIME1:
1499 if (sscanf(tokens[++i], "%lf",
1500 &clock_stat.fudgetime1) != 1) {
1501 msyslog(LOG_ERR,
1502 "fudge %s time1 value in error",
1333 ntoa(&peeraddr));
1503 stoa(&peeraddr));
1334 errflg = i;
1335 break;
1336 }
1337 clock_stat.haveflags |= CLK_HAVETIME1;
1338 break;
1339
1340 case CONF_FDG_TIME2:
1341 if (sscanf(tokens[++i], "%lf",
1342 &clock_stat.fudgetime2) != 1) {
1343 msyslog(LOG_ERR,
1344 "fudge %s time2 value in error",
1504 errflg = i;
1505 break;
1506 }
1507 clock_stat.haveflags |= CLK_HAVETIME1;
1508 break;
1509
1510 case CONF_FDG_TIME2:
1511 if (sscanf(tokens[++i], "%lf",
1512 &clock_stat.fudgetime2) != 1) {
1513 msyslog(LOG_ERR,
1514 "fudge %s time2 value in error",
1345 ntoa(&peeraddr));
1515 stoa(&peeraddr));
1346 errflg = i;
1347 break;
1348 }
1349 clock_stat.haveflags |= CLK_HAVETIME2;
1350 break;
1351
1352
1353 case CONF_FDG_STRATUM:
1354 if (!atoint(tokens[++i], &stratum))
1355 {
1356 msyslog(LOG_ERR,
1357 "fudge %s stratum value in error",
1516 errflg = i;
1517 break;
1518 }
1519 clock_stat.haveflags |= CLK_HAVETIME2;
1520 break;
1521
1522
1523 case CONF_FDG_STRATUM:
1524 if (!atoint(tokens[++i], &stratum))
1525 {
1526 msyslog(LOG_ERR,
1527 "fudge %s stratum value in error",
1358 ntoa(&peeraddr));
1528 stoa(&peeraddr));
1359 errflg = i;
1360 break;
1361 }
1362 clock_stat.fudgeval1 = stratum;
1363 clock_stat.haveflags |= CLK_HAVEVAL1;
1364 break;
1365
1366 case CONF_FDG_REFID:

--- 7 unchanged lines hidden (view full) ---

1374 case CONF_FDG_FLAG1:
1375 case CONF_FDG_FLAG2:
1376 case CONF_FDG_FLAG3:
1377 case CONF_FDG_FLAG4:
1378 if (!atouint(tokens[++i], &fudgeflag)
1379 || fudgeflag > 1) {
1380 msyslog(LOG_ERR,
1381 "fudge %s flag value in error",
1529 errflg = i;
1530 break;
1531 }
1532 clock_stat.fudgeval1 = stratum;
1533 clock_stat.haveflags |= CLK_HAVEVAL1;
1534 break;
1535
1536 case CONF_FDG_REFID:

--- 7 unchanged lines hidden (view full) ---

1544 case CONF_FDG_FLAG1:
1545 case CONF_FDG_FLAG2:
1546 case CONF_FDG_FLAG3:
1547 case CONF_FDG_FLAG4:
1548 if (!atouint(tokens[++i], &fudgeflag)
1549 || fudgeflag > 1) {
1550 msyslog(LOG_ERR,
1551 "fudge %s flag value in error",
1382 ntoa(&peeraddr));
1552 stoa(&peeraddr));
1383 errflg = i;
1384 break;
1385 }
1386 switch(c) {
1387 case CONF_FDG_FLAG1:
1388 c = CLK_FLAG1;
1389 clock_stat.haveflags|=CLK_HAVEFLAG1;
1390 break;

--- 79 unchanged lines hidden (view full) ---

1470 * peerflags is (ab)used for filegen flags
1471 */
1472 peerversion = 0;
1473 peerkey = filegen->type;
1474 peerflags = filegen->flag;
1475 errflg = 0;
1476
1477 for (i = 2; i < ntokens; i++) {
1553 errflg = i;
1554 break;
1555 }
1556 switch(c) {
1557 case CONF_FDG_FLAG1:
1558 c = CLK_FLAG1;
1559 clock_stat.haveflags|=CLK_HAVEFLAG1;
1560 break;

--- 79 unchanged lines hidden (view full) ---

1640 * peerflags is (ab)used for filegen flags
1641 */
1642 peerversion = 0;
1643 peerkey = filegen->type;
1644 peerflags = filegen->flag;
1645 errflg = 0;
1646
1647 for (i = 2; i < ntokens; i++) {
1478 switch (matchkey(tokens[i], filegen_keywords)) {
1648 switch (matchkey(tokens[i],
1649 filegen_keywords, 1)) {
1479 case CONF_FGEN_FILE:
1480 if (i >= ntokens - 1) {
1481 msyslog(LOG_ERR,
1482 "filegen %s file requires argument",
1483 tokens[1]);
1484 errflg = i;
1485 break;
1486 }
1487 peerversion = ++i;
1488 break;
1489 case CONF_FGEN_TYPE:
1490 if (i >= ntokens -1) {
1491 msyslog(LOG_ERR,
1492 "filegen %s type requires argument",
1493 tokens[1]);
1494 errflg = i;
1495 break;
1496 }
1650 case CONF_FGEN_FILE:
1651 if (i >= ntokens - 1) {
1652 msyslog(LOG_ERR,
1653 "filegen %s file requires argument",
1654 tokens[1]);
1655 errflg = i;
1656 break;
1657 }
1658 peerversion = ++i;
1659 break;
1660 case CONF_FGEN_TYPE:
1661 if (i >= ntokens -1) {
1662 msyslog(LOG_ERR,
1663 "filegen %s type requires argument",
1664 tokens[1]);
1665 errflg = i;
1666 break;
1667 }
1497 peerkey = matchkey(tokens[++i], fgen_types);
1668 peerkey = matchkey(tokens[++i],
1669 fgen_types, 1);
1498 if (peerkey == CONFIG_UNKNOWN) {
1499 msyslog(LOG_ERR,
1500 "filegen %s unknown type \"%s\"",
1501 tokens[1], tokens[i]);
1502 errflg = i;
1503 break;
1504 }
1505 break;

--- 21 unchanged lines hidden (view full) ---

1527 break;
1528
1529 case CONFIG_SETVAR:
1530 if (ntokens < 2) {
1531 msyslog(LOG_ERR,
1532 "no value for setvar command - line ignored");
1533 } else {
1534 set_sys_var(tokens[1], strlen(tokens[1])+1,
1670 if (peerkey == CONFIG_UNKNOWN) {
1671 msyslog(LOG_ERR,
1672 "filegen %s unknown type \"%s\"",
1673 tokens[1], tokens[i]);
1674 errflg = i;
1675 break;
1676 }
1677 break;

--- 21 unchanged lines hidden (view full) ---

1699 break;
1700
1701 case CONFIG_SETVAR:
1702 if (ntokens < 2) {
1703 msyslog(LOG_ERR,
1704 "no value for setvar command - line ignored");
1705 } else {
1706 set_sys_var(tokens[1], strlen(tokens[1])+1,
1535 RW |
1707 (u_short) (RW |
1536 ((((ntokens > 2)
1537 && !strcmp(tokens[2],
1538 "default")))
1539 ? DEF
1708 ((((ntokens > 2)
1709 && !strcmp(tokens[2],
1710 "default")))
1711 ? DEF
1540 : 0));
1712 : 0)));
1541 }
1542 break;
1543
1713 }
1714 break;
1715
1544 case CONFIG_CLIENTLIMIT:
1545 if (ntokens < 2) {
1546 msyslog(LOG_ERR,
1547 "no value for clientlimit command - line ignored");
1548 } else {
1549 u_long ui;
1550
1551 if (!atouint(tokens[1], &ui) || !ui) {
1552 msyslog(LOG_ERR,
1553 "illegal value for clientlimit command - line ignored");
1554 } else {
1555 char bp[80];
1556
1557#ifdef DEBUG
1558 if (debug)
1559 sprintf(bp, "client_limit=%lu", ui);
1560#endif
1561 set_sys_var(bp, strlen(bp)+1, RO);
1562 client_limit = ui;
1563 }
1564 }
1565 break;
1566
1567 case CONFIG_CLIENTPERIOD:
1568 if (ntokens < 2) {
1569 msyslog(LOG_ERR,
1570 "no value for clientperiod command - line ignored");
1571 } else {
1572 u_long ui;
1573
1574 if (!atouint(tokens[1], &ui) || ui < 64) {
1575 msyslog(LOG_ERR,
1576 "illegal value for clientperiod command - line ignored");
1577 } else {
1578 char bp[80];
1579
1580 sprintf(bp, "client_limit_period=%ld", ui);
1581 set_sys_var(bp, strlen(bp)+1, RO);
1582 client_limit_period = ui;
1583 }
1584 }
1585 break;
1586
1587 case CONFIG_ENABLE:
1588 for (i = 1; i < ntokens; i++) {
1589 int flag;
1590
1716 case CONFIG_ENABLE:
1717 for (i = 1; i < ntokens; i++) {
1718 int flag;
1719
1591 flag = matchkey(tokens[i], flags_keywords);
1720 flag = matchkey(tokens[i], flags_keywords, 1);
1592 if (flag == CONFIG_UNKNOWN) {
1593 msyslog(LOG_ERR,
1594 "enable unknown flag %s",
1595 tokens[i]);
1596 errflg = 1;
1597 break;
1598 }
1721 if (flag == CONFIG_UNKNOWN) {
1722 msyslog(LOG_ERR,
1723 "enable unknown flag %s",
1724 tokens[i]);
1725 errflg = 1;
1726 break;
1727 }
1599 proto_config(flag, 1, 0.);
1728 proto_config(flag, 1, 0., NULL);
1600 }
1601 break;
1602
1603 case CONFIG_DISABLE:
1604 for (i = 1; i < ntokens; i++) {
1605 int flag;
1606
1729 }
1730 break;
1731
1732 case CONFIG_DISABLE:
1733 for (i = 1; i < ntokens; i++) {
1734 int flag;
1735
1607 flag = matchkey(tokens[i], flags_keywords);
1736 flag = matchkey(tokens[i], flags_keywords, 1);
1608 if (flag == CONFIG_UNKNOWN) {
1609 msyslog(LOG_ERR,
1610 "disable unknown flag %s",
1611 tokens[i]);
1612 errflg = 1;
1613 break;
1614 }
1737 if (flag == CONFIG_UNKNOWN) {
1738 msyslog(LOG_ERR,
1739 "disable unknown flag %s",
1740 tokens[i]);
1741 errflg = 1;
1742 break;
1743 }
1615 proto_config(flag, 0, 0.);
1744 proto_config(flag, 0, 0., NULL);
1616 }
1617 break;
1618
1619 case CONFIG_PHONE:
1620 for (i = 1; i < ntokens && i < MAXPHONE; i++) {
1621 (void)strncpy(sys_phone[i - 1],
1622 tokens[i], MAXDIAL);
1623 }
1624 sys_phone[i - 1][0] = '\0';
1625 break;
1626
1745 }
1746 break;
1747
1748 case CONFIG_PHONE:
1749 for (i = 1; i < ntokens && i < MAXPHONE; i++) {
1750 (void)strncpy(sys_phone[i - 1],
1751 tokens[i], MAXDIAL);
1752 }
1753 sys_phone[i - 1][0] = '\0';
1754 break;
1755
1627 case CONFIG_PPS:
1628 if (ntokens < 2) {
1629 msyslog(LOG_ERR,
1630 "pps missing device name");
1631 break;
1632 }
1633 (void)strncpy(pps_device, tokens[1], MAXPPS);
1634 for (i = 2; i < ntokens; i++) {
1635 int flag;
1756 case CONFIG_ADJ: {
1757 double ftemp;
1636
1758
1637 flag = matchkey(tokens[i], pps_keywords);
1638 switch(flag) {
1639 case CONF_PPS_ASSERT:
1640 pps_assert = 0;
1641 break;
1642 case CONF_PPS_CLEAR:
1643 pps_assert = 1;
1644 break;
1645 case CONF_PPS_HARDPPS:
1646 pps_hardpps = 1;
1647 break;
1648 default:
1649 msyslog(LOG_ERR,
1650 "pps unknown flag %s",
1651 tokens[i]);
1652 errflg = 1;
1653 break;
1654 }
1655 if(errflg)
1656 break;
1759 sscanf(tokens[1], "%lf", &ftemp);
1760 proto_config(PROTO_ADJ, 0, ftemp, NULL);
1657 }
1658 break;
1761 }
1762 break;
1763
1659 }
1660 }
1661 if (fp[0])
1662 (void)fclose(fp[0]);
1663
1664#ifdef HAVE_NETINFO
1665 if (config_netinfo)
1666 free_netinfo_config(config_netinfo);

--- 8 unchanged lines hidden (view full) ---

1675
1676 /* if doesn't exist, make up one at random */
1677 if (!authhavekey(req_keyid)) {
1678 char rankey[9];
1679 int j;
1680
1681 for (i = 0; i < 8; i++)
1682 for (j = 1; j < 100; ++j) {
1764 }
1765 }
1766 if (fp[0])
1767 (void)fclose(fp[0]);
1768
1769#ifdef HAVE_NETINFO
1770 if (config_netinfo)
1771 free_netinfo_config(config_netinfo);

--- 8 unchanged lines hidden (view full) ---

1780
1781 /* if doesn't exist, make up one at random */
1782 if (!authhavekey(req_keyid)) {
1783 char rankey[9];
1784 int j;
1785
1786 for (i = 0; i < 8; i++)
1787 for (j = 1; j < 100; ++j) {
1683 rankey[i] = RANDOM & 0xff;
1788 rankey[i] = (char) (RANDOM & 0xff);
1684 if (rankey[i] != 0) break;
1685 }
1686 rankey[8] = 0;
1687 authusekey(req_keyid, KEY_TYPE_MD5, (u_char *)rankey);
1688 authtrust(req_keyid, 1);
1689 if (!authhavekey(req_keyid)) {
1690 msyslog(LOG_ERR, "getconfig: Couldn't generate a valid random key!");
1691 /* HMS: Should this be fatal? */
1692 }
1693 }
1694
1695 /* save keyid so we will accept config requests with it */
1696 info_auth_keyid = req_keyid;
1697#endif /* !defined(VMS) && !defined(SYS_VXWORKS) */
1698
1699 if (res_fp != NULL) {
1789 if (rankey[i] != 0) break;
1790 }
1791 rankey[8] = 0;
1792 authusekey(req_keyid, KEY_TYPE_MD5, (u_char *)rankey);
1793 authtrust(req_keyid, 1);
1794 if (!authhavekey(req_keyid)) {
1795 msyslog(LOG_ERR, "getconfig: Couldn't generate a valid random key!");
1796 /* HMS: Should this be fatal? */
1797 }
1798 }
1799
1800 /* save keyid so we will accept config requests with it */
1801 info_auth_keyid = req_keyid;
1802#endif /* !defined(VMS) && !defined(SYS_VXWORKS) */
1803
1804 if (res_fp != NULL) {
1700 /*
1701 * Need name resolution
1702 */
1703 do_resolve_internal();
1805 if (call_resolver) {
1806 /*
1807 * Need name resolution
1808 */
1809 do_resolve_internal();
1810 }
1704 }
1705}
1706
1707
1708#ifdef HAVE_NETINFO
1709
1710/*
1711 * get_netinfo_config - find the nearest NetInfo domain with an ntp

--- 84 unchanged lines hidden (view full) ---

1796 if (namelist.ni_namelist_len == 0) continue;
1797
1798 if (! (val_list = config->val_list = (char**)malloc(sizeof(char*) * (namelist.ni_namelist_len + 1))))
1799 { msyslog(LOG_ERR, "out of memory while configuring"); break; }
1800
1801 for (index = 0; index < namelist.ni_namelist_len; index++) {
1802 char *value = namelist.ni_namelist_val[index];
1803
1811 }
1812}
1813
1814
1815#ifdef HAVE_NETINFO
1816
1817/*
1818 * get_netinfo_config - find the nearest NetInfo domain with an ntp

--- 84 unchanged lines hidden (view full) ---

1903 if (namelist.ni_namelist_len == 0) continue;
1904
1905 if (! (val_list = config->val_list = (char**)malloc(sizeof(char*) * (namelist.ni_namelist_len + 1))))
1906 { msyslog(LOG_ERR, "out of memory while configuring"); break; }
1907
1908 for (index = 0; index < namelist.ni_namelist_len; index++) {
1909 char *value = namelist.ni_namelist_val[index];
1910
1804 if (! (val_list[index] = (char*)malloc(strlen(value+1))))
1911 if (! (val_list[index] = (char*)malloc(strlen(value)+1)))
1805 { msyslog(LOG_ERR, "out of memory while configuring"); break; }
1806
1807 strcpy(val_list[index], value);
1808 }
1809 val_list[index] = NULL;
1810
1811 break;
1812 }

--- 103 unchanged lines hidden (view full) ---

1916 break;
1917 }
1918 }
1919
1920 /*
1921 * Return the match
1922 */
1923 *ntokens = ntok + 1;
1912 { msyslog(LOG_ERR, "out of memory while configuring"); break; }
1913
1914 strcpy(val_list[index], value);
1915 }
1916 val_list[index] = NULL;
1917
1918 break;
1919 }

--- 103 unchanged lines hidden (view full) ---

2023 break;
2024 }
2025 }
2026
2027 /*
2028 * Return the match
2029 */
2030 *ntokens = ntok + 1;
1924 ntok = matchkey(tokenlist[0], keywords);
2031 ntok = matchkey(tokenlist[0], keywords, 1);
1925 if (ntok == CONFIG_UNKNOWN)
1926 goto again;
1927 return ntok;
1928}
1929
1930
1931
1932/*
1933 * matchkey - match a keyword to a list
1934 */
1935static int
1936matchkey(
1937 register char *word,
2032 if (ntok == CONFIG_UNKNOWN)
2033 goto again;
2034 return ntok;
2035}
2036
2037
2038
2039/*
2040 * matchkey - match a keyword to a list
2041 */
2042static int
2043matchkey(
2044 register char *word,
1938 register struct keyword *keys
2045 register struct keyword *keys,
2046 int complain
1939 )
1940{
1941 for (;;) {
1942 if (keys->keytype == CONFIG_UNKNOWN) {
2047 )
2048{
2049 for (;;) {
2050 if (keys->keytype == CONFIG_UNKNOWN) {
1943 msyslog(LOG_ERR,
1944 "configure: keyword \"%s\" unknown, line ignored",
1945 word);
2051 if (complain)
2052 msyslog(LOG_ERR,
2053 "configure: keyword \"%s\" unknown, line ignored",
2054 word);
1946 return CONFIG_UNKNOWN;
1947 }
1948 if (STRSAME(word, keys->text))
1949 return keys->keytype;
1950 keys++;
1951 }
1952}
1953
1954
1955/*
1956 * getnetnum - return a net number (this is crude, but careful)
1957 */
1958static int
1959getnetnum(
1960 const char *num,
2055 return CONFIG_UNKNOWN;
2056 }
2057 if (STRSAME(word, keys->text))
2058 return keys->keytype;
2059 keys++;
2060 }
2061}
2062
2063
2064/*
2065 * getnetnum - return a net number (this is crude, but careful)
2066 */
2067static int
2068getnetnum(
2069 const char *num,
1961 struct sockaddr_in *addr,
2070 struct sockaddr_storage *addr,
1962 int complain
1963 )
1964{
2071 int complain
2072 )
2073{
1965 register const char *cp;
1966 register char *bp;
1967 register int i;
1968 register int temp;
1969 char buf[80]; /* will core dump on really stupid stuff */
1970 u_int32 netnum;
2074 struct addrinfo hints;
2075 struct addrinfo *ptr;
1971
2076
1972 /* XXX ELIMINATE replace with decodenetnum */
1973 cp = num;
1974 netnum = 0;
1975 for (i = 0; i < 4; i++) {
1976 bp = buf;
1977 while (isdigit((int)*cp))
1978 *bp++ = *cp++;
1979 if (bp == buf)
1980 break;
2077 /* Get host address. Looking for UDP datagram connection */
2078 memset(&hints, 0, sizeof (hints));
2079 if (addr->ss_family == AF_INET || addr->ss_family == AF_INET6)
2080 hints.ai_family = addr->ss_family;
2081 else
2082 hints.ai_family = AF_UNSPEC;
1981
2083
1982 if (i < 3) {
1983 if (*cp++ != '.')
1984 break;
1985 } else if (*cp != '\0')
1986 break;
1987
1988 *bp = '\0';
1989 temp = atoi(buf);
1990 if (temp > 255)
1991 break;
1992 netnum <<= 8;
1993 netnum += temp;
2084 hints.ai_socktype = SOCK_DGRAM;
1994#ifdef DEBUG
1995 if (debug > 3)
2085#ifdef DEBUG
2086 if (debug > 3)
1996 printf("getnetnum %s step %d buf %s temp %d netnum %lu\n",
1997 num, i, buf, temp, (u_long)netnum);
2087 printf("getaddrinfo %s\n", num);
1998#endif
2088#endif
1999 }
2000
2001 if (i < 4) {
2089 if (getaddrinfo(num, "ntp", &hints, &ptr)!=0) {
2002 if (complain)
2003 msyslog(LOG_ERR,
2090 if (complain)
2091 msyslog(LOG_ERR,
2004 "getnetnum: \"%s\" invalid host number, line ignored",
2092 "getaddrinfo: \"%s\" invalid host address, line ignored",
2005 num);
2006#ifdef DEBUG
2007 if (debug > 3)
2008 printf(
2093 num);
2094#ifdef DEBUG
2095 if (debug > 3)
2096 printf(
2009 "getnetnum: \"%s\" invalid host number, line ignored\n",
2010 num);
2097 "getaddrinfo: \"%s\" invalid host address%s.\n",
2098 num, (complain)
2099 ? ", line ignored"
2100 : "");
2011#endif
2012 return 0;
2013 }
2014
2101#endif
2102 return 0;
2103 }
2104
2015 /*
2016 * make up socket address. Clear it out for neatness.
2017 */
2018 memset((void *)addr, 0, sizeof(struct sockaddr_in));
2019 addr->sin_family = AF_INET;
2020 addr->sin_port = htons(NTP_PORT);
2021 addr->sin_addr.s_addr = htonl(netnum);
2105 memcpy(addr, ptr->ai_addr, ptr->ai_addrlen);
2022#ifdef DEBUG
2023 if (debug > 1)
2106#ifdef DEBUG
2107 if (debug > 1)
2024 printf("getnetnum given %s, got %s (%lx)\n",
2025 num, ntoa(addr), (u_long)netnum);
2108 printf("getnetnum given %s, got %s \n",
2109 num, stoa(addr));
2026#endif
2110#endif
2111 freeaddrinfo(ptr);
2027 return 1;
2028}
2029
2030
2112 return 1;
2113}
2114
2115
2031#if !defined(VMS)
2116#if !defined(VMS) && !defined(SYS_WINNT)
2032/*
2033 * catchchild - receive the resolver's exit status
2034 */
2035static RETSIGTYPE
2036catchchild(
2037 int sig
2038 )
2039{

--- 27 unchanged lines hidden (view full) ---

2067{
2068#ifndef SYS_VXWORKS
2069 if (res_fp == NULL) {
2070#ifndef SYS_WINNT
2071 (void) strcpy(res_file, RES_TEMPFILE);
2072#else
2073 /* no /tmp directory under NT */
2074 {
2117/*
2118 * catchchild - receive the resolver's exit status
2119 */
2120static RETSIGTYPE
2121catchchild(
2122 int sig
2123 )
2124{

--- 27 unchanged lines hidden (view full) ---

2152{
2153#ifndef SYS_VXWORKS
2154 if (res_fp == NULL) {
2155#ifndef SYS_WINNT
2156 (void) strcpy(res_file, RES_TEMPFILE);
2157#else
2158 /* no /tmp directory under NT */
2159 {
2075 DWORD len;
2076 if(!(len = GetTempPath((DWORD)MAX_PATH, (LPTSTR)res_file))) {
2160 if(!(GetTempPath((DWORD)MAX_PATH, (LPTSTR)res_file))) {
2077 msyslog(LOG_ERR, "cannot get pathname for temporary directory: %m");
2078 return;
2079 }
2080 (void) strcat(res_file, "ntpdXXXXXX");
2081 }
2082#endif /* SYS_WINNT */
2083#ifdef HAVE_MKSTEMP
2084 {

--- 121 unchanged lines hidden (view full) ---

2206 *
2207 * Thanks to wgstuken@informatik.uni-erlangen.de to notice
2208 * that it is the ntp-resolver child running into trouble.
2209 *
2210 * THUS:
2211 */
2212
2213 closelog();
2161 msyslog(LOG_ERR, "cannot get pathname for temporary directory: %m");
2162 return;
2163 }
2164 (void) strcat(res_file, "ntpdXXXXXX");
2165 }
2166#endif /* SYS_WINNT */
2167#ifdef HAVE_MKSTEMP
2168 {

--- 121 unchanged lines hidden (view full) ---

2290 *
2291 * Thanks to wgstuken@informatik.uni-erlangen.de to notice
2292 * that it is the ntp-resolver child running into trouble.
2293 *
2294 * THUS:
2295 */
2296
2297 closelog();
2214 kill_asyncio();
2298 kill_asyncio(0);
2215
2216 (void) signal_no_reset(SIGCHLD, SIG_DFL);
2217
2218#ifdef DEBUG
2219 if (0)
2220 debug = 2;
2221#endif
2222

--- 38 unchanged lines hidden (view full) ---

2261#else /* SYS_WINNT */
2262 {
2263 /* NT's equivalent of fork() is _spawn(), but the start point
2264 * of the new process is an executable filename rather than
2265 * a function name as desired here.
2266 */
2267 DWORD dwThreadId;
2268 fflush(stdout);
2299
2300 (void) signal_no_reset(SIGCHLD, SIG_DFL);
2301
2302#ifdef DEBUG
2303 if (0)
2304 debug = 2;
2305#endif
2306

--- 38 unchanged lines hidden (view full) ---

2345#else /* SYS_WINNT */
2346 {
2347 /* NT's equivalent of fork() is _spawn(), but the start point
2348 * of the new process is an executable filename rather than
2349 * a function name as desired here.
2350 */
2351 DWORD dwThreadId;
2352 fflush(stdout);
2269 if (!(ResolverThreadHandle = CreateThread(
2270 NULL, /* no security attributes */
2271 0, /* use default stack size */
2353 ResolverThreadHandle = CreateThread(
2354 NULL, /* no security attributes */
2355 0, /* use default stack size */
2272 (LPTHREAD_START_ROUTINE) ntp_intres, /* thread function */
2356 (LPTHREAD_START_ROUTINE) ntp_intres, /* thread function */
2273 NULL, /* argument to thread function */
2274 0, /* use default creation flags */
2275 &dwThreadId))) { /* returns the thread identifier */
2357 NULL, /* argument to thread function */
2358 0, /* use default creation flags */
2359 &dwThreadId); /* returns the thread identifier */
2360 if (ResolverThreadHandle == NULL) {
2276 msyslog(LOG_ERR, "CreateThread() failed, can't start ntp_intres");
2277 abort_resolve();
2278 }
2279 }
2280#endif /* SYS_WINNT */
2281#else /* VMS VX_WORKS */
2282 msyslog(LOG_ERR,
2283 "Name resolution not implemented for VMS - use numeric addresses");
2284 abort_resolve();
2285#endif /* VMS VX_WORKS */
2286}
2361 msyslog(LOG_ERR, "CreateThread() failed, can't start ntp_intres");
2362 abort_resolve();
2363 }
2364 }
2365#endif /* SYS_WINNT */
2366#else /* VMS VX_WORKS */
2367 msyslog(LOG_ERR,
2368 "Name resolution not implemented for VMS - use numeric addresses");
2369 abort_resolve();
2370#endif /* VMS VX_WORKS */
2371}