src/timesync/timesyncd-manager.c

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