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