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