1 #include <config.h>
2
3 #include <event2/util.h>
4 #include <event2/event.h>
5
6 #include "ntp_workimpl.h"
7 #ifdef WORK_THREAD
8 # include <event2/thread.h>
9 #endif
10
11 #ifdef HAVE_SYSEXITS_H
12 # include <sysexits.h>
13 #endif
14
15 #include "main.h"
16 #include "ntp_libopts.h"
17 #include "kod_management.h"
18 #include "networking.h"
19 #include "utilities.h"
20 #include "log.h"
21 #include "libntp.h"
22
23
24 int shutting_down;
25 int time_derived;
26 int time_adjusted;
27 int n_pending_dns = 0;
28 int n_pending_ntp = 0;
29 int ai_fam_pref = AF_UNSPEC;
30 int ntpver = 4;
31 double steplimit = -1;
32 SOCKET sock4 = -1; /* Socket for IPv4 */
33 SOCKET sock6 = -1; /* Socket for IPv6 */
34 /*
35 ** BCAST *must* listen on port 123 (by default), so we can only
36 ** use the UCST sockets (above) if they too are using port 123
37 */
38 SOCKET bsock4 = -1; /* Broadcast Socket for IPv4 */
39 SOCKET bsock6 = -1; /* Broadcast Socket for IPv6 */
40 struct event_base *base;
41 struct event *ev_sock4;
42 struct event *ev_sock6;
43 struct event *ev_worker_timeout;
44 struct event *ev_xmt_timer;
45
46 struct dns_ctx {
47 const char * name;
48 int flags;
49 #define CTX_BCST 0x0001
50 #define CTX_UCST 0x0002
51 #define CTX_xCST 0x0003
52 #define CTX_CONC 0x0004
53 #define CTX_unused 0xfffd
54 int key_id;
55 struct timeval timeout;
56 struct key * key;
57 };
58
59 typedef struct sent_pkt_tag sent_pkt;
60 struct sent_pkt_tag {
61 sent_pkt * link;
62 struct dns_ctx * dctx;
63 sockaddr_u addr;
64 time_t stime;
65 int done;
66 struct pkt x_pkt;
67 };
68
69 typedef struct xmt_ctx_tag xmt_ctx;
70 struct xmt_ctx_tag {
71 xmt_ctx * link;
72 SOCKET sock;
73 time_t sched;
74 sent_pkt * spkt;
75 };
76
77 struct timeval gap;
78 xmt_ctx * xmt_q;
79 struct key * keys = NULL;
80 int response_timeout;
81 struct timeval response_tv;
82 struct timeval start_tv;
83 /* check the timeout at least once per second */
84 struct timeval wakeup_tv = { 0, 888888 };
85
86 sent_pkt * fam_listheads[2];
87 #define v4_pkts_list (fam_listheads[0])
88 #define v6_pkts_list (fam_listheads[1])
89
90 static union {
91 struct pkt pkt;
92 char buf[LEN_PKT_NOMAC + NTP_MAXEXTEN + MAX_MAC_LEN];
93 } rbuf;
94
95 #define r_pkt rbuf.pkt
96
97 #ifdef HAVE_DROPROOT
98 int droproot; /* intres imports these */
99 int root_dropped;
100 #endif
101 u_long current_time; /* libntp/authkeys.c */
102
103 void open_sockets(void);
104 void handle_lookup(const char *name, int flags);
105 void sntp_addremove_fd(int fd, int is_pipe, int remove_it);
106 void worker_timeout(evutil_socket_t, short, void *);
107 void worker_resp_cb(evutil_socket_t, short, void *);
108 void sntp_name_resolved(int, int, void *, const char *, const char *,
109 const struct addrinfo *,
110 const struct addrinfo *);
111 void queue_xmt(SOCKET sock, struct dns_ctx *dctx, sent_pkt *spkt,
112 u_int xmt_delay);
113 void xmt_timer_cb(evutil_socket_t, short, void *ptr);
114 void xmt(xmt_ctx *xctx);
115 int check_kod(const struct addrinfo *ai);
116 void timeout_query(sent_pkt *);
117 void timeout_queries(void);
118 void sock_cb(evutil_socket_t, short, void *);
119 void check_exit_conditions(void);
120 void sntp_libevent_log_cb(int, const char *);
121 void set_li_vn_mode(struct pkt *spkt, char leap, char version, char mode);
122 int set_time(double offset);
123 void dec_pending_ntp(const char *, sockaddr_u *);
124 int libevent_version_ok(void);
125 int gettimeofday_cached(struct event_base *b, struct timeval *tv);
126
127
128 /*
129 * The actual main function.
130 */
131 int
sntp_main(int argc,char ** argv,const char * sntpVersion)132 sntp_main (
133 int argc,
134 char **argv,
135 const char *sntpVersion
136 )
137 {
138 int i;
139 int exitcode;
140 int optct;
141 struct event_config * evcfg;
142
143 /* Initialize logging system - sets up progname */
144 sntp_init_logging(argv[0]);
145
146 if (!libevent_version_ok())
147 exit(EX_SOFTWARE);
148
149 init_lib();
150 init_auth();
151
152 optct = ntpOptionProcess(&sntpOptions, argc, argv);
153 argc -= optct;
154 argv += optct;
155
156
157 debug = OPT_VALUE_SET_DEBUG_LEVEL;
158
159 TRACE(2, ("init_lib() done, %s%s\n",
160 (ipv4_works)
161 ? "ipv4_works "
162 : "",
163 (ipv6_works)
164 ? "ipv6_works "
165 : ""));
166 ntpver = OPT_VALUE_NTPVERSION;
167 steplimit = OPT_VALUE_STEPLIMIT / 1e3;
168 gap.tv_usec = max(0, OPT_VALUE_GAP * 1000);
169 gap.tv_usec = min(gap.tv_usec, 999999);
170
171 if (HAVE_OPT(LOGFILE))
172 open_logfile(OPT_ARG(LOGFILE));
173
174 msyslog(LOG_INFO, "%s", sntpVersion);
175
176 if (0 == argc && !HAVE_OPT(BROADCAST) && !HAVE_OPT(CONCURRENT)) {
177 printf("%s: Must supply at least one of -b hostname, -c hostname, or hostname.\n",
178 progname);
179 exit(EX_USAGE);
180 }
181
182
183 /*
184 ** Eventually, we probably want:
185 ** - separate bcst and ucst timeouts (why?)
186 ** - multiple --timeout values in the commandline
187 */
188
189 response_timeout = OPT_VALUE_TIMEOUT;
190 response_tv.tv_sec = response_timeout;
191 response_tv.tv_usec = 0;
192
193 /* IPv6 available? */
194 if (isc_net_probeipv6() != ISC_R_SUCCESS) {
195 ai_fam_pref = AF_INET;
196 TRACE(1, ("No ipv6 support available, forcing ipv4\n"));
197 } else {
198 /* Check for options -4 and -6 */
199 if (HAVE_OPT(IPV4))
200 ai_fam_pref = AF_INET;
201 else if (HAVE_OPT(IPV6))
202 ai_fam_pref = AF_INET6;
203 }
204
205 /* TODO: Parse config file if declared */
206
207 /*
208 ** Init the KOD system.
209 ** For embedded systems with no writable filesystem,
210 ** -K /dev/null can be used to disable KoD storage.
211 */
212 kod_init_kod_db(OPT_ARG(KOD), FALSE);
213
214 /* HMS: Check and see what happens if KEYFILE doesn't exist */
215 auth_init(OPT_ARG(KEYFILE), &keys);
216
217 /*
218 ** Considering employing a variable that prevents functions of doing
219 ** anything until everything is initialized properly
220 **
221 ** HMS: What exactly does the above mean?
222 */
223 event_set_log_callback(&sntp_libevent_log_cb);
224 if (debug > 0)
225 event_enable_debug_mode();
226 #ifdef WORK_THREAD
227 evthread_use_pthreads();
228 /* we use libevent from main thread only, locks should be academic */
229 if (debug > 0)
230 evthread_enable_lock_debuging();
231 #endif
232 evcfg = event_config_new();
233 if (NULL == evcfg) {
234 printf("%s: event_config_new() failed!\n", progname);
235 return -1;
236 }
237 #ifndef HAVE_SOCKETPAIR
238 event_config_require_features(evcfg, EV_FEATURE_FDS);
239 #endif
240 /* all libevent calls are from main thread */
241 /* event_config_set_flag(evcfg, EVENT_BASE_FLAG_NOLOCK); */
242 base = event_base_new_with_config(evcfg);
243 event_config_free(evcfg);
244 if (NULL == base) {
245 printf("%s: event_base_new() failed!\n", progname);
246 return -1;
247 }
248
249 /* wire into intres resolver */
250 worker_per_query = TRUE;
251 addremove_io_fd = &sntp_addremove_fd;
252
253 open_sockets();
254
255 if (HAVE_OPT(BROADCAST)) {
256 int cn = STACKCT_OPT( BROADCAST );
257 const char ** cp = STACKLST_OPT( BROADCAST );
258
259 while (cn-- > 0) {
260 handle_lookup(*cp, CTX_BCST);
261 cp++;
262 }
263 }
264
265 if (HAVE_OPT(CONCURRENT)) {
266 int cn = STACKCT_OPT( CONCURRENT );
267 const char ** cp = STACKLST_OPT( CONCURRENT );
268
269 while (cn-- > 0) {
270 handle_lookup(*cp, CTX_UCST | CTX_CONC);
271 cp++;
272 }
273 }
274
275 for (i = 0; i < argc; ++i)
276 handle_lookup(argv[i], CTX_UCST);
277
278 gettimeofday_cached(base, &start_tv);
279 event_base_dispatch(base);
280 event_base_free(base);
281
282 if (!time_adjusted &&
283 (ENABLED_OPT(STEP) || ENABLED_OPT(SLEW)))
284 exitcode = 1;
285 else
286 exitcode = 0;
287
288 return exitcode;
289 }
290
291
292 /*
293 ** open sockets and make them non-blocking
294 */
295 void
open_sockets(void)296 open_sockets(
297 void
298 )
299 {
300 sockaddr_u name;
301
302 if (-1 == sock4) {
303 sock4 = socket(PF_INET, SOCK_DGRAM, 0);
304 if (-1 == sock4) {
305 /* error getting a socket */
306 msyslog(LOG_ERR, "open_sockets: socket(PF_INET) failed: %m");
307 exit(1);
308 }
309 /* Make it non-blocking */
310 make_socket_nonblocking(sock4);
311
312 /* Let's try using a wildcard... */
313 ZERO(name);
314 AF(&name) = AF_INET;
315 SET_ADDR4N(&name, INADDR_ANY);
316 SET_PORT(&name, (HAVE_OPT(USERESERVEDPORT) ? 123 : 0));
317
318 if (-1 == bind(sock4, &name.sa,
319 SOCKLEN(&name))) {
320 msyslog(LOG_ERR, "open_sockets: bind(sock4) failed: %m");
321 exit(1);
322 }
323
324 /* Register an NTP callback for recv/timeout */
325 ev_sock4 = event_new(base, sock4,
326 EV_TIMEOUT | EV_READ | EV_PERSIST,
327 &sock_cb, NULL);
328 if (NULL == ev_sock4) {
329 msyslog(LOG_ERR,
330 "open_sockets: event_new(base, sock4) failed!");
331 } else {
332 event_add(ev_sock4, &wakeup_tv);
333 }
334 }
335
336 /* We may not always have IPv6... */
337 if (-1 == sock6 && ipv6_works) {
338 sock6 = socket(PF_INET6, SOCK_DGRAM, 0);
339 if (-1 == sock6 && ipv6_works) {
340 /* error getting a socket */
341 msyslog(LOG_ERR, "open_sockets: socket(PF_INET6) failed: %m");
342 exit(1);
343 }
344 /* Make it non-blocking */
345 make_socket_nonblocking(sock6);
346
347 /* Let's try using a wildcard... */
348 ZERO(name);
349 AF(&name) = AF_INET6;
350 SET_ADDR6N(&name, in6addr_any);
351 SET_PORT(&name, (HAVE_OPT(USERESERVEDPORT) ? 123 : 0));
352
353 if (-1 == bind(sock6, &name.sa,
354 SOCKLEN(&name))) {
355 msyslog(LOG_ERR, "open_sockets: bind(sock6) failed: %m");
356 exit(1);
357 }
358 /* Register an NTP callback for recv/timeout */
359 ev_sock6 = event_new(base, sock6,
360 EV_TIMEOUT | EV_READ | EV_PERSIST,
361 &sock_cb, NULL);
362 if (NULL == ev_sock6) {
363 msyslog(LOG_ERR,
364 "open_sockets: event_new(base, sock6) failed!");
365 } else {
366 event_add(ev_sock6, &wakeup_tv);
367 }
368 }
369
370 return;
371 }
372
373
374 /*
375 ** handle_lookup
376 */
377 void
handle_lookup(const char * name,int flags)378 handle_lookup(
379 const char *name,
380 int flags
381 )
382 {
383 struct addrinfo hints; /* Local copy is OK */
384 struct dns_ctx *ctx;
385 char * name_copy;
386 size_t name_sz;
387 size_t octets;
388
389 TRACE(1, ("handle_lookup(%s,%#x)\n", name, flags));
390
391 ZERO(hints);
392 hints.ai_family = ai_fam_pref;
393 hints.ai_flags = AI_CANONNAME | Z_AI_NUMERICSERV;
394 /*
395 ** Unless we specify a socktype, we'll get at least two
396 ** entries for each address: one for TCP and one for
397 ** UDP. That's not what we want.
398 */
399 hints.ai_socktype = SOCK_DGRAM;
400 hints.ai_protocol = IPPROTO_UDP;
401
402 name_sz = 1 + strlen(name);
403 octets = sizeof(*ctx) + name_sz; // Space for a ctx and the name
404 ctx = emalloc_zero(octets); // ctx at ctx[0]
405 name_copy = (char *)(ctx + 1); // Put the name at ctx[1]
406 memcpy(name_copy, name, name_sz); // copy the name to ctx[1]
407 ctx->name = name_copy; // point to it...
408 ctx->flags = flags;
409 ctx->timeout = response_tv;
410 ctx->key = NULL;
411
412 /* The following should arguably be passed in... */
413 if (ENABLED_OPT(AUTHENTICATION)) {
414 ctx->key_id = OPT_VALUE_AUTHENTICATION;
415 get_key(ctx->key_id, &ctx->key);
416 if (NULL == ctx->key) {
417 fprintf(stderr, "%s: Authentication with keyID %d requested, but no matching keyID found in <%s>!\n",
418 progname, ctx->key_id, OPT_ARG(KEYFILE));
419 exit(1);
420 }
421 } else {
422 ctx->key_id = -1;
423 }
424
425 ++n_pending_dns;
426 getaddrinfo_sometime(name, "123", &hints, 0,
427 &sntp_name_resolved, ctx);
428 }
429
430
431 /*
432 ** DNS Callback:
433 ** - For each IP:
434 ** - - open a socket
435 ** - - increment n_pending_ntp
436 ** - - send a request if this is a Unicast callback
437 ** - - queue wait for response
438 ** - decrement n_pending_dns
439 */
440 void
sntp_name_resolved(int rescode,int gai_errno,void * context,const char * name,const char * service,const struct addrinfo * hints,const struct addrinfo * addr)441 sntp_name_resolved(
442 int rescode,
443 int gai_errno,
444 void * context,
445 const char * name,
446 const char * service,
447 const struct addrinfo * hints,
448 const struct addrinfo * addr
449 )
450 {
451 struct dns_ctx * dctx;
452 sent_pkt * spkt;
453 const struct addrinfo * ai;
454 SOCKET sock;
455 u_int xmt_delay_v4;
456 u_int xmt_delay_v6;
457 u_int xmt_delay;
458 size_t octets;
459
460 xmt_delay_v4 = 0;
461 xmt_delay_v6 = 0;
462 dctx = context;
463 if (rescode) {
464 #ifdef EAI_SYSTEM
465 if (EAI_SYSTEM == rescode) {
466 errno = gai_errno;
467 mfprintf(stderr, "%s lookup error %m\n",
468 dctx->name);
469 } else
470 #endif
471 fprintf(stderr, "%s lookup error %s\n",
472 dctx->name, gai_strerror(rescode));
473 } else {
474 TRACE(3, ("%s [%s]\n", dctx->name,
475 (addr->ai_canonname != NULL)
476 ? addr->ai_canonname
477 : ""));
478
479 for (ai = addr; ai != NULL; ai = ai->ai_next) {
480
481 if (check_kod(ai))
482 continue;
483
484 switch (ai->ai_family) {
485
486 case AF_INET:
487 sock = sock4;
488 xmt_delay = xmt_delay_v4;
489 xmt_delay_v4++;
490 break;
491
492 case AF_INET6:
493 if (!ipv6_works)
494 continue;
495
496 sock = sock6;
497 xmt_delay = xmt_delay_v6;
498 xmt_delay_v6++;
499 break;
500
501 default:
502 msyslog(LOG_ERR, "sntp_name_resolved: unexpected ai_family: %d",
503 ai->ai_family);
504 exit(1);
505 break;
506 }
507
508 /*
509 ** We're waiting for a response for either unicast
510 ** or broadcast, so...
511 */
512 ++n_pending_ntp;
513
514 /* If this is for a unicast IP, queue a request */
515 if (dctx->flags & CTX_UCST) {
516 spkt = emalloc_zero(sizeof(*spkt));
517 spkt->dctx = dctx;
518 octets = min(ai->ai_addrlen, sizeof(spkt->addr));
519 memcpy(&spkt->addr, ai->ai_addr, octets);
520 queue_xmt(sock, dctx, spkt, xmt_delay);
521 }
522 }
523 }
524 /* n_pending_dns really should be >0 here... */
525 --n_pending_dns;
526 check_exit_conditions();
527 }
528
529
530 /*
531 ** queue_xmt
532 */
533 void
queue_xmt(SOCKET sock,struct dns_ctx * dctx,sent_pkt * spkt,u_int xmt_delay)534 queue_xmt(
535 SOCKET sock,
536 struct dns_ctx * dctx,
537 sent_pkt * spkt,
538 u_int xmt_delay
539 )
540 {
541 sockaddr_u * dest;
542 sent_pkt ** pkt_listp;
543 sent_pkt * match;
544 xmt_ctx * xctx;
545 struct timeval start_cb;
546 struct timeval delay;
547
548 dest = &spkt->addr;
549 if (IS_IPV6(dest))
550 pkt_listp = &v6_pkts_list;
551 else
552 pkt_listp = &v4_pkts_list;
553
554 /* reject attempts to add address already listed */
555 for (match = *pkt_listp; match != NULL; match = match->link) {
556 if (ADDR_PORT_EQ(&spkt->addr, &match->addr)) {
557 if (strcasecmp(spkt->dctx->name,
558 match->dctx->name))
559 printf("%s %s duplicate address from %s ignored.\n",
560 sptoa(&match->addr),
561 match->dctx->name,
562 spkt->dctx->name);
563 else
564 printf("%s %s, duplicate address ignored.\n",
565 sptoa(&match->addr),
566 match->dctx->name);
567 dec_pending_ntp(spkt->dctx->name, &spkt->addr);
568 free(spkt);
569 return;
570 }
571 }
572
573 LINK_SLIST(*pkt_listp, spkt, link);
574
575 xctx = emalloc_zero(sizeof(*xctx));
576 xctx->sock = sock;
577 xctx->spkt = spkt;
578 gettimeofday_cached(base, &start_cb);
579 xctx->sched = start_cb.tv_sec + (2 * xmt_delay);
580
581 LINK_SORT_SLIST(xmt_q, xctx, (xctx->sched < L_S_S_CUR()->sched),
582 link, xmt_ctx);
583 if (xmt_q == xctx) {
584 /*
585 * The new entry is the first scheduled. The timer is
586 * either not active or is set for the second xmt
587 * context in xmt_q.
588 */
589 if (NULL == ev_xmt_timer)
590 ev_xmt_timer = event_new(base, INVALID_SOCKET,
591 EV_TIMEOUT,
592 &xmt_timer_cb, NULL);
593 if (NULL == ev_xmt_timer) {
594 msyslog(LOG_ERR,
595 "queue_xmt: event_new(base, -1, EV_TIMEOUT) failed!");
596 exit(1);
597 }
598 ZERO(delay);
599 if (xctx->sched > start_cb.tv_sec)
600 delay.tv_sec = xctx->sched - start_cb.tv_sec;
601 event_add(ev_xmt_timer, &delay);
602 TRACE(2, ("queue_xmt: xmt timer for %u usec\n",
603 (u_int)delay.tv_usec));
604 }
605 }
606
607
608 /*
609 ** xmt_timer_cb
610 */
611 void
xmt_timer_cb(evutil_socket_t fd,short what,void * ctx)612 xmt_timer_cb(
613 evutil_socket_t fd,
614 short what,
615 void * ctx
616 )
617 {
618 struct timeval start_cb;
619 struct timeval delay;
620 xmt_ctx * x;
621
622 UNUSED_ARG(fd);
623 UNUSED_ARG(ctx);
624 DEBUG_INSIST(EV_TIMEOUT == what);
625
626 if (NULL == xmt_q || shutting_down)
627 return;
628 gettimeofday_cached(base, &start_cb);
629 if (xmt_q->sched <= start_cb.tv_sec) {
630 UNLINK_HEAD_SLIST(x, xmt_q, link);
631 TRACE(2, ("xmt_timer_cb: at .%6.6u -> %s\n",
632 (u_int)start_cb.tv_usec, stoa(&x->spkt->addr)));
633 xmt(x);
634 free(x);
635 if (NULL == xmt_q)
636 return;
637 }
638 if (xmt_q->sched <= start_cb.tv_sec) {
639 event_add(ev_xmt_timer, &gap);
640 TRACE(2, ("xmt_timer_cb: at .%6.6u gap %6.6u\n",
641 (u_int)start_cb.tv_usec,
642 (u_int)gap.tv_usec));
643 } else {
644 delay.tv_sec = xmt_q->sched - start_cb.tv_sec;
645 delay.tv_usec = 0;
646 event_add(ev_xmt_timer, &delay);
647 TRACE(2, ("xmt_timer_cb: at .%6.6u next %ld seconds\n",
648 (u_int)start_cb.tv_usec,
649 (long)delay.tv_sec));
650 }
651 }
652
653
654 /*
655 ** xmt()
656 */
657 void
xmt(xmt_ctx * xctx)658 xmt(
659 xmt_ctx * xctx
660 )
661 {
662 SOCKET sock = xctx->sock;
663 struct dns_ctx *dctx = xctx->spkt->dctx;
664 sent_pkt * spkt = xctx->spkt;
665 sockaddr_u * dst = &spkt->addr;
666 struct timeval tv_xmt;
667 struct pkt x_pkt;
668 size_t pkt_len;
669 int sent;
670
671 if (0 != gettimeofday(&tv_xmt, NULL)) {
672 msyslog(LOG_ERR,
673 "xmt: gettimeofday() failed: %m");
674 exit(1);
675 }
676 tv_xmt.tv_sec += JAN_1970;
677
678 pkt_len = generate_pkt(&x_pkt, &tv_xmt, dctx->key_id,
679 dctx->key);
680
681 sent = sendpkt(sock, dst, &x_pkt, pkt_len);
682 if (sent) {
683 /* Save the packet we sent... */
684 memcpy(&spkt->x_pkt, &x_pkt, min(sizeof(spkt->x_pkt),
685 pkt_len));
686 spkt->stime = tv_xmt.tv_sec - JAN_1970;
687
688 TRACE(2, ("xmt: %lx.%6.6u %s %s\n", (u_long)tv_xmt.tv_sec,
689 (u_int)tv_xmt.tv_usec, dctx->name, stoa(dst)));
690 } else {
691 dec_pending_ntp(dctx->name, dst);
692 }
693
694 return;
695 }
696
697
698 /*
699 * timeout_queries() -- give up on unrequited NTP queries
700 */
701 void
timeout_queries(void)702 timeout_queries(void)
703 {
704 struct timeval start_cb;
705 u_int idx;
706 sent_pkt * head;
707 sent_pkt * spkt;
708 sent_pkt * spkt_next;
709 long age;
710 int didsomething = 0;
711
712 TRACE(3, ("timeout_queries: called to check %u items\n",
713 (unsigned)COUNTOF(fam_listheads)));
714
715 gettimeofday_cached(base, &start_cb);
716 for (idx = 0; idx < COUNTOF(fam_listheads); idx++) {
717 head = fam_listheads[idx];
718 for (spkt = head; spkt != NULL; spkt = spkt_next) {
719 char xcst;
720
721 didsomething = 1;
722 switch (spkt->dctx->flags & CTX_xCST) {
723 case CTX_BCST:
724 xcst = 'B';
725 break;
726
727 case CTX_UCST:
728 xcst = 'U';
729 break;
730
731 default:
732 INSIST(!"spkt->dctx->flags neither UCST nor BCST");
733 break;
734 }
735
736 spkt_next = spkt->link;
737 if (0 == spkt->stime || spkt->done)
738 continue;
739 age = start_cb.tv_sec - spkt->stime;
740 TRACE(3, ("%s %s %cCST age %ld\n",
741 stoa(&spkt->addr),
742 spkt->dctx->name, xcst, age));
743 if (age > response_timeout)
744 timeout_query(spkt);
745 }
746 }
747 // Do we care about didsomething?
748 TRACE(3, ("timeout_queries: didsomething is %d, age is %ld\n",
749 didsomething, (long) (start_cb.tv_sec - start_tv.tv_sec)));
750 if (start_cb.tv_sec - start_tv.tv_sec > response_timeout) {
751 TRACE(3, ("timeout_queries: bail!\n"));
752 event_base_loopexit(base, NULL);
753 shutting_down = TRUE;
754 }
755 }
756
757
dec_pending_ntp(const char * name,sockaddr_u * server)758 void dec_pending_ntp(
759 const char * name,
760 sockaddr_u * server
761 )
762 {
763 if (n_pending_ntp > 0) {
764 --n_pending_ntp;
765 check_exit_conditions();
766 } else {
767 INSIST(0 == n_pending_ntp);
768 TRACE(1, ("n_pending_ntp was zero before decrement for %s\n",
769 hostnameaddr(name, server)));
770 }
771 }
772
773
timeout_query(sent_pkt * spkt)774 void timeout_query(
775 sent_pkt * spkt
776 )
777 {
778 sockaddr_u * server;
779 char xcst;
780
781
782 switch (spkt->dctx->flags & CTX_xCST) {
783 case CTX_BCST:
784 xcst = 'B';
785 break;
786
787 case CTX_UCST:
788 xcst = 'U';
789 break;
790
791 default:
792 INSIST(!"spkt->dctx->flags neither UCST nor BCST");
793 break;
794 }
795 spkt->done = TRUE;
796 server = &spkt->addr;
797 msyslog(LOG_INFO, "%s no %cCST response after %d seconds",
798 hostnameaddr(spkt->dctx->name, server), xcst,
799 response_timeout);
800 dec_pending_ntp(spkt->dctx->name, server);
801 return;
802 }
803
804
805 /*
806 ** check_kod
807 */
808 int
check_kod(const struct addrinfo * ai)809 check_kod(
810 const struct addrinfo * ai
811 )
812 {
813 char *hostname;
814 struct kod_entry *reason;
815
816 /* Is there a KoD on file for this address? */
817 hostname = addrinfo_to_str(ai);
818 TRACE(2, ("check_kod: checking <%s>\n", hostname));
819 if (search_entry(hostname, &reason)) {
820 printf("prior KoD for %s, skipping.\n",
821 hostname);
822 free(reason);
823 free(hostname);
824
825 return 1;
826 }
827 free(hostname);
828
829 return 0;
830 }
831
832
833 /*
834 ** Socket readable/timeout Callback:
835 ** Read in the packet
836 ** Unicast:
837 ** - close socket
838 ** - decrement n_pending_ntp
839 ** - If packet is good, set the time and "exit"
840 ** Broadcast:
841 ** - If packet is good, set the time and "exit"
842 */
843 void
sock_cb(evutil_socket_t fd,short what,void * ptr)844 sock_cb(
845 evutil_socket_t fd,
846 short what,
847 void *ptr
848 )
849 {
850 sockaddr_u sender;
851 sockaddr_u * psau;
852 sent_pkt ** p_pktlist;
853 sent_pkt * spkt;
854 int rpktl;
855 int rc;
856
857 INSIST(sock4 == fd || sock6 == fd);
858
859 TRACE(3, ("sock_cb: event on sock%s:%s%s%s%s\n",
860 (fd == sock6)
861 ? "6"
862 : "4",
863 (what & EV_TIMEOUT) ? " timeout" : "",
864 (what & EV_READ) ? " read" : "",
865 (what & EV_WRITE) ? " write" : "",
866 (what & EV_SIGNAL) ? " signal" : ""));
867
868 if (!(EV_READ & what)) {
869 if (EV_TIMEOUT & what)
870 timeout_queries();
871
872 return;
873 }
874
875 /* Read in the packet */
876 rpktl = recvdata(fd, &sender, &rbuf, sizeof(rbuf));
877 if (rpktl < 0) {
878 msyslog(LOG_DEBUG, "recvfrom error %m");
879 return;
880 }
881
882 if (sock6 == fd)
883 p_pktlist = &v6_pkts_list;
884 else
885 p_pktlist = &v4_pkts_list;
886
887 for (spkt = *p_pktlist; spkt != NULL; spkt = spkt->link) {
888 psau = &spkt->addr;
889 if (SOCK_EQ(&sender, psau))
890 break;
891 }
892 if (NULL == spkt) {
893 msyslog(LOG_WARNING,
894 "Packet from unexpected source %s dropped",
895 sptoa(&sender));
896 return;
897 }
898
899 TRACE(1, ("sock_cb: %s %s\n", spkt->dctx->name,
900 sptoa(&sender)));
901
902 rpktl = process_pkt(&r_pkt, &sender, rpktl, MODE_SERVER,
903 &spkt->x_pkt, "sock_cb");
904
905 TRACE(2, ("sock_cb: process_pkt returned %d\n", rpktl));
906
907 /* If this is a Unicast packet, one down ... */
908 if (!spkt->done && (CTX_UCST & spkt->dctx->flags)) {
909 dec_pending_ntp(spkt->dctx->name, &spkt->addr);
910 spkt->done = TRUE;
911 }
912
913
914 /* If the packet is good, set the time and we're all done */
915 rc = handle_pkt(rpktl, &r_pkt, &spkt->addr, spkt->dctx->name);
916 if (0 != rc)
917 TRACE(1, ("sock_cb: handle_pkt() returned %d\n", rc));
918 check_exit_conditions();
919 }
920
921
922 /*
923 * check_exit_conditions()
924 *
925 * If sntp has a reply, ask the event loop to stop after this round of
926 * callbacks, unless --wait was used.
927 */
928 void
check_exit_conditions(void)929 check_exit_conditions(void)
930 {
931 if ((0 == n_pending_ntp && 0 == n_pending_dns) ||
932 (time_derived && !HAVE_OPT(WAIT))) {
933 event_base_loopexit(base, NULL);
934 shutting_down = TRUE;
935 } else {
936 TRACE(2, ("%d NTP and %d name queries pending\n",
937 n_pending_ntp, n_pending_dns));
938 }
939 }
940
941
942 /*
943 * sntp_addremove_fd() is invoked by the intres blocking worker code
944 * to read from a pipe, or to stop same.
945 */
sntp_addremove_fd(int fd,int is_pipe,int remove_it)946 void sntp_addremove_fd(
947 int fd,
948 int is_pipe,
949 int remove_it
950 )
951 {
952 u_int idx;
953 blocking_child *c;
954 struct event * ev;
955
956 #ifdef HAVE_SOCKETPAIR
957 if (is_pipe) {
958 /* sntp only asks for EV_FEATURE_FDS without HAVE_SOCKETPAIR */
959 msyslog(LOG_ERR, "fatal: pipes not supported on systems with socketpair()");
960 exit(1);
961 }
962 #endif
963
964 c = NULL;
965 for (idx = 0; idx < blocking_children_alloc; idx++) {
966 c = blocking_children[idx];
967 if (NULL == c)
968 continue;
969 if (fd == c->resp_read_pipe)
970 break;
971 }
972 if (idx == blocking_children_alloc)
973 return;
974
975 if (remove_it) {
976 ev = c->resp_read_ctx;
977 c->resp_read_ctx = NULL;
978 event_del(ev);
979 event_free(ev);
980
981 return;
982 }
983
984 ev = event_new(base, fd, EV_READ | EV_PERSIST,
985 &worker_resp_cb, c);
986 if (NULL == ev) {
987 msyslog(LOG_ERR,
988 "sntp_addremove_fd: event_new(base, fd) failed!");
989 return;
990 }
991 c->resp_read_ctx = ev;
992 event_add(ev, NULL);
993 }
994
995
996 /* called by forked intres child to close open descriptors */
997 #ifdef WORK_FORK
998 void
kill_asyncio(int startfd)999 kill_asyncio(
1000 int startfd
1001 )
1002 {
1003 if (INVALID_SOCKET != sock4) {
1004 closesocket(sock4);
1005 sock4 = INVALID_SOCKET;
1006 }
1007 if (INVALID_SOCKET != sock6) {
1008 closesocket(sock6);
1009 sock6 = INVALID_SOCKET;
1010 }
1011 if (INVALID_SOCKET != bsock4) {
1012 closesocket(sock4);
1013 sock4 = INVALID_SOCKET;
1014 }
1015 if (INVALID_SOCKET != bsock6) {
1016 closesocket(sock6);
1017 sock6 = INVALID_SOCKET;
1018 }
1019 }
1020 #endif
1021
1022
1023 /*
1024 * worker_resp_cb() is invoked when resp_read_pipe is readable.
1025 */
1026 void
worker_resp_cb(evutil_socket_t fd,short what,void * ctx)1027 worker_resp_cb(
1028 evutil_socket_t fd,
1029 short what,
1030 void * ctx /* blocking_child * */
1031 )
1032 {
1033 blocking_child * c;
1034
1035 DEBUG_INSIST(EV_READ & what);
1036 c = ctx;
1037 DEBUG_INSIST(fd == c->resp_read_pipe);
1038 process_blocking_resp(c);
1039 }
1040
1041
1042 /*
1043 * intres_timeout_req(s) is invoked in the parent to schedule an idle
1044 * timeout to fire in s seconds, if not reset earlier by a call to
1045 * intres_timeout_req(0), which clears any pending timeout. When the
1046 * timeout expires, worker_idle_timer_fired() is invoked (again, in the
1047 * parent).
1048 *
1049 * sntp and ntpd each provide implementations adapted to their timers.
1050 */
1051 void
intres_timeout_req(u_int seconds)1052 intres_timeout_req(
1053 u_int seconds /* 0 cancels */
1054 )
1055 {
1056 struct timeval tv_to;
1057
1058 if (NULL == ev_worker_timeout) {
1059 ev_worker_timeout = event_new(base, -1,
1060 EV_TIMEOUT | EV_PERSIST,
1061 &worker_timeout, NULL);
1062 DEBUG_INSIST(NULL != ev_worker_timeout);
1063 } else {
1064 event_del(ev_worker_timeout);
1065 }
1066 if (0 == seconds)
1067 return;
1068 tv_to.tv_sec = seconds;
1069 tv_to.tv_usec = 0;
1070 event_add(ev_worker_timeout, &tv_to);
1071 }
1072
1073
1074 void
worker_timeout(evutil_socket_t fd,short what,void * ctx)1075 worker_timeout(
1076 evutil_socket_t fd,
1077 short what,
1078 void * ctx
1079 )
1080 {
1081 UNUSED_ARG(fd);
1082 UNUSED_ARG(ctx);
1083
1084 DEBUG_REQUIRE(EV_TIMEOUT & what);
1085 worker_idle_timer_fired();
1086 }
1087
1088
1089 void
sntp_libevent_log_cb(int severity,const char * msg)1090 sntp_libevent_log_cb(
1091 int severity,
1092 const char * msg
1093 )
1094 {
1095 int level;
1096
1097 switch (severity) {
1098
1099 default:
1100 case _EVENT_LOG_DEBUG:
1101 level = LOG_DEBUG;
1102 break;
1103
1104 case _EVENT_LOG_MSG:
1105 level = LOG_NOTICE;
1106 break;
1107
1108 case _EVENT_LOG_WARN:
1109 level = LOG_WARNING;
1110 break;
1111
1112 case _EVENT_LOG_ERR:
1113 level = LOG_ERR;
1114 break;
1115 }
1116
1117 msyslog(level, "%s", msg);
1118 }
1119
1120
1121 int
generate_pkt(struct pkt * x_pkt,const struct timeval * tv_xmt,int key_id,struct key * pkt_key)1122 generate_pkt (
1123 struct pkt *x_pkt,
1124 const struct timeval *tv_xmt,
1125 int key_id,
1126 struct key *pkt_key
1127 )
1128 {
1129 l_fp xmt_fp;
1130 int pkt_len;
1131 int mac_size;
1132
1133 pkt_len = LEN_PKT_NOMAC;
1134 ZERO(*x_pkt);
1135 TVTOTS(tv_xmt, &xmt_fp);
1136 HTONL_FP(&xmt_fp, &x_pkt->xmt);
1137 x_pkt->stratum = STRATUM_TO_PKT(STRATUM_UNSPEC);
1138 x_pkt->ppoll = 8;
1139 /* FIXME! Modus broadcast + adr. check -> bdr. pkt */
1140 set_li_vn_mode(x_pkt, LEAP_NOTINSYNC, ntpver, 3);
1141 if (debug > 0) {
1142 printf("generate_pkt: key_id %d, key pointer %p\n", key_id, pkt_key);
1143 }
1144 if (pkt_key != NULL) {
1145 x_pkt->exten[0] = htonl(key_id);
1146 mac_size = make_mac(x_pkt, pkt_len, MAX_MDG_LEN,
1147 pkt_key, (char *)&x_pkt->exten[1]);
1148 if (mac_size > 0)
1149 pkt_len += mac_size + KEY_MAC_LEN;
1150 #ifdef DEBUG
1151 if (debug > 0) {
1152 printf("generate_pkt: mac_size is %d\n", mac_size);
1153 }
1154 #endif
1155
1156 }
1157 return pkt_len;
1158 }
1159
1160
1161 int
handle_pkt(int rpktl,struct pkt * rpkt,sockaddr_u * host,const char * hostname)1162 handle_pkt(
1163 int rpktl,
1164 struct pkt * rpkt,
1165 sockaddr_u * host,
1166 const char * hostname
1167 )
1168 {
1169 char disptxt[32];
1170 const char * addrtxt;
1171 struct timeval tv_dst;
1172 int cnt;
1173 int sw_case;
1174 int digits;
1175 int stratum;
1176 char * ref;
1177 char * ts_str;
1178 const char * leaptxt;
1179 double offset;
1180 double precision;
1181 double synch_distance;
1182 char * p_SNTP_PRETEND_TIME;
1183 time_t pretend_time;
1184 #if SIZEOF_TIME_T == 8
1185 long long ll;
1186 #else
1187 long l;
1188 #endif
1189
1190 ts_str = NULL;
1191
1192 if (rpktl > 0)
1193 sw_case = 1;
1194 else
1195 sw_case = rpktl;
1196
1197 switch (sw_case) {
1198
1199 case SERVER_UNUSEABLE:
1200 return -1;
1201 break;
1202
1203 case PACKET_UNUSEABLE:
1204 break;
1205
1206 case SERVER_AUTH_FAIL:
1207 break;
1208
1209 case KOD_DEMOBILIZE:
1210 /* Received a DENY or RESTR KOD packet */
1211 addrtxt = stoa(host);
1212 ref = (char *)&rpkt->refid;
1213 add_entry(addrtxt, ref);
1214 msyslog(LOG_WARNING, "KOD code %c%c%c%c from %s %s",
1215 ref[0], ref[1], ref[2], ref[3], addrtxt, hostname);
1216 break;
1217
1218 case KOD_RATE:
1219 /*
1220 ** Hmm...
1221 ** We should probably call add_entry() with an
1222 ** expiration timestamp of several seconds in the future,
1223 ** and back-off even more if we get more RATE responses.
1224 */
1225 break;
1226
1227 case 1:
1228 TRACE(3, ("handle_pkt: %d bytes from %s %s\n",
1229 rpktl, stoa(host), hostname));
1230
1231 gettimeofday_cached(base, &tv_dst);
1232
1233 p_SNTP_PRETEND_TIME = getenv("SNTP_PRETEND_TIME");
1234 if (p_SNTP_PRETEND_TIME) {
1235 pretend_time = 0;
1236 #if SIZEOF_TIME_T == 4
1237 if (1 == sscanf(p_SNTP_PRETEND_TIME, "%ld", &l))
1238 pretend_time = (time_t)l;
1239 #elif SIZEOF_TIME_T == 8
1240 if (1 == sscanf(p_SNTP_PRETEND_TIME, "%lld", &ll))
1241 pretend_time = (time_t)ll;
1242 #else
1243 # include "GRONK: unexpected value for SIZEOF_TIME_T"
1244 #endif
1245 if (0 != pretend_time)
1246 tv_dst.tv_sec = pretend_time;
1247 }
1248
1249 offset_calculation(rpkt, rpktl, &tv_dst, &offset,
1250 &precision, &synch_distance);
1251 time_derived = TRUE;
1252
1253 for (digits = 0; (precision *= 10.) < 1.; ++digits)
1254 /* empty */ ;
1255 if (digits > 6)
1256 digits = 6;
1257
1258 ts_str = tv_to_str(&tv_dst);
1259 stratum = rpkt->stratum;
1260 if (0 == stratum)
1261 stratum = 16;
1262
1263 if (synch_distance > 0.) {
1264 cnt = snprintf(disptxt, sizeof(disptxt),
1265 " +/- %f", synch_distance);
1266 if ((size_t)cnt >= sizeof(disptxt))
1267 snprintf(disptxt, sizeof(disptxt),
1268 "ERROR %d >= %d", cnt,
1269 (int)sizeof(disptxt));
1270 } else {
1271 disptxt[0] = '\0';
1272 }
1273
1274 switch (PKT_LEAP(rpkt->li_vn_mode)) {
1275 case LEAP_NOWARNING:
1276 leaptxt = "no-leap";
1277 break;
1278 case LEAP_ADDSECOND:
1279 leaptxt = "add-leap";
1280 break;
1281 case LEAP_DELSECOND:
1282 leaptxt = "del-leap";
1283 break;
1284 case LEAP_NOTINSYNC:
1285 leaptxt = "unsync";
1286 break;
1287 default:
1288 leaptxt = "LEAP-ERROR";
1289 break;
1290 }
1291
1292 msyslog(LOG_INFO, "%s %+.*f%s %s s%d %s%s", ts_str,
1293 digits, offset, disptxt,
1294 hostnameaddr(hostname, host), stratum,
1295 leaptxt,
1296 (time_adjusted)
1297 ? " [excess]"
1298 : "");
1299 free(ts_str);
1300
1301 if (p_SNTP_PRETEND_TIME)
1302 return 0;
1303
1304 if (!time_adjusted &&
1305 (ENABLED_OPT(STEP) || ENABLED_OPT(SLEW)))
1306 return set_time(offset);
1307
1308 return EX_OK;
1309 }
1310
1311 return 1;
1312 }
1313
1314
1315 void
offset_calculation(struct pkt * rpkt,int rpktl,struct timeval * tv_dst,double * offset,double * precision,double * synch_distance)1316 offset_calculation(
1317 struct pkt *rpkt,
1318 int rpktl,
1319 struct timeval *tv_dst,
1320 double *offset,
1321 double *precision,
1322 double *synch_distance
1323 )
1324 {
1325 l_fp p_rec, p_xmt, p_ref, p_org, tmp, dst;
1326 u_fp p_rdly, p_rdsp;
1327 double t21, t34, delta;
1328
1329 /* Convert timestamps from network to host byte order */
1330 p_rdly = NTOHS_FP(rpkt->rootdelay);
1331 p_rdsp = NTOHS_FP(rpkt->rootdisp);
1332 NTOHL_FP(&rpkt->reftime, &p_ref);
1333 NTOHL_FP(&rpkt->org, &p_org);
1334 NTOHL_FP(&rpkt->rec, &p_rec);
1335 NTOHL_FP(&rpkt->xmt, &p_xmt);
1336
1337 *precision = LOGTOD(rpkt->precision);
1338
1339 TRACE(3, ("offset_calculation: LOGTOD(rpkt->precision): %f\n", *precision));
1340
1341 /* Compute offset etc. */
1342 tmp = p_rec;
1343 L_SUB(&tmp, &p_org);
1344 LFPTOD(&tmp, t21);
1345 TVTOTS(tv_dst, &dst);
1346 dst.l_ui += JAN_1970;
1347 tmp = p_xmt;
1348 L_SUB(&tmp, &dst);
1349 LFPTOD(&tmp, t34);
1350 *offset = (t21 + t34) / 2.;
1351 delta = t21 - t34;
1352
1353 // synch_distance is:
1354 // (peer->delay + peer->rootdelay) / 2 + peer->disp
1355 // + peer->rootdisp + clock_phi * (current_time - peer->update)
1356 // + peer->jitter;
1357 //
1358 // and peer->delay = fabs(peer->offset - p_offset) * 2;
1359 // and peer->offset needs history, so we're left with
1360 // p_offset = (t21 + t34) / 2.;
1361 // peer->disp = 0; (we have no history to augment this)
1362 // clock_phi = 15e-6;
1363 // peer->jitter = LOGTOD(sys_precision); (we have no history to augment this)
1364 // and ntp_proto.c:set_sys_tick_precision() should get us sys_precision.
1365 //
1366 // so our answer seems to be:
1367 //
1368 // (fabs(t21 + t34) + peer->rootdelay) / 3.
1369 // + 0 (peer->disp)
1370 // + peer->rootdisp
1371 // + 15e-6 (clock_phi)
1372 // + LOGTOD(sys_precision)
1373
1374 INSIST( FPTOD(p_rdly) >= 0. );
1375 #if 1
1376 *synch_distance = (fabs(t21 + t34) + FPTOD(p_rdly)) / 3.
1377 + 0.
1378 + FPTOD(p_rdsp)
1379 + 15e-6
1380 + 0. /* LOGTOD(sys_precision) when we can get it */
1381 ;
1382 INSIST( *synch_distance >= 0. );
1383 #else
1384 *synch_distance = (FPTOD(p_rdly) + FPTOD(p_rdsp))/2.0;
1385 #endif
1386
1387 #ifdef DEBUG
1388 if (debug > 3) {
1389 printf("sntp rootdelay: %f\n", FPTOD(p_rdly));
1390 printf("sntp rootdisp: %f\n", FPTOD(p_rdsp));
1391 printf("sntp syncdist: %f\n", *synch_distance);
1392
1393 pkt_output(rpkt, rpktl, stdout);
1394
1395 printf("sntp offset_calculation: rpkt->reftime:\n");
1396 l_fp_output(&p_ref, stdout);
1397 printf("sntp offset_calculation: rpkt->org:\n");
1398 l_fp_output(&p_org, stdout);
1399 printf("sntp offset_calculation: rpkt->rec:\n");
1400 l_fp_output(&p_rec, stdout);
1401 printf("sntp offset_calculation: rpkt->xmt:\n");
1402 l_fp_output(&p_xmt, stdout);
1403 }
1404 #endif
1405
1406 TRACE(3, ("sntp offset_calculation:\trec - org t21: %.6f\n"
1407 "\txmt - dst t34: %.6f\tdelta: %.6f\toffset: %.6f\n",
1408 t21, t34, delta, *offset));
1409
1410 return;
1411 }
1412
1413
1414
1415 /* Compute the 8 bits for li_vn_mode */
1416 void
set_li_vn_mode(struct pkt * spkt,char leap,char version,char mode)1417 set_li_vn_mode (
1418 struct pkt *spkt,
1419 char leap,
1420 char version,
1421 char mode
1422 )
1423 {
1424 if (leap > 3) {
1425 msyslog(LOG_DEBUG, "set_li_vn_mode: leap > 3, using max. 3");
1426 leap = 3;
1427 }
1428
1429 if ((unsigned char)version > 7) {
1430 msyslog(LOG_DEBUG, "set_li_vn_mode: version < 0 or > 7, using 4");
1431 version = 4;
1432 }
1433
1434 if (mode > 7) {
1435 msyslog(LOG_DEBUG, "set_li_vn_mode: mode > 7, using client mode 3");
1436 mode = 3;
1437 }
1438
1439 spkt->li_vn_mode = leap << 6;
1440 spkt->li_vn_mode |= version << 3;
1441 spkt->li_vn_mode |= mode;
1442 }
1443
1444
1445 /*
1446 ** set_time applies 'offset' to the local clock.
1447 */
1448 int
set_time(double offset)1449 set_time(
1450 double offset
1451 )
1452 {
1453 int rc;
1454
1455 if (time_adjusted)
1456 return EX_OK;
1457
1458 /*
1459 ** If we can step but we cannot slew, then step.
1460 ** If we can step or slew and and |offset| > steplimit, then step.
1461 */
1462 if (ENABLED_OPT(STEP) &&
1463 ( !ENABLED_OPT(SLEW)
1464 || (ENABLED_OPT(SLEW) && (fabs(offset) > steplimit))
1465 )) {
1466 rc = step_systime(offset);
1467
1468 /* If there was a problem, can we rely on errno? */
1469 if (1 == rc)
1470 time_adjusted = TRUE;
1471 return (time_adjusted)
1472 ? EX_OK
1473 : 1;
1474 /*
1475 ** In case of error, what should we use?
1476 ** EX_UNAVAILABLE?
1477 ** EX_OSERR?
1478 ** EX_NOPERM?
1479 */
1480 }
1481
1482 if (ENABLED_OPT(SLEW)) {
1483 rc = adj_systime(offset);
1484
1485 /* If there was a problem, can we rely on errno? */
1486 if (1 == rc)
1487 time_adjusted = TRUE;
1488 return (time_adjusted)
1489 ? EX_OK
1490 : 1;
1491 /*
1492 ** In case of error, what should we use?
1493 ** EX_UNAVAILABLE?
1494 ** EX_OSERR?
1495 ** EX_NOPERM?
1496 */
1497 }
1498
1499 return EX_SOFTWARE;
1500 }
1501
1502
1503 int
libevent_version_ok(void)1504 libevent_version_ok(void)
1505 {
1506 ev_uint32_t v_compile_maj;
1507 ev_uint32_t v_run_maj;
1508
1509 v_compile_maj = LIBEVENT_VERSION_NUMBER & 0xffff0000;
1510 v_run_maj = event_get_version_number() & 0xffff0000;
1511 if (v_compile_maj != v_run_maj) {
1512 fprintf(stderr,
1513 "Incompatible libevent versions: have %s, built with %s\n",
1514 event_get_version(),
1515 LIBEVENT_VERSION);
1516 return 0;
1517 }
1518 return 1;
1519 }
1520
1521 /*
1522 * gettimeofday_cached()
1523 *
1524 * Clones the event_base_gettimeofday_cached() interface but ensures the
1525 * times are always on the gettimeofday() 1970 scale. Older libevent 2
1526 * sometimes used gettimeofday(), sometimes the since-system-start
1527 * clock_gettime(CLOCK_MONOTONIC), depending on the platform.
1528 *
1529 * It is not cleanly possible to tell which timescale older libevent is
1530 * using.
1531 *
1532 * The strategy involves 1 hour thresholds chosen to be far longer than
1533 * the duration of a round of libevent callbacks, which share a cached
1534 * start-of-round time. First compare the last cached time with the
1535 * current gettimeofday() time. If they are within one hour, libevent
1536 * is using the proper timescale so leave the offset 0. Otherwise,
1537 * compare libevent's cached time and the current time on the monotonic
1538 * scale. If they are within an hour, libevent is using the monotonic
1539 * scale so calculate the offset to add to such times to bring them to
1540 * gettimeofday()'s scale.
1541 */
1542 int
gettimeofday_cached(struct event_base * b,struct timeval * caller_tv)1543 gettimeofday_cached(
1544 struct event_base * b,
1545 struct timeval * caller_tv
1546 )
1547 {
1548 #if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
1549 static struct event_base * cached_b;
1550 static struct timeval cached;
1551 static struct timeval adj_cached;
1552 static struct timeval offset;
1553 static int offset_ready;
1554 struct timeval latest;
1555 struct timeval systemt;
1556 struct timespec ts;
1557 struct timeval mono;
1558 struct timeval diff;
1559 int cgt_rc;
1560 int gtod_rc;
1561
1562 event_base_gettimeofday_cached(b, &latest);
1563 if (b == cached_b &&
1564 !memcmp(&latest, &cached, sizeof(latest))) {
1565 *caller_tv = adj_cached;
1566 return 0;
1567 }
1568 cached = latest;
1569 cached_b = b;
1570 if (!offset_ready) {
1571 cgt_rc = clock_gettime(CLOCK_MONOTONIC, &ts);
1572 gtod_rc = gettimeofday(&systemt, NULL);
1573 if (0 != gtod_rc) {
1574 msyslog(LOG_ERR,
1575 "%s: gettimeofday() error %m",
1576 progname);
1577 exit(1);
1578 }
1579 diff = sub_tval(systemt, latest);
1580 if (debug > 1)
1581 printf("system minus cached %+ld.%06ld\n",
1582 (long)diff.tv_sec, (long)diff.tv_usec);
1583 if (0 != cgt_rc || labs((long)diff.tv_sec) < 3600) {
1584 /*
1585 * Either use_monotonic == 0, or this libevent
1586 * has been repaired. Leave offset at zero.
1587 */
1588 } else {
1589 mono.tv_sec = ts.tv_sec;
1590 mono.tv_usec = ts.tv_nsec / 1000;
1591 diff = sub_tval(latest, mono);
1592 if (debug > 1)
1593 printf("cached minus monotonic %+ld.%06ld\n",
1594 (long)diff.tv_sec, (long)diff.tv_usec);
1595 if (labs((long)diff.tv_sec) < 3600) {
1596 /* older libevent2 using monotonic */
1597 offset = sub_tval(systemt, mono);
1598 TRACE(1, ("%s: Offsetting libevent CLOCK_MONOTONIC times by %+ld.%06ld\n",
1599 "gettimeofday_cached",
1600 (long)offset.tv_sec,
1601 (long)offset.tv_usec));
1602 }
1603 }
1604 offset_ready = TRUE;
1605 }
1606 adj_cached = add_tval(cached, offset);
1607 *caller_tv = adj_cached;
1608
1609 return 0;
1610 #else
1611 return event_base_gettimeofday_cached(b, caller_tv);
1612 #endif
1613 }
1614
1615 /* Dummy function to satisfy libntp/work_fork.c */
1616 extern int set_user_group_ids(void);
set_user_group_ids(void)1617 int set_user_group_ids(void)
1618 {
1619 return 1;
1620 }
1621