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