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