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         (void) setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
 724
 725         return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
 726 }
 727
 728 static int manager_begin(Manager *m) {
 729         _cleanup_free_ char *pretty = NULL;
 730         int r;
 731
 732         assert(m);
 733         assert_return(m->current_server_name, -EHOSTUNREACH);
 734         assert_return(m->current_server_address, -EHOSTUNREACH);
 735
 736         m->missed_replies = NTP_MAX_MISSED_REPLIES;
 737         if (m->poll_interval_usec == 0)
 738                 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 739
 740         server_address_pretty(m->current_server_address, &pretty);
 741         log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
 742         sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
 743
 744         r = manager_listen_setup(m);
 745         if (r < 0) {
 746                 log_warning("Failed to setup connection socket: %s", strerror(-r));
 747                 return r;
 748         }
 749
 750         r = manager_clock_watch_setup(m);
 751         if (r < 0)
 752                 return r;
 753
 754         return manager_send_request(m);
 755 }
 756
 757 void manager_set_server_name(Manager *m, ServerName *n) {
 758         assert(m);
 759
 760         if (m->current_server_name == n)
 761                 return;
 762
 763         m->current_server_name = n;
 764         m->current_server_address = NULL;
 765
 766         manager_disconnect(m);
 767
 768         if (n)
 769                 log_debug("Selected server %s.", n->string);
 770 }
 771
 772 void manager_set_server_address(Manager *m, ServerAddress *a) {
 773         assert(m);
 774
 775         if (m->current_server_address == a)
 776                 return;
 777
 778         m->current_server_address = a;
 779         /* If a is NULL, we are just clearing the address, without
 780          * changing the name. Keep the existing name in that case. */
 781         if (a)
 782                 m->current_server_name = a->name;
 783
 784         manager_disconnect(m);
 785
 786         if (a) {
 787                 _cleanup_free_ char *pretty = NULL;
 788                 server_address_pretty(a, &pretty);
 789                 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
 790         }
 791 }
 792
 793 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
 794         Manager *m = userdata;
 795         int r;
 796
 797         assert(q);
 798         assert(m);
 799         assert(m->current_server_name);
 800
 801         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 802
 803         if (ret != 0) {
 804                 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
 805
 806                 /* Try next host */
 807                 return manager_connect(m);
 808         }
 809
 810         for (; ai; ai = ai->ai_next) {
 811                 _cleanup_free_ char *pretty = NULL;
 812                 ServerAddress *a;
 813
 814                 assert(ai->ai_addr);
 815                 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
 816
 817                 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
 818                         log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
 819                         continue;
 820                 }
 821
 822                 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
 823                 if (r < 0) {
 824                         log_error("Failed to add server address: %s", strerror(-r));
 825                         return r;
 826                 }
 827
 828                 server_address_pretty(a, &pretty);
 829                 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
 830         }
 831
 832         if (!m->current_server_name->addresses) {
 833                 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
 834
 835                 /* Try next host */
 836                 return manager_connect(m);
 837         }
 838
 839         manager_set_server_address(m, m->current_server_name->addresses);
 840
 841         return manager_begin(m);
 842 }
 843
 844 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
 845         Manager *m = userdata;
 846
 847         assert(m);
 848
 849         return manager_connect(m);
 850 }
 851
 852 int manager_connect(Manager *m) {
 853         int r;
 854
 855         assert(m);
 856
 857         manager_disconnect(m);
 858
 859         m->event_retry = sd_event_source_unref(m->event_retry);
 860         if (!ratelimit_test(&m->ratelimit)) {
 861                 log_debug("Slowing down attempts to contact servers.");
 862
 863                 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);
 864                 if (r < 0) {
 865                         log_error("Failed to create retry timer: %s", strerror(-r));
 866                         return r;
 867                 }
 868
 869                 return 0;
 870         }
 871
 872         /* If we already are operating on some address, switch to the
 873          * next one. */
 874         if (m->current_server_address && m->current_server_address->addresses_next)
 875                 manager_set_server_address(m, m->current_server_address->addresses_next);
 876         else {
 877                 struct addrinfo hints = {
 878                         .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
 879                         .ai_socktype = SOCK_DGRAM,
 880                 };
 881
 882                 /* Hmm, we are through all addresses, let's look for the next host instead */
 883                 if (m->current_server_name && m->current_server_name->names_next)
 884                         manager_set_server_name(m, m->current_server_name->names_next);
 885                 else {
 886                         ServerName *f;
 887                         bool restart = true;
 888
 889                         /* Our current server name list is exhausted,
 890                          * let's find the next one to iterate. First
 891                          * we try the system list, then the link list.
 892                          * After having processed the link list we
 893                          * jump back to the system list. However, if
 894                          * both lists are empty, we change to the
 895                          * fallback list. */
 896                         if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
 897                                 f = m->system_servers;
 898                                 if (!f)
 899                                         f = m->link_servers;
 900                         } else {
 901                                 f = m->link_servers;
 902                                 if (!f)
 903                                         f = m->system_servers;
 904                                 else
 905                                         restart = false;
 906                         }
 907
 908                         if (!f)
 909                                 f = m->fallback_servers;
 910
 911                         if (!f) {
 912                                 manager_set_server_name(m, NULL);
 913                                 log_debug("No server found.");
 914                                 return 0;
 915                         }
 916
 917                         if (restart && !m->exhausted_servers && m->poll_interval_usec) {
 918                                 log_debug("Waiting after exhausting servers.");
 919                                 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);
 920                                 if (r < 0) {
 921                                         log_error("Failed to create retry timer: %s", strerror(-r));
 922                                         return r;
 923                                 }
 924
 925                                 m->exhausted_servers = true;
 926
 927                                 /* Increase the polling interval */
 928                                 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 929                                         m->poll_interval_usec *= 2;
 930
 931                                 return 0;
 932                         }
 933
 934                         m->exhausted_servers = false;
 935
 936                         manager_set_server_name(m, f);
 937                 }
 938
 939                 /* Tell the resolver to reread /etc/resolv.conf, in
 940                  * case it changed. */
 941                 res_init();
 942
 943                 /* Flush out any previously resolved addresses */
 944                 server_name_flush_addresses(m->current_server_name);
 945
 946                 log_debug("Resolving %s...", m->current_server_name->string);
 947
 948                 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
 949                 if (r < 0) {
 950                         log_error("Failed to create resolver: %s", strerror(-r));
 951                         return r;
 952                 }
 953
 954                 return 1;
 955         }
 956
 957         r = manager_begin(m);
 958         if (r < 0)
 959                 return r;
 960
 961         return 1;
 962 }
 963
 964 void manager_disconnect(Manager *m) {
 965         assert(m);
 966
 967         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 968
 969         m->event_timer = sd_event_source_unref(m->event_timer);
 970
 971         m->event_receive = sd_event_source_unref(m->event_receive);
 972         m->server_socket = safe_close(m->server_socket);
 973
 974         m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
 975         m->clock_watch_fd = safe_close(m->clock_watch_fd);
 976
 977         m->event_timeout = sd_event_source_unref(m->event_timeout);
 978
 979         sd_notifyf(false, "STATUS=Idle.");
 980 }
 981
 982 void manager_flush_server_names(Manager  *m, ServerType t) {
 983         assert(m);
 984
 985         if (t == SERVER_SYSTEM)
 986                 while (m->system_servers)
 987                         server_name_free(m->system_servers);
 988
 989         if (t == SERVER_LINK)
 990                 while (m->link_servers)
 991                         server_name_free(m->link_servers);
 992
 993         if (t == SERVER_FALLBACK)
 994                 while (m->fallback_servers)
 995                         server_name_free(m->fallback_servers);
 996 }
 997
 998 void manager_free(Manager *m) {
 999         if (!m)
1000                 return;
1001
1002         manager_disconnect(m);
1003         manager_flush_server_names(m, SERVER_SYSTEM);
1004         manager_flush_server_names(m, SERVER_LINK);
1005         manager_flush_server_names(m, SERVER_FALLBACK);
1006
1007         sd_event_source_unref(m->event_retry);
1008
1009         sd_event_source_unref(m->network_event_source);
1010         sd_network_monitor_unref(m->network_monitor);
1011
1012         sd_resolve_unref(m->resolve);
1013         sd_event_unref(m->event);
1014
1015         free(m);
1016 }
1017
1018 static int manager_network_read_link_servers(Manager *m) {
1019         _cleanup_strv_free_ char **ntp = NULL;
1020         ServerName *n, *nx;
1021         char **i;
1022         int r;
1023
1024         assert(m);
1025
1026         r = sd_network_get_ntp(&ntp);
1027         if (r < 0)
1028                 goto clear;
1029
1030         LIST_FOREACH(names, n, m->link_servers)
1031                 n->marked = true;
1032
1033         STRV_FOREACH(i, ntp) {
1034                 bool found = false;
1035
1036                 LIST_FOREACH(names, n, m->link_servers)
1037                         if (streq(n->string, *i)) {
1038                                 n->marked = false;
1039                                 found = true;
1040                                 break;
1041                         }
1042
1043                 if (!found) {
1044                         r = server_name_new(m, NULL, SERVER_LINK, *i);
1045                         if (r < 0)
1046                                 goto clear;
1047                 }
1048         }
1049
1050         LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1051                 if (n->marked)
1052                         server_name_free(n);
1053
1054         return 0;
1055
1056 clear:
1057         manager_flush_server_names(m, SERVER_LINK);
1058         return r;
1059 }
1060
1061 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1062         Manager *m = userdata;
1063         bool connected, online;
1064         int r;
1065
1066         assert(m);
1067
1068         sd_network_monitor_flush(m->network_monitor);
1069
1070         manager_network_read_link_servers(m);
1071
1072         /* check if the machine is online */
1073         online = network_is_online();
1074
1075         /* check if the client is currently connected */
1076         connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1077
1078         if (connected && !online) {
1079                 log_info("No network connectivity, watching for changes.");
1080                 manager_disconnect(m);
1081
1082         } else if (!connected && online) {
1083                 log_info("Network configuration changed, trying to establish connection.");
1084
1085                 if (m->current_server_address)
1086                         r = manager_begin(m);
1087                 else
1088                         r = manager_connect(m);
1089                 if (r < 0)
1090                         return r;
1091         }
1092
1093         return 0;
1094 }
1095
1096 static int manager_network_monitor_listen(Manager *m) {
1097         int r, fd, events;
1098
1099         assert(m);
1100
1101         r = sd_network_monitor_new(&m->network_monitor, NULL);
1102         if (r < 0)
1103                 return r;
1104
1105         fd = sd_network_monitor_get_fd(m->network_monitor);
1106         if (fd < 0)
1107                 return fd;
1108
1109         events = sd_network_monitor_get_events(m->network_monitor);
1110         if (events < 0)
1111                 return events;
1112
1113         r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1114         if (r < 0)
1115                 return r;
1116
1117         return 0;
1118 }
1119
1120 int manager_new(Manager **ret) {
1121         _cleanup_(manager_freep) Manager *m = NULL;
1122         int r;
1123
1124         assert(ret);
1125
1126         m = new0(Manager, 1);
1127         if (!m)
1128                 return -ENOMEM;
1129
1130         m->server_socket = m->clock_watch_fd = -1;
1131
1132         RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1133
1134         r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1135         if (r < 0)
1136                 return r;
1137
1138         r = sd_event_default(&m->event);
1139         if (r < 0)
1140                 return r;
1141
1142         sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
1143         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1144
1145         sd_event_set_watchdog(m->event, true);
1146
1147         r = sd_resolve_default(&m->resolve);
1148         if (r < 0)
1149                 return r;
1150
1151         r = sd_resolve_attach_event(m->resolve, m->event, 0);
1152         if (r < 0)
1153                 return r;
1154
1155         r = manager_network_monitor_listen(m);
1156         if (r < 0)
1157                 return r;
1158
1159         manager_network_read_link_servers(m);
1160
1161         *ret = m;
1162         m = NULL;
1163
1164         return 0;
1165 }