src/timesync/timesyncd.c

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