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