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