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