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         _cleanup_free_ char *pretty = NULL;
 487         Manager *m = userdata;
 488         struct ntp_msg ntpmsg;
 489
 490         struct iovec iov = {
 491                 .iov_base = &ntpmsg,
 492                 .iov_len = sizeof(ntpmsg),
 493         };
 494         union {
 495                 struct cmsghdr cmsghdr;
 496                 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
 497         } control;
 498         union sockaddr_union server_addr;
 499         struct msghdr msghdr = {
 500                 .msg_iov = &iov,
 501                 .msg_iovlen = 1,
 502                 .msg_control = &control,
 503                 .msg_controllen = sizeof(control),
 504                 .msg_name = &server_addr,
 505                 .msg_namelen = sizeof(server_addr),
 506         };
 507         struct cmsghdr *cmsg;
 508         struct timespec now_ts;
 509         struct timeval *recv_time;
 510         ssize_t len;
 511         double origin, receive, trans, dest;
 512         double delay, offset;
 513         bool spike;
 514         int leap_sec;
 515         int r;
 516
 517         assert(source);
 518         assert(m);
 519
 520         if (revents & (EPOLLHUP|EPOLLERR)) {
 521                 log_warning("Server connection returned error.");
 522                 return manager_connect(m);
 523         }
 524
 525         len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
 526         if (len < 0) {
 527                 if (errno == EAGAIN)
 528                         return 0;
 529
 530                 log_warning("Error receiving message. Disconnecting.");
 531                 return manager_connect(m);
 532         }
 533
 534         if (iov.iov_len < sizeof(struct ntp_msg)) {
 535                 log_warning("Invalid response from server. Disconnecting.");
 536                 return manager_connect(m);
 537         }
 538
 539         if (!m->current_server_name ||
 540             !m->current_server_address ||
 541             !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
 542                 log_debug("Response from unknown server.");
 543                 return 0;
 544         }
 545
 546         recv_time = NULL;
 547         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
 548                 if (cmsg->cmsg_level != SOL_SOCKET)
 549                         continue;
 550
 551                 switch (cmsg->cmsg_type) {
 552                 case SCM_TIMESTAMP:
 553                         recv_time = (struct timeval *) CMSG_DATA(cmsg);
 554                         break;
 555                 }
 556         }
 557         if (!recv_time) {
 558                 log_error("Invalid packet timestamp.");
 559                 return -EINVAL;
 560         }
 561
 562         if (!m->pending) {
 563                 log_debug("Unexpected reply. Ignoring.");
 564                 return 0;
 565         }
 566
 567         /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
 568         if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
 569             be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
 570                 log_debug("Invalid reply; not our transmit time. Ignoring.");
 571                 return 0;
 572         }
 573
 574         m->event_timeout = sd_event_source_unref(m->event_timeout);
 575
 576         if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
 577             be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
 578                 log_debug("Invalid reply, returned times before epoch. Ignoring.");
 579                 return manager_connect(m);
 580         }
 581
 582         if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC) {
 583                 log_debug("Server is not synchronized. Disconnecting.");
 584                 return manager_connect(m);
 585         }
 586
 587         if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
 588                 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
 589                 return manager_connect(m);
 590         }
 591
 592         if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
 593                 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
 594                 return manager_connect(m);
 595         }
 596
 597         /* valid packet */
 598         m->pending = false;
 599         m->retry_interval = 0;
 600
 601         /* announce leap seconds */
 602         if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
 603                 leap_sec = 1;
 604         else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
 605                 leap_sec = -1;
 606         else
 607                 leap_sec = 0;
 608
 609         /*
 610          * "Timestamp Name          ID   When Generated
 611          *  ------------------------------------------------------------
 612          *  Originate Timestamp     T1   time request sent by client
 613          *  Receive Timestamp       T2   time request received by server
 614          *  Transmit Timestamp      T3   time reply sent by server
 615          *  Destination Timestamp   T4   time reply received by client
 616          *
 617          *  The round-trip delay, d, and system clock offset, t, are defined as:
 618          *  d = (T4 - T1) - (T3 - T2)     t = ((T2 - T1) + (T3 - T4)) / 2"
 619          */
 620         assert_se(clock_gettime(CLOCK_MONOTONIC, &now_ts) >= 0);
 621         origin = tv_to_d(recv_time) - (ts_to_d(&now_ts) - ts_to_d(&m->trans_time_mon)) + OFFSET_1900_1970;
 622         receive = ntp_ts_to_d(&ntpmsg.recv_time);
 623         trans = ntp_ts_to_d(&ntpmsg.trans_time);
 624         dest = tv_to_d(recv_time) + OFFSET_1900_1970;
 625
 626         offset = ((receive - origin) + (trans - dest)) / 2;
 627         delay = (dest - origin) - (trans - receive);
 628
 629         spike = manager_sample_spike_detection(m, offset, delay);
 630
 631         manager_adjust_poll(m, offset, spike);
 632
 633         log_debug("NTP response:\n"
 634                   "  leap         : %u\n"
 635                   "  version      : %u\n"
 636                   "  mode         : %u\n"
 637                   "  stratum      : %u\n"
 638                   "  precision    : %.6f sec (%d)\n"
 639                   "  reference    : %.4s\n"
 640                   "  origin       : %.3f\n"
 641                   "  receive      : %.3f\n"
 642                   "  transmit     : %.3f\n"
 643                   "  dest         : %.3f\n"
 644                   "  offset       : %+.3f sec\n"
 645                   "  delay        : %+.3f sec\n"
 646                   "  packet count : %"PRIu64"\n"
 647                   "  jitter       : %.3f%s\n"
 648                   "  poll interval: %llu\n",
 649                   NTP_FIELD_LEAP(ntpmsg.field),
 650                   NTP_FIELD_VERSION(ntpmsg.field),
 651                   NTP_FIELD_MODE(ntpmsg.field),
 652                   ntpmsg.stratum,
 653                   exp2(ntpmsg.precision), ntpmsg.precision,
 654                   ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
 655                   origin - OFFSET_1900_1970,
 656                   receive - OFFSET_1900_1970,
 657                   trans - OFFSET_1900_1970,
 658                   dest - OFFSET_1900_1970,
 659                   offset, delay,
 660                   m->packet_count,
 661                   m->samples_jitter, spike ? " spike" : "",
 662                   m->poll_interval_usec / USEC_PER_SEC);
 663
 664         if (!spike) {
 665                 r = manager_adjust_clock(m, offset, leap_sec);
 666                 if (r < 0)
 667                         log_error("Failed to call clock_adjtime(): %m");
 668         }
 669
 670         sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
 671         log_info("%s (%s): interval/delta/delay/jitter/drift %llus/%+.3fs/%.3fs/%.3fs/%+ippm%s",
 672                  strna(pretty), m->current_server_name->string, m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
 673                  spike ? " (ignored)" : "");
 674
 675         r = manager_arm_timer(m, m->poll_interval_usec);
 676         if (r < 0) {
 677                 log_error("Failed to rearm timer: %s", strerror(-r));
 678                 return r;
 679         }
 680
 681         return 0;
 682 }
 683
 684 static int manager_listen_setup(Manager *m) {
 685         union sockaddr_union addr = {};
 686         static const int tos = IPTOS_LOWDELAY;
 687         static const int on = 1;
 688         int r;
 689
 690         assert(m);
 691
 692         assert(m->server_socket < 0);
 693         assert(!m->event_receive);
 694         assert(m->current_server_address);
 695
 696         addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
 697
 698         m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 699         if (m->server_socket < 0)
 700                 return -errno;
 701
 702         r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
 703         if (r < 0)
 704                 return -errno;
 705
 706         r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on));
 707         if (r < 0)
 708                 return -errno;
 709
 710         setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
 711
 712         return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
 713 }
 714
 715 static int manager_begin(Manager *m) {
 716         _cleanup_free_ char *pretty = NULL;
 717         int r;
 718
 719         assert(m);
 720         assert_return(m->current_server_name, -EHOSTUNREACH);
 721         assert_return(m->current_server_address, -EHOSTUNREACH);
 722
 723         m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 724
 725         sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
 726         log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
 727         sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
 728
 729         r = manager_listen_setup(m);
 730         if (r < 0) {
 731                 log_warning("Failed to setup connection socket: %s", strerror(-r));
 732                 return r;
 733         }
 734
 735         r = manager_clock_watch_setup(m);
 736         if (r < 0)
 737                 return r;
 738
 739         return manager_send_request(m);
 740 }
 741
 742 static void server_name_flush_addresses(ServerName *n) {
 743         ServerAddress *a;
 744
 745         assert(n);
 746
 747         while ((a = n->addresses)) {
 748                 LIST_REMOVE(addresses, n->addresses, a);
 749                 free(a);
 750         }
 751 }
 752
 753 static void manager_flush_names(Manager *m) {
 754         ServerName *n;
 755
 756         assert(m);
 757
 758         while ((n = m->servers)) {
 759                 LIST_REMOVE(names, m->servers, n);
 760                 free(n->string);
 761                 server_name_flush_addresses(n);
 762                 free(n);
 763         }
 764 }
 765
 766 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
 767         Manager *m = userdata;
 768         ServerAddress *a, *last = NULL;
 769
 770         assert(q);
 771         assert(m);
 772         assert(m->current_server_name);
 773
 774         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 775
 776         if (ret != 0) {
 777                 log_error("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
 778
 779                 /* Try next host */
 780                 return manager_connect(m);
 781         }
 782
 783         server_name_flush_addresses(m->current_server_name);
 784
 785         for (; ai; ai = ai->ai_next) {
 786                 _cleanup_free_ char *pretty = NULL;
 787
 788                 assert(ai->ai_addr);
 789                 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
 790                 assert(ai->ai_addrlen <= sizeof(union sockaddr_union));
 791
 792                 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
 793                         log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
 794                         continue;
 795                 }
 796
 797                 a = new0(ServerAddress, 1);
 798                 if (!a)
 799                         return log_oom();
 800
 801                 memcpy(&a->sockaddr, ai->ai_addr, ai->ai_addrlen);
 802                 a->socklen = ai->ai_addrlen;
 803
 804                 LIST_INSERT_AFTER(addresses, m->current_server_name->addresses, last, a);
 805                 last = a;
 806
 807                 sockaddr_pretty(&a->sockaddr.sa, a->socklen, true, &pretty);
 808                 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
 809         }
 810
 811         if (!m->current_server_name->addresses) {
 812                 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
 813
 814                 /* Try next host */
 815                 return manager_connect(m);
 816         }
 817
 818         m->current_server_address = m->current_server_name->addresses;
 819
 820         return manager_begin(m);
 821 }
 822
 823 static int manager_retry(sd_event_source *source, usec_t usec, void *userdata) {
 824         Manager *m = userdata;
 825
 826         assert(m);
 827
 828         return manager_connect(m);
 829 }
 830
 831 static int manager_connect(Manager *m) {
 832
 833         struct addrinfo hints = {
 834                 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
 835                 .ai_socktype = SOCK_DGRAM,
 836         };
 837         int r;
 838
 839         assert(m);
 840
 841         manager_disconnect(m);
 842
 843         m->event_retry = sd_event_source_unref(m->event_retry);
 844         if (!ratelimit_test(&m->ratelimit)) {
 845                 log_debug("Slowing down attempts to contact servers.");
 846
 847                 r = sd_event_add_time(m->event, &m->event_retry, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + RETRY_USEC, 0, manager_retry, m);
 848                 if (r < 0) {
 849                         log_error("Failed to create retry timer: %s", strerror(-r));
 850                         return r;
 851                 }
 852
 853                 return 0;
 854         }
 855
 856         /* If we already are operating on some address, switch to the
 857          * next one. */
 858         if (m->current_server_address && m->current_server_address->addresses_next)
 859                 m->current_server_address = m->current_server_address->addresses_next;
 860         else {
 861                 /* Hmm, we are through all addresses, let's look for the next host instead */
 862                 m->current_server_address = NULL;
 863
 864                 if (m->current_server_name && m->current_server_name->names_next)
 865                         m->current_server_name = m->current_server_name->names_next;
 866                 else {
 867                         if (!m->servers) {
 868                                 m->current_server_name = NULL;
 869                                 log_debug("No server found.");
 870                                 return 0;
 871                         }
 872
 873                         m->current_server_name = m->servers;
 874                 }
 875
 876                 /* Tell the resolver to reread /etc/resolv.conf, in
 877                  * case it changed. */
 878                 res_init();
 879
 880                 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
 881                 if (r < 0) {
 882                         log_error("Failed to create resolver: %s", strerror(-r));
 883                         return r;
 884                 }
 885
 886                 return 1;
 887         }
 888
 889         r = manager_begin(m);
 890         if (r < 0)
 891                 return r;
 892
 893         return 1;
 894 }
 895
 896 static int manager_add_server(Manager *m, const char *server) {
 897         ServerName *n, *tail;
 898
 899         assert(m);
 900         assert(server);
 901
 902         n = new0(ServerName, 1);
 903         if (!n)
 904                 return -ENOMEM;
 905
 906         n->string = strdup(server);
 907         if (!n->string) {
 908                 free(n);
 909                 return -ENOMEM;
 910         }
 911
 912         LIST_FIND_TAIL(names, m->servers, tail);
 913         LIST_INSERT_AFTER(names, m->servers, tail, n);
 914
 915         return 0;
 916 }
 917
 918 static int manager_add_server_string(Manager *m, const char *string) {
 919         char *w, *state;
 920         size_t l;
 921         int r;
 922
 923         assert(m);
 924         assert(string);
 925
 926         FOREACH_WORD_QUOTED(w, l, string, state) {
 927                 char t[l+1];
 928
 929                 memcpy(t, w, l);
 930                 t[l] = 0;
 931
 932                 r = manager_add_server(m, t);
 933                 if (r < 0)
 934                         log_error("Failed to add server %s to configuration, ignoring: %s", t, strerror(-r));
 935         }
 936
 937         return 0;
 938 }
 939
 940 static void manager_disconnect(Manager *m) {
 941         assert(m);
 942
 943         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 944
 945         m->event_timer = sd_event_source_unref(m->event_timer);
 946
 947         m->event_receive = sd_event_source_unref(m->event_receive);
 948         m->server_socket = safe_close(m->server_socket);
 949
 950         m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
 951         m->clock_watch_fd = safe_close(m->clock_watch_fd);
 952
 953         m->event_timeout = sd_event_source_unref(m->event_timeout);
 954
 955         sd_notifyf(false, "STATUS=Idle.");
 956 }
 957
 958 static int manager_new(Manager **ret) {
 959         _cleanup_manager_free_ Manager *m = NULL;
 960         int r;
 961
 962         m = new0(Manager, 1);
 963         if (!m)
 964                 return -ENOMEM;
 965
 966         m->server_socket = m->clock_watch_fd = -1;
 967
 968         RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
 969
 970         r = sd_event_default(&m->event);
 971         if (r < 0)
 972                 return r;
 973
 974         sd_event_add_signal(m->event, &m->sigterm, SIGTERM, NULL,  NULL);
 975         sd_event_add_signal(m->event, &m->sigint, SIGINT, NULL, NULL);
 976
 977         r = sd_resolve_default(&m->resolve);
 978         if (r < 0)
 979                 return r;
 980
 981         r = sd_resolve_attach_event(m->resolve, m->event, 0);
 982         if (r < 0)
 983                 return 0;
 984
 985         r = manager_clock_watch_setup(m);
 986         if (r < 0)
 987                 return r;
 988
 989         *ret = m;
 990         m = NULL;
 991
 992         return 0;
 993 }
 994
 995 static void manager_free(Manager *m) {
 996         if (!m)
 997                 return;
 998
 999         manager_disconnect(m);
1000         manager_flush_names(m);
1001
1002         sd_event_source_unref(m->sigint);
1003         sd_event_source_unref(m->sigterm);
1004
1005         sd_event_source_unref(m->event_retry);
1006
1007         sd_resolve_unref(m->resolve);
1008         sd_event_unref(m->event);
1009
1010         free(m);
1011 }
1012
1013 int config_parse_servers(
1014                 const char *unit,
1015                 const char *filename,
1016                 unsigned line,
1017                 const char *section,
1018                 unsigned section_line,
1019                 const char *lvalue,
1020                 int ltype,
1021                 const char *rvalue,
1022                 void *data,
1023                 void *userdata) {
1024
1025         Manager *m = userdata;
1026
1027         assert(filename);
1028         assert(lvalue);
1029         assert(rvalue);
1030
1031         manager_flush_names(m);
1032         manager_add_server_string(m, rvalue);
1033
1034         return 0;
1035 }
1036
1037 static int manager_parse_config_file(Manager *m) {
1038         static const char fn[] = "/etc/systemd/timesyncd.conf";
1039         _cleanup_fclose_ FILE *f = NULL;
1040         int r;
1041
1042         assert(m);
1043
1044         f = fopen(fn, "re");
1045         if (!f) {
1046                 if (errno == ENOENT)
1047                         return 0;
1048
1049                 log_warning("Failed to open configuration file %s: %m", fn);
1050                 return -errno;
1051         }
1052
1053         r = config_parse(NULL, fn, f, "Time\0", config_item_perf_lookup,
1054                          (void*) timesyncd_gperf_lookup, false, false, m);
1055         if (r < 0)
1056                 log_warning("Failed to parse configuration file: %s", strerror(-r));
1057
1058         return r;
1059 }
1060
1061 int main(int argc, char *argv[]) {
1062         _cleanup_manager_free_ Manager *m = NULL;
1063         int r;
1064
1065         if (argc > 1) {
1066                 log_error("This program does not take arguments.");
1067                 return EXIT_FAILURE;
1068         }
1069
1070         log_set_target(LOG_TARGET_AUTO);
1071         log_set_facility(LOG_CRON);
1072         log_parse_environment();
1073         log_open();
1074
1075         umask(0022);
1076
1077         assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
1078
1079         r = manager_new(&m);
1080         if (r < 0) {
1081                 log_error("Failed to allocate manager: %s", strerror(-r));
1082                 goto out;
1083         }
1084
1085         manager_add_server_string(m, NTP_SERVERS);
1086         manager_parse_config_file(m);
1087
1088         log_debug("systemd-timesyncd running as pid %lu", (unsigned long) getpid());
1089         sd_notify(false, "READY=1");
1090
1091         r = manager_connect(m);
1092         if (r < 0)
1093                 goto out;
1094
1095         r = sd_event_loop(m->event);
1096         if (r < 0) {
1097                 log_error("Failed to run event loop: %s", strerror(-r));
1098                 goto out;
1099         }
1100
1101         sd_event_get_exit_code(m->event, &r);
1102
1103 out:
1104         sd_notify(false, "STATUS=Shutting down...");
1105
1106         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1107 }