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