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