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