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