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