src/timesync/timesyncd.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2014 Kay Sievers
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27 #include <time.h>
  28 #include <math.h>
  29 #include <arpa/inet.h>
  30 #include <netinet/in.h>
  31 #include <netinet/ip.h>
  32 #include <sys/timerfd.h>
  33 #include <sys/timex.h>
  34 #include <sys/socket.h>
  35
  36 #include "missing.h"
  37 #include "util.h"
  38 #include "sparse-endian.h"
  39 #include "log.h"
  40 #include "socket-util.h"
  41 #include "list.h"
  42 #include "ratelimit.h"
  43 #include "strv.h"
  44 #include "sd-event.h"
  45 #include "sd-resolve.h"
  46 #include "sd-daemon.h"
  47
  48 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
  49
  50 #ifndef ADJ_SETOFFSET
  51 #define ADJ_SETOFFSET                   0x0100  /* add 'time' to current time */
  52 #endif
  53
  54 /* expected accuracy of time synchronization; used to adjust the poll interval */
  55 #define NTP_ACCURACY_SEC                0.2
  56
  57 /*
  58  * "A client MUST NOT under any conditions use a poll interval less
  59  * than 15 seconds."
  60  */
  61 #define NTP_POLL_INTERVAL_MIN_SEC       32
  62 #define NTP_POLL_INTERVAL_MAX_SEC       2048
  63
  64 /*
  65  * Maximum delta in seconds which the system clock is gradually adjusted
  66  * (slew) to approach the network time. Deltas larger that this are set by
  67  * letting the system time jump. The kernel's limit for adjtime is 0.5s.
  68  */
  69 #define NTP_MAX_ADJUST                  0.4
  70
  71 /* NTP protocol, packet header */
  72 #define NTP_LEAP_PLUSSEC                1
  73 #define NTP_LEAP_MINUSSEC               2
  74 #define NTP_LEAP_NOTINSYNC              3
  75 #define NTP_MODE_CLIENT                 3
  76 #define NTP_MODE_SERVER                 4
  77 #define NTP_FIELD_LEAP(f)               (((f) >> 6) & 3)
  78 #define NTP_FIELD_VERSION(f)            (((f) >> 3) & 7)
  79 #define NTP_FIELD_MODE(f)               ((f) & 7)
  80 #define NTP_FIELD(l, v, m)              (((l) << 6) | ((v) << 3) | (m))
  81
  82 /*
  83  * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
  84  * in seconds relative to 0h on 1 January 1900."
  85  */
  86 #define OFFSET_1900_1970        2208988800UL
  87
  88 #define RETRY_USEC (30*USEC_PER_SEC)
  89 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
  90 #define RATELIMIT_BURST 10
  91
  92 struct ntp_ts {
  93         be32_t sec;
  94         be32_t frac;
  95 } _packed_;
  96
  97 struct ntp_ts_short {
  98         be16_t sec;
  99         be16_t frac;
 100 } _packed_;
 101
 102 struct ntp_msg {
 103         uint8_t field;
 104         uint8_t stratum;
 105         int8_t poll;
 106         int8_t precision;
 107         struct ntp_ts_short root_delay;
 108         struct ntp_ts_short root_dispersion;
 109         char refid[4];
 110         struct ntp_ts reference_time;
 111         struct ntp_ts origin_time;
 112         struct ntp_ts recv_time;
 113         struct ntp_ts trans_time;
 114 } _packed_;
 115
 116 typedef struct Manager Manager;
 117 typedef struct ServerAddress ServerAddress;
 118 typedef struct ServerName ServerName;
 119
 120 struct ServerAddress {
 121         union sockaddr_union sockaddr;
 122         socklen_t socklen;
 123         LIST_FIELDS(ServerAddress, addresses);
 124 };
 125
 126 struct ServerName {
 127         char *string;
 128         LIST_HEAD(ServerAddress, addresses);
 129         LIST_FIELDS(ServerName, names);
 130 };
 131
 132 struct Manager {
 133         sd_event *event;
 134         sd_resolve *resolve;
 135
 136         LIST_HEAD(ServerName, servers);
 137
 138         RateLimit ratelimit;
 139
 140         /* peer */
 141         sd_resolve_query *resolve_query;
 142         sd_event_source *event_receive;
 143         ServerName *current_server_name;
 144         ServerAddress *current_server_address;
 145         int server_socket;
 146         uint64_t packet_count;
 147
 148         /* last sent packet */
 149         struct timespec trans_time_mon;
 150         struct timespec trans_time;
 151         usec_t retry_interval;
 152         bool pending;
 153
 154         /* poll timer */
 155         sd_event_source *event_timer;
 156         usec_t poll_interval_usec;
 157         bool poll_resync;
 158
 159         /* history data */
 160         struct {
 161                 double offset;
 162                 double delay;
 163         } samples[8];
 164         unsigned int samples_idx;
 165         double samples_jitter;
 166
 167         /* last change */
 168         bool jumped;
 169         int drift_ppm;
 170
 171         /* watch for time changes */
 172         sd_event_source *event_clock_watch;
 173         int clock_watch_fd;
 174
 175         /* Retry connections */
 176         sd_event_source *event_retry;
 177
 178         /* Handle SIGINT/SIGTERM */
 179         sd_event_source *sigterm, *sigint;
 180 };
 181
 182 static void manager_free(Manager *m);
 183 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
 184 #define _cleanup_manager_free_ _cleanup_(manager_freep)
 185
 186 static int manager_arm_timer(Manager *m, usec_t next);
 187 static int manager_clock_watch_setup(Manager *m);
 188 static int manager_connect(Manager *m);
 189 static void manager_disconnect(Manager *m);
 190
 191 static double ntp_ts_to_d(const struct ntp_ts *ts) {
 192         return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
 193 }
 194
 195 static double ts_to_d(const struct timespec *ts) {
 196         return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
 197 }
 198
 199 static double tv_to_d(const struct timeval *tv) {
 200         return tv->tv_sec + (1.0e-6 * tv->tv_usec);
 201 }
 202
 203 static double square(double d) {
 204         return d * d;
 205 }
 206
 207 static int manager_send_request(Manager *m) {
 208         _cleanup_free_ char *pretty = NULL;
 209         struct ntp_msg ntpmsg = {
 210                 /*
 211                  * "The client initializes the NTP message header, sends the request
 212                  * to the server, and strips the time of day from the Transmit
 213                  * Timestamp field of the reply.  For this purpose, all the NTP
 214                  * header fields are set to 0, except the Mode, VN, and optional
 215                  * Transmit Timestamp fields."
 216                  */
 217                 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
 218         };
 219         ssize_t len;
 220         int r;
 221
 222         assert(m);
 223         assert(m->current_server_name);
 224         assert(m->current_server_address);
 225
 226         /*
 227          * Set transmit timestamp, remember it; the server will send that back
 228          * as the origin timestamp and we have an indication that this is the
 229          * matching answer to our request.
 230          *
 231          * The actual value does not matter, We do not care about the correct
 232          * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
 233          */
 234         assert_se(clock_gettime(CLOCK_MONOTONIC, &m->trans_time_mon) >= 0);
 235         assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
 236         ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
 237         ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
 238
 239         r = sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
 240         if (r < 0) {
 241                 log_error("Failed to format sockaddr: %s", strerror(-r));
 242                 return r;
 243         }
 244
 245         len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
 246         if (len == sizeof(ntpmsg)) {
 247                 m->pending = true;
 248                 log_debug("Sent NTP request to %s (%s)", pretty, m->current_server_name->string);
 249         } else {
 250                 log_debug("Sending NTP request to %s (%s) failed: %m", pretty, m->current_server_name->string);
 251                 return manager_connect(m);
 252         }
 253
 254         /* re-arm timer with incresing timeout, in case the packets never arrive back */
 255         if (m->retry_interval > 0) {
 256                 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 257                         m->retry_interval *= 2;
 258         } else
 259                 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 260
 261         r = manager_arm_timer(m, m->retry_interval);
 262         if (r < 0) {
 263                 log_error("Failed to rearm timer: %s", strerror(-r));
 264                 return r;
 265         }
 266
 267         return 0;
 268 }
 269
 270 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
 271         Manager *m = userdata;
 272
 273         assert(m);
 274
 275         return manager_send_request(m);
 276 }
 277
 278 static int manager_arm_timer(Manager *m, usec_t next) {
 279         int r;
 280
 281         assert(m);
 282         assert(m->event_receive);
 283
 284         if (next == 0) {
 285                 m->event_timer = sd_event_source_unref(m->event_timer);
 286                 return 0;
 287         }
 288
 289         if (m->event_timer) {
 290                 r = sd_event_source_set_time(m->event_timer, now(CLOCK_MONOTONIC) + next);
 291                 if (r < 0)
 292                         return r;
 293
 294                 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
 295         }
 296
 297         return sd_event_add_time(
 298                         m->event,
 299                         &m->event_timer,
 300                         CLOCK_MONOTONIC,
 301                         now(CLOCK_MONOTONIC) + next, 0,
 302                         manager_timer, m);
 303 }
 304
 305 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 306         Manager *m = userdata;
 307
 308         assert(m);
 309
 310         /* rearm timer */
 311         manager_clock_watch_setup(m);
 312
 313         /* skip our own jumps */
 314         if (m->jumped) {
 315                 m->jumped = false;
 316                 return 0;
 317         }
 318
 319         /* resync */
 320         log_info("System time changed. Resyncing.");
 321         m->poll_resync = true;
 322         return manager_send_request(m);
 323 }
 324
 325 /* wake up when the system time changes underneath us */
 326 static int manager_clock_watch_setup(Manager *m) {
 327
 328         struct itimerspec its = {
 329                 .it_value.tv_sec = TIME_T_MAX
 330         };
 331
 332         int r;
 333
 334         assert(m);
 335
 336         m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
 337         m->clock_watch_fd = safe_close(m->clock_watch_fd);
 338
 339         m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
 340         if (m->clock_watch_fd < 0) {
 341                 log_error("Failed to create timerfd: %m");
 342                 return -errno;
 343         }
 344
 345         if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
 346                 log_error("Failed to set up timerfd: %m");
 347                 return -errno;
 348         }
 349
 350         r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
 351         if (r < 0) {
 352                 log_error("Failed to create clock watch event source: %s", strerror(-r));
 353                 return r;
 354         }
 355
 356         return 0;
 357 }
 358
 359 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
 360         struct timex tmx = {};
 361         int r;
 362
 363         assert(m);
 364
 365         /*
 366          * For small deltas, tell the kernel to gradually adjust the system
 367          * clock to the NTP time, larger deltas are just directly set.
 368          *
 369          * Clear STA_UNSYNC, it will enable the kernel's 11-minute mode, which
 370          * syncs the system time periodically to the hardware clock.
 371          */
 372         if (fabs(offset) < NTP_MAX_ADJUST) {
 373                 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
 374                 tmx.status = STA_PLL;
 375                 tmx.offset = offset * NSEC_PER_SEC;
 376                 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
 377                 tmx.maxerror = 0;
 378                 tmx.esterror = 0;
 379                 log_debug("  adjust (slew): %+.3f sec\n", offset);
 380         } else {
 381                 tmx.modes = ADJ_SETOFFSET | ADJ_NANO;
 382
 383                 /* ADJ_NANO uses nanoseconds in the microseconds field */
 384                 tmx.time.tv_sec = (long)offset;
 385                 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
 386
 387                 /* the kernel expects -0.3s as {-1, 7000.000.000} */
 388                 if (tmx.time.tv_usec < 0) {
 389                         tmx.time.tv_sec  -= 1;
 390                         tmx.time.tv_usec += NSEC_PER_SEC;
 391                 }
 392
 393                 m->jumped = true;
 394                 log_debug("  adjust (jump): %+.3f sec\n", offset);
 395         }
 396
 397         switch (leap_sec) {
 398         case 1:
 399                 tmx.status |= STA_INS;
 400                 break;
 401         case -1:
 402                 tmx.status |= STA_DEL;
 403                 break;
 404         }
 405
 406         r = clock_adjtime(CLOCK_REALTIME, &tmx);
 407         if (r < 0)
 408                 return r;
 409
 410         m->drift_ppm = tmx.freq / 65536;
 411
 412         log_debug("  status       : %04i %s\n"
 413                   "  time now     : %li.%03lli\n"
 414                   "  constant     : %li\n"
 415                   "  offset       : %+.3f sec\n"
 416                   "  freq offset  : %+li (%i ppm)\n",
 417                   tmx.status, tmx.status & STA_UNSYNC ? "" : "sync",
 418                   tmx.time.tv_sec, tmx.time.tv_usec / NSEC_PER_MSEC,
 419                   tmx.constant,
 420                   (double)tmx.offset / NSEC_PER_SEC,
 421                   tmx.freq, m->drift_ppm);
 422
 423         return 0;
 424 }
 425
 426 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
 427         unsigned int i, idx_cur, idx_new, idx_min;
 428         double jitter;
 429         double j;
 430
 431         assert(m);
 432
 433         m->packet_count++;
 434
 435         /* ignore initial sample */
 436         if (m->packet_count == 1)
 437                 return false;
 438
 439         /* store the current data in our samples array */
 440         idx_cur = m->samples_idx;
 441         idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
 442         m->samples_idx = idx_new;
 443         m->samples[idx_new].offset = offset;
 444         m->samples[idx_new].delay = delay;
 445
 446         /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
 447         jitter = m->samples_jitter;
 448         for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
 449                 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
 450                         idx_min = i;
 451
 452         j = 0;
 453         for (i = 0; i < ELEMENTSOF(m->samples); i++)
 454                 j += square(m->samples[i].offset - m->samples[idx_min].offset);
 455         m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
 456
 457         /* ignore samples when resyncing */
 458         if (m->poll_resync)
 459                 return false;
 460
 461         /* always accept offset if we are farther off than the round-trip delay */
 462         if (fabs(offset) > delay)
 463                 return false;
 464
 465         /* we need a few samples before looking at them */
 466         if (m->packet_count < 4)
 467                 return false;
 468
 469         /* do not accept anything worse than the maximum possible error of the best sample */
 470         if (fabs(offset) > m->samples[idx_min].delay)
 471                 return true;
 472
 473         /* compare the difference between the current offset to the previous offset and jitter */
 474         return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
 475 }
 476
 477 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
 478         assert(m);
 479
 480         if (m->poll_resync) {
 481                 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 482                 m->poll_resync = false;
 483                 return;
 484         }
 485
 486         /* set to minimal poll interval */
 487         if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
 488                 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 489                 return;
 490         }
 491
 492         /* increase polling interval */
 493         if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
 494                 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 495                         m->poll_interval_usec *= 2;
 496                 return;
 497         }
 498
 499         /* decrease polling interval */
 500         if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
 501                 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
 502                         m->poll_interval_usec /= 2;
 503                 return;
 504         }
 505 }
 506
 507 static bool sockaddr_equal(union sockaddr_union *a, union sockaddr_union *b) {
 508         assert(a);
 509         assert(b);
 510
 511         if (a->sa.sa_family != b->sa.sa_family)
 512                 return false;
 513
 514         if (a->sa.sa_family == AF_INET)
 515                 return a->in.sin_addr.s_addr == b->in.sin_addr.s_addr;
 516
 517         if (a->sa.sa_family == AF_INET6)
 518                 return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr)) == 0;
 519
 520         return false;
 521 }
 522
 523 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 524         _cleanup_free_ char *pretty = NULL;
 525         Manager *m = userdata;
 526         struct ntp_msg ntpmsg;
 527
 528         struct iovec iov = {
 529                 .iov_base = &ntpmsg,
 530                 .iov_len = sizeof(ntpmsg),
 531         };
 532         union {
 533                 struct cmsghdr cmsghdr;
 534                 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
 535         } control;
 536         union sockaddr_union server_addr;
 537         struct msghdr msghdr = {
 538                 .msg_iov = &iov,
 539                 .msg_iovlen = 1,
 540                 .msg_control = &control,
 541                 .msg_controllen = sizeof(control),
 542                 .msg_name = &server_addr,
 543                 .msg_namelen = sizeof(server_addr),
 544         };
 545         struct cmsghdr *cmsg;
 546         struct timespec now_ts;
 547         struct timeval *recv_time;
 548         ssize_t len;
 549         double origin, receive, trans, dest;
 550         double delay, offset;
 551         bool spike;
 552         int leap_sec;
 553         int r;
 554
 555         assert(source);
 556         assert(m);
 557
 558         if (revents & (EPOLLHUP|EPOLLERR)) {
 559                 log_warning("Server connection returned error.");
 560                 return manager_connect(m);
 561         }
 562
 563         len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
 564         if (len < 0) {
 565                 if (errno == EAGAIN)
 566                         return 0;
 567
 568                 log_warning("Error receiving message. Disconnecting.");
 569                 return manager_connect(m);
 570         }
 571
 572         if (iov.iov_len < sizeof(struct ntp_msg)) {
 573                 log_warning("Invalid response from server. Disconnecting.");
 574                 return manager_connect(m);
 575         }
 576
 577         if (!m->current_server_name ||
 578             !m->current_server_address ||
 579             !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
 580                 log_debug("Response from unknown server.");
 581                 return 0;
 582         }
 583
 584         recv_time = NULL;
 585         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
 586                 if (cmsg->cmsg_level != SOL_SOCKET)
 587                         continue;
 588
 589                 switch (cmsg->cmsg_type) {
 590                 case SCM_TIMESTAMP:
 591                         recv_time = (struct timeval *) CMSG_DATA(cmsg);
 592                         break;
 593                 }
 594         }
 595         if (!recv_time) {
 596                 log_error("Invalid packet timestamp.");
 597                 return -EINVAL;
 598         }
 599
 600         if (!m->pending) {
 601                 log_debug("Unexpected reply. Ignoring.");
 602                 return 0;
 603         }
 604
 605         /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
 606         if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
 607             be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
 608                 log_debug("Invalid reply; not our transmit time. Ignoring.");
 609                 return 0;
 610         }
 611
 612         if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC) {
 613                 log_debug("Server is not synchronized. Disconnecting.");
 614                 return manager_connect(m);
 615         }
 616
 617         if (NTP_FIELD_VERSION(ntpmsg.field) != 4 && NTP_FIELD_VERSION(ntpmsg.field) != 3) {
 618                 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
 619                 return manager_connect(m);
 620         }
 621
 622         if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
 623                 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
 624                 return manager_connect(m);
 625         }
 626
 627         /* valid packet */
 628         m->pending = false;
 629         m->retry_interval = 0;
 630
 631         /* announce leap seconds */
 632         if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
 633                 leap_sec = 1;
 634         else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
 635                 leap_sec = -1;
 636         else
 637                 leap_sec = 0;
 638
 639         /*
 640          * "Timestamp Name          ID   When Generated
 641          *  ------------------------------------------------------------
 642          *  Originate Timestamp     T1   time request sent by client
 643          *  Receive Timestamp       T2   time request received by server
 644          *  Transmit Timestamp      T3   time reply sent by server
 645          *  Destination Timestamp   T4   time reply received by client
 646          *
 647          *  The round-trip delay, d, and system clock offset, t, are defined as:
 648          *  d = (T4 - T1) - (T3 - T2)     t = ((T2 - T1) + (T3 - T4)) / 2"
 649          */
 650         assert_se(clock_gettime(CLOCK_MONOTONIC, &now_ts) >= 0);
 651         origin = tv_to_d(recv_time) - (ts_to_d(&now_ts) - ts_to_d(&m->trans_time_mon)) + OFFSET_1900_1970;
 652         receive = ntp_ts_to_d(&ntpmsg.recv_time);
 653         trans = ntp_ts_to_d(&ntpmsg.trans_time);
 654         dest = tv_to_d(recv_time) + OFFSET_1900_1970;
 655
 656         offset = ((receive - origin) + (trans - dest)) / 2;
 657         delay = (dest - origin) - (trans - receive);
 658
 659         spike = manager_sample_spike_detection(m, offset, delay);
 660
 661         manager_adjust_poll(m, offset, spike);
 662
 663         log_debug("NTP response:\n"
 664                   "  leap         : %u\n"
 665                   "  version      : %u\n"
 666                   "  mode         : %u\n"
 667                   "  stratum      : %u\n"
 668                   "  precision    : %.6f sec (%d)\n"
 669                   "  reference    : %.4s\n"
 670                   "  origin       : %.3f\n"
 671                   "  receive      : %.3f\n"
 672                   "  transmit     : %.3f\n"
 673                   "  dest         : %.3f\n"
 674                   "  offset       : %+.3f sec\n"
 675                   "  delay        : %+.3f sec\n"
 676                   "  packet count : %"PRIu64"\n"
 677                   "  jitter       : %.3f%s\n"
 678                   "  poll interval: %llu\n",
 679                   NTP_FIELD_LEAP(ntpmsg.field),
 680                   NTP_FIELD_VERSION(ntpmsg.field),
 681                   NTP_FIELD_MODE(ntpmsg.field),
 682                   ntpmsg.stratum,
 683                   exp2(ntpmsg.precision), ntpmsg.precision,
 684                   ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
 685                   origin - OFFSET_1900_1970,
 686                   receive - OFFSET_1900_1970,
 687                   trans - OFFSET_1900_1970,
 688                   dest - OFFSET_1900_1970,
 689                   offset, delay,
 690                   m->packet_count,
 691                   m->samples_jitter, spike ? " spike" : "",
 692                   m->poll_interval_usec / USEC_PER_SEC);
 693
 694         if (!spike) {
 695                 r = manager_adjust_clock(m, offset, leap_sec);
 696                 if (r < 0)
 697                         log_error("Failed to call clock_adjtime(): %m");
 698         }
 699
 700         r = sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
 701         if (r < 0) {
 702                 log_error("Failed to format socket address: %s", strerror(-r));
 703                 return r;
 704         }
 705
 706         log_info("%s (%s): interval/delta/delay/jitter/drift %llus/%+.3fs/%.3fs/%.3fs/%+ippm%s",
 707                  pretty, m->current_server_name->string, m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
 708                  spike ? " (ignored)" : "");
 709
 710         r = manager_arm_timer(m, m->poll_interval_usec);
 711         if (r < 0) {
 712                 log_error("Failed to rearm timer: %s", strerror(-r));
 713                 return r;
 714         }
 715
 716         return 0;
 717 }
 718
 719 static int manager_listen_setup(Manager *m) {
 720         union sockaddr_union addr = {};
 721         static const int tos = IPTOS_LOWDELAY;
 722         static const int on = 1;
 723         int r;
 724
 725         assert(m);
 726
 727         assert(m->server_socket < 0);
 728         assert(!m->event_receive);
 729         assert(m->current_server_address);
 730
 731         addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
 732
 733         m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 734         if (m->server_socket < 0)
 735                 return -errno;
 736
 737         r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
 738         if (r < 0)
 739                 return -errno;
 740
 741         r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on));
 742         if (r < 0)
 743                 return -errno;
 744
 745         setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
 746
 747         return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
 748 }
 749
 750 static int manager_begin(Manager *m) {
 751         _cleanup_free_ char *pretty = NULL;
 752         int r;
 753
 754         assert(m);
 755         assert_return(m->current_server_name, -EHOSTUNREACH);
 756         assert_return(m->current_server_address, -EHOSTUNREACH);
 757
 758         m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 759
 760         r = sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
 761         if (r < 0) {
 762                 log_warning("Failed to decode address of %s: %s", m->current_server_name->string, strerror(-r));
 763                 return r;
 764         }
 765
 766         log_debug("Connecting to NTP server %s (%s).", pretty, m->current_server_name->string);
 767         sd_notifyf(false, "STATUS=Using Time Server %s (%s)", pretty, m->current_server_name->string);
 768
 769         r = manager_listen_setup(m);
 770         if (r < 0) {
 771                 log_warning("Failed to setup connection socket: %s", strerror(-r));
 772                 return r;
 773         }
 774
 775         r = manager_clock_watch_setup(m);
 776         if (r < 0)
 777                 return r;
 778
 779         return manager_send_request(m);
 780 }
 781
 782 static void server_name_flush_addresses(ServerName *n) {
 783         ServerAddress *a;
 784
 785         assert(n);
 786
 787         while ((a = n->addresses)) {
 788                 LIST_REMOVE(addresses, n->addresses, a);
 789                 free(a);
 790         }
 791 }
 792
 793 static void manager_flush_names(Manager *m) {
 794         ServerName *n;
 795
 796         assert(m);
 797
 798         while ((n = m->servers)) {
 799                 LIST_REMOVE(names, m->servers, n);
 800                 free(n->string);
 801                 server_name_flush_addresses(n);
 802                 free(n);
 803         }
 804 }
 805
 806 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
 807         Manager *m = userdata;
 808         ServerAddress *a, *last = NULL;
 809
 810         assert(q);
 811         assert(m);
 812         assert(m->current_server_name);
 813
 814         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 815
 816         if (ret != 0) {
 817                 log_error("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
 818
 819                 /* Try next host */
 820                 return manager_connect(m);
 821         }
 822
 823         server_name_flush_addresses(m->current_server_name);
 824
 825         for (; ai; ai = ai->ai_next) {
 826                 _cleanup_free_ char *pretty = NULL;
 827
 828                 assert(ai->ai_addr);
 829                 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
 830                 assert(ai->ai_addrlen <= sizeof(union sockaddr_union));
 831
 832                 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
 833                         log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
 834                         continue;
 835                 }
 836
 837                 a = new0(ServerAddress, 1);
 838                 if (!a)
 839                         return log_oom();
 840
 841                 memcpy(&a->sockaddr, ai->ai_addr, ai->ai_addrlen);
 842                 a->socklen = ai->ai_addrlen;
 843
 844                 LIST_INSERT_AFTER(addresses, m->current_server_name->addresses, last, a);
 845                 last = a;
 846
 847                 sockaddr_pretty(&a->sockaddr.sa, a->socklen, true, &pretty);
 848                 log_debug("Found address %s for %s.", pretty, m->current_server_name->string);
 849         }
 850
 851         if (!m->current_server_name->addresses) {
 852                 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
 853
 854                 /* Try next host */
 855                 return manager_connect(m);
 856         }
 857
 858         m->current_server_address = m->current_server_name->addresses;
 859
 860         return manager_begin(m);
 861 }
 862
 863 static int manager_retry(sd_event_source *source, usec_t usec, void *userdata) {
 864         Manager *m = userdata;
 865
 866         assert(m);
 867
 868         return manager_connect(m);
 869 }
 870
 871 static int manager_connect(Manager *m) {
 872
 873         struct addrinfo hints = {
 874                 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
 875                 .ai_socktype = SOCK_DGRAM,
 876         };
 877         int r;
 878
 879         assert(m);
 880
 881         manager_disconnect(m);
 882
 883         m->event_retry = sd_event_source_unref(m->event_retry);
 884         if (!ratelimit_test(&m->ratelimit)) {
 885                 log_debug("Slowing down attempts to contact servers.");
 886
 887                 r = sd_event_add_time(m->event, &m->event_retry, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + RETRY_USEC, 0, manager_retry, m);
 888                 if (r < 0) {
 889                         log_error("Failed to create retry timer: %s", strerror(-r));
 890                         return r;
 891                 }
 892
 893                 return 0;
 894         }
 895
 896         /* If we already are operating on some address, switch to the
 897          * next one. */
 898         if (m->current_server_address && m->current_server_address->addresses_next)
 899                 m->current_server_address = m->current_server_address->addresses_next;
 900         else {
 901                 /* Hmm, we are through all addresses, let's look for the next host instead */
 902                 m->current_server_address = NULL;
 903
 904                 if (m->current_server_name && m->current_server_name->names_next)
 905                         m->current_server_name = m->current_server_name->names_next;
 906                 else {
 907                         if (!m->servers) {
 908                                 m->current_server_name = NULL;
 909                                 log_debug("No server found.");
 910                                 return 0;
 911                         }
 912
 913                         m->current_server_name = m->servers;
 914                 }
 915
 916                 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
 917                 if (r < 0) {
 918                         log_error("Failed to create resolver: %s", strerror(-r));
 919                         return r;
 920                 }
 921
 922                 return 1;
 923         }
 924
 925         r = manager_begin(m);
 926         if (r < 0)
 927                 return r;
 928
 929         return 1;
 930 }
 931
 932 static int manager_add_server(Manager *m, const char *server) {
 933         ServerName *n;
 934
 935         assert(m);
 936         assert(server);
 937
 938         n = new0(ServerName, 1);
 939         if (!n)
 940                 return -ENOMEM;
 941
 942         n->string = strdup(server);
 943         if (!n->string) {
 944                 free(n);
 945                 return -ENOMEM;
 946         }
 947
 948         LIST_PREPEND(names, m->servers, n);
 949         return 0;
 950 }
 951
 952 static void manager_disconnect(Manager *m) {
 953         assert(m);
 954
 955         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 956
 957         m->event_timer = sd_event_source_unref(m->event_timer);
 958
 959         m->event_receive = sd_event_source_unref(m->event_receive);
 960         m->server_socket = safe_close(m->server_socket);
 961
 962         m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
 963         m->clock_watch_fd = safe_close(m->clock_watch_fd);
 964 }
 965
 966 static int manager_new(Manager **ret) {
 967         _cleanup_manager_free_ Manager *m = NULL;
 968         int r;
 969
 970         m = new0(Manager, 1);
 971         if (!m)
 972                 return -ENOMEM;
 973
 974         m->server_socket = m->clock_watch_fd = -1;
 975
 976         RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
 977
 978         r = sd_event_default(&m->event);
 979         if (r < 0)
 980                 return r;
 981
 982         sd_event_add_signal(m->event, &m->sigterm, SIGTERM, NULL,  NULL);
 983         sd_event_add_signal(m->event, &m->sigint, SIGINT, NULL, NULL);
 984
 985         r = sd_resolve_default(&m->resolve);
 986         if (r < 0)
 987                 return r;
 988
 989         r = sd_resolve_attach_event(m->resolve, m->event, 0);
 990         if (r < 0)
 991                 return 0;
 992
 993         r = manager_clock_watch_setup(m);
 994         if (r < 0)
 995                 return r;
 996
 997         *ret = m;
 998         m = NULL;
 999
1000         return 0;
1001 }
1002
1003 static void manager_free(Manager *m) {
1004         if (!m)
1005                 return;
1006
1007         manager_disconnect(m);
1008         manager_flush_names(m);
1009
1010         sd_event_source_unref(m->sigint);
1011         sd_event_source_unref(m->sigterm);
1012
1013         sd_event_source_unref(m->event_retry);
1014
1015         sd_resolve_unref(m->resolve);
1016         sd_event_unref(m->event);
1017
1018         free(m);
1019 }
1020
1021 int main(int argc, char *argv[]) {
1022         _cleanup_manager_free_ Manager *m = NULL;
1023         const char *x;
1024         int r;
1025
1026         log_set_target(LOG_TARGET_AUTO);
1027         log_parse_environment();
1028         log_open();
1029
1030         assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
1031
1032         r = manager_new(&m);
1033         if (r < 0) {
1034                 log_error("Failed to allocate manager: %s", strerror(-r));
1035                 goto out;
1036         }
1037
1038         sd_notify(false, "READY=1");
1039
1040         FOREACH_STRING(x, "time1.google.com", "time2.google.com", "time3.google.com", "time4.google.com", "0.fedora.pool.ntp.org") {
1041                 r = manager_add_server(m, x);
1042                 if (r < 0) {
1043                         log_error("Failed to add server %s: %s", x, strerror(-r));
1044                         goto out;
1045                 }
1046         }
1047
1048         r = manager_connect(m);
1049         if (r < 0)
1050                 goto out;
1051
1052         r = sd_event_loop(m->event);
1053         if (r < 0) {
1054                 log_error("Failed to run event loop: %s", strerror(-r));
1055                 goto out;
1056         }
1057
1058         sd_event_get_exit_code(m->event, &r);
1059
1060 out:
1061         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1062 }