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