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