src/timesync/timesyncd.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-event.h"
  50 #include "sd-resolve.h"
  51 #include "sd-daemon.h"
  52 #include "sd-network.h"
  53 #include "event-util.h"
  54 #include "network-util.h"
  55 #include "clock-util.h"
  56 #include "capability.h"
  57 #include "mkdir.h"
  58 #include "timesyncd.h"
  59
  60 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
  61
  62 #ifndef ADJ_SETOFFSET
  63 #define ADJ_SETOFFSET                   0x0100  /* add 'time' to current time */
  64 #endif
  65
  66 /* expected accuracy of time synchronization; used to adjust the poll interval */
  67 #define NTP_ACCURACY_SEC                0.2
  68
  69 /*
  70  * "A client MUST NOT under any conditions use a poll interval less
  71  * than 15 seconds."
  72  */
  73 #define NTP_POLL_INTERVAL_MIN_SEC       32
  74 #define NTP_POLL_INTERVAL_MAX_SEC       2048
  75
  76 /*
  77  * Maximum delta in seconds which the system clock is gradually adjusted
  78  * (slew) to approach the network time. Deltas larger that this are set by
  79  * letting the system time jump. The kernel's limit for adjtime is 0.5s.
  80  */
  81 #define NTP_MAX_ADJUST                  0.4
  82
  83 /* NTP protocol, packet header */
  84 #define NTP_LEAP_PLUSSEC                1
  85 #define NTP_LEAP_MINUSSEC               2
  86 #define NTP_LEAP_NOTINSYNC              3
  87 #define NTP_MODE_CLIENT                 3
  88 #define NTP_MODE_SERVER                 4
  89 #define NTP_FIELD_LEAP(f)               (((f) >> 6) & 3)
  90 #define NTP_FIELD_VERSION(f)            (((f) >> 3) & 7)
  91 #define NTP_FIELD_MODE(f)               ((f) & 7)
  92 #define NTP_FIELD(l, v, m)              (((l) << 6) | ((v) << 3) | (m))
  93
  94 /*
  95  * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
  96  * in seconds relative to 0h on 1 January 1900."
  97  */
  98 #define OFFSET_1900_1970        2208988800UL
  99
 100 #define RETRY_USEC (30*USEC_PER_SEC)
 101 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
 102 #define RATELIMIT_BURST 10
 103
 104 #define TIMEOUT_USEC (10*USEC_PER_SEC)
 105
 106 struct ntp_ts {
 107         be32_t sec;
 108         be32_t frac;
 109 } _packed_;
 110
 111 struct ntp_ts_short {
 112         be16_t sec;
 113         be16_t frac;
 114 } _packed_;
 115
 116 struct ntp_msg {
 117         uint8_t field;
 118         uint8_t stratum;
 119         int8_t poll;
 120         int8_t precision;
 121         struct ntp_ts_short root_delay;
 122         struct ntp_ts_short root_dispersion;
 123         char refid[4];
 124         struct ntp_ts reference_time;
 125         struct ntp_ts origin_time;
 126         struct ntp_ts recv_time;
 127         struct ntp_ts trans_time;
 128 } _packed_;
 129
 130 static void manager_free(Manager *m);
 131 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
 132 #define _cleanup_manager_free_ _cleanup_(manager_freep)
 133
 134 static int manager_arm_timer(Manager *m, usec_t next);
 135 static int manager_clock_watch_setup(Manager *m);
 136 static int manager_connect(Manager *m);
 137 static void manager_disconnect(Manager *m);
 138
 139 static double ntp_ts_to_d(const struct ntp_ts *ts) {
 140         return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
 141 }
 142
 143 static double ts_to_d(const struct timespec *ts) {
 144         return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
 145 }
 146
 147 static double tv_to_d(const struct timeval *tv) {
 148         return tv->tv_sec + (1.0e-6 * tv->tv_usec);
 149 }
 150
 151 static double square(double d) {
 152         return d * d;
 153 }
 154
 155 static int load_clock_timestamp(uid_t uid, gid_t gid) {
 156         _cleanup_close_ int fd = -1;
 157         usec_t min = TIME_EPOCH * USEC_PER_SEC;
 158         usec_t ct;
 159         int r;
 160
 161         /* Let's try to make sure that the clock is always
 162          * monotonically increasing, by saving the clock whenever we
 163          * have a new NTP time, or when we shut down, and restoring it
 164          * when we start again. This is particularly helpful on
 165          * systems lacking a battery backed RTC. We also will adjust
 166          * the time to at least the build time of systemd. */
 167
 168         fd = open("/var/lib/systemd/clock", O_RDWR|O_CLOEXEC, 0644);
 169         if (fd >= 0) {
 170                 struct stat st;
 171                 usec_t stamp;
 172
 173                 /* check if the recorded time is later than the compiled-in one */
 174                 r = fstat(fd, &st);
 175                 if (r >= 0) {
 176                         stamp = timespec_load(&st.st_mtim);
 177                         if (stamp > min)
 178                                 min = stamp;
 179                 }
 180
 181                 /* Try to fix the access mode, so that we can still
 182                    touch the file after dropping priviliges */
 183                 fchmod(fd, 0644);
 184                 fchown(fd, uid, gid);
 185
 186         } else
 187                 /* create stamp file with the compiled-in date */
 188                 touch_file("/var/lib/systemd/clock", true, min, uid, gid, 0644);
 189
 190         ct = now(CLOCK_REALTIME);
 191         if (ct < min) {
 192                 struct timespec ts;
 193                 char date[FORMAT_TIMESTAMP_MAX];
 194
 195                 log_info("System clock time unset or jumped backwards, restoring from recorded timestamp: %s",
 196                          format_timestamp(date, sizeof(date), min));
 197
 198                 if (clock_settime(CLOCK_REALTIME, timespec_store(&ts, min)) < 0)
 199                         log_error("Failed to restore system clock: %m");
 200         }
 201
 202         return 0;
 203 }
 204
 205 static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
 206         _cleanup_free_ char *pretty = NULL;
 207         Manager *m = userdata;
 208
 209         assert(m);
 210         assert(m->current_server_name);
 211         assert(m->current_server_address);
 212
 213         sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
 214         log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
 215
 216         return manager_connect(m);
 217 }
 218
 219 static int manager_send_request(Manager *m) {
 220         _cleanup_free_ char *pretty = NULL;
 221         struct ntp_msg ntpmsg = {
 222                 /*
 223                  * "The client initializes the NTP message header, sends the request
 224                  * to the server, and strips the time of day from the Transmit
 225                  * Timestamp field of the reply.  For this purpose, all the NTP
 226                  * header fields are set to 0, except the Mode, VN, and optional
 227                  * Transmit Timestamp fields."
 228                  */
 229                 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
 230         };
 231         ssize_t len;
 232         int r;
 233
 234         assert(m);
 235         assert(m->current_server_name);
 236         assert(m->current_server_address);
 237
 238         m->event_timeout = sd_event_source_unref(m->event_timeout);
 239
 240         /*
 241          * Set transmit timestamp, remember it; the server will send that back
 242          * as the origin timestamp and we have an indication that this is the
 243          * matching answer to our request.
 244          *
 245          * The actual value does not matter, We do not care about the correct
 246          * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
 247          */
 248         assert_se(clock_gettime(CLOCK_MONOTONIC, &m->trans_time_mon) >= 0);
 249         assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
 250         ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
 251         ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
 252
 253         sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
 254
 255         len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
 256         if (len == sizeof(ntpmsg)) {
 257                 m->pending = true;
 258                 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
 259         } else {
 260                 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
 261                 return manager_connect(m);
 262         }
 263
 264         /* re-arm timer with increasing timeout, in case the packets never arrive back */
 265         if (m->retry_interval > 0) {
 266                 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 267                         m->retry_interval *= 2;
 268         } else
 269                 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 270
 271         r = manager_arm_timer(m, m->retry_interval);
 272         if (r < 0) {
 273                 log_error("Failed to rearm timer: %s", strerror(-r));
 274                 return r;
 275         }
 276
 277         r = sd_event_add_time(
 278                         m->event,
 279                         &m->event_timeout,
 280                         CLOCK_MONOTONIC,
 281                         now(CLOCK_MONOTONIC) + TIMEOUT_USEC, 0,
 282                         manager_timeout, m);
 283         if (r < 0) {
 284                 log_error("Failed to arm timeout timer: %s", strerror(-r));
 285                 return r;
 286         }
 287
 288         return 0;
 289 }
 290
 291 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
 292         Manager *m = userdata;
 293
 294         assert(m);
 295
 296         return manager_send_request(m);
 297 }
 298
 299 static int manager_arm_timer(Manager *m, usec_t next) {
 300         int r;
 301
 302         assert(m);
 303         assert(m->event_receive);
 304
 305         if (next == 0) {
 306                 m->event_timer = sd_event_source_unref(m->event_timer);
 307                 return 0;
 308         }
 309
 310         if (m->event_timer) {
 311                 r = sd_event_source_set_time(m->event_timer, now(CLOCK_MONOTONIC) + next);
 312                 if (r < 0)
 313                         return r;
 314
 315                 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
 316         }
 317
 318         return sd_event_add_time(
 319                         m->event,
 320                         &m->event_timer,
 321                         CLOCK_MONOTONIC,
 322                         now(CLOCK_MONOTONIC) + next, 0,
 323                         manager_timer, m);
 324 }
 325
 326 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 327         Manager *m = userdata;
 328
 329         assert(m);
 330
 331         /* rearm timer */
 332         manager_clock_watch_setup(m);
 333
 334         if (!m->current_server_address)
 335                 return 0;
 336
 337         /* skip our own jumps */
 338         if (m->jumped) {
 339                 m->jumped = false;
 340                 return 0;
 341         }
 342
 343         /* resync */
 344         log_info("System time changed. Resyncing.");
 345         m->poll_resync = true;
 346         return manager_send_request(m);
 347 }
 348
 349 /* wake up when the system time changes underneath us */
 350 static int manager_clock_watch_setup(Manager *m) {
 351
 352         struct itimerspec its = {
 353                 .it_value.tv_sec = TIME_T_MAX
 354         };
 355
 356         int r;
 357
 358         assert(m);
 359
 360         m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
 361         safe_close(m->clock_watch_fd);
 362
 363         m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
 364         if (m->clock_watch_fd < 0) {
 365                 log_error("Failed to create timerfd: %m");
 366                 return -errno;
 367         }
 368
 369         if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
 370                 log_error("Failed to set up timerfd: %m");
 371                 return -errno;
 372         }
 373
 374         r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
 375         if (r < 0) {
 376                 log_error("Failed to create clock watch event source: %s", strerror(-r));
 377                 return r;
 378         }
 379
 380         return 0;
 381 }
 382
 383 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
 384         struct timex tmx = {};
 385         int r;
 386
 387         assert(m);
 388
 389         /*
 390          * For small deltas, tell the kernel to gradually adjust the system
 391          * clock to the NTP time, larger deltas are just directly set.
 392          *
 393          * Clear STA_UNSYNC, it will enable the kernel's 11-minute mode, which
 394          * syncs the system time periodically to the hardware clock.
 395          */
 396         if (fabs(offset) < NTP_MAX_ADJUST) {
 397                 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
 398                 tmx.status = STA_PLL;
 399                 tmx.offset = offset * NSEC_PER_SEC;
 400                 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
 401                 tmx.maxerror = 0;
 402                 tmx.esterror = 0;
 403                 log_debug("  adjust (slew): %+.3f sec\n", offset);
 404         } else {
 405                 tmx.modes = ADJ_SETOFFSET | ADJ_NANO;
 406
 407                 /* ADJ_NANO uses nanoseconds in the microseconds field */
 408                 tmx.time.tv_sec = (long)offset;
 409                 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
 410
 411                 /* the kernel expects -0.3s as {-1, 7000.000.000} */
 412                 if (tmx.time.tv_usec < 0) {
 413                         tmx.time.tv_sec  -= 1;
 414                         tmx.time.tv_usec += NSEC_PER_SEC;
 415                 }
 416
 417                 m->jumped = true;
 418                 log_debug("  adjust (jump): %+.3f sec\n", offset);
 419         }
 420
 421         switch (leap_sec) {
 422         case 1:
 423                 tmx.status |= STA_INS;
 424                 break;
 425         case -1:
 426                 tmx.status |= STA_DEL;
 427                 break;
 428         }
 429
 430         r = clock_adjtime(CLOCK_REALTIME, &tmx);
 431         if (r < 0)
 432                 return r;
 433
 434         touch("/var/lib/systemd/clock");
 435
 436         m->drift_ppm = tmx.freq / 65536;
 437
 438         log_debug("  status       : %04i %s\n"
 439                   "  time now     : %li.%03llu\n"
 440                   "  constant     : %li\n"
 441                   "  offset       : %+.3f sec\n"
 442                   "  freq offset  : %+li (%i ppm)\n",
 443                   tmx.status, tmx.status & STA_UNSYNC ? "" : "sync",
 444                   tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
 445                   tmx.constant,
 446                   (double)tmx.offset / NSEC_PER_SEC,
 447                   tmx.freq, m->drift_ppm);
 448
 449         return 0;
 450 }
 451
 452 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
 453         unsigned int i, idx_cur, idx_new, idx_min;
 454         double jitter;
 455         double j;
 456
 457         assert(m);
 458
 459         m->packet_count++;
 460
 461         /* ignore initial sample */
 462         if (m->packet_count == 1)
 463                 return false;
 464
 465         /* store the current data in our samples array */
 466         idx_cur = m->samples_idx;
 467         idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
 468         m->samples_idx = idx_new;
 469         m->samples[idx_new].offset = offset;
 470         m->samples[idx_new].delay = delay;
 471
 472         /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
 473         jitter = m->samples_jitter;
 474         for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
 475                 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
 476                         idx_min = i;
 477
 478         j = 0;
 479         for (i = 0; i < ELEMENTSOF(m->samples); i++)
 480                 j += square(m->samples[i].offset - m->samples[idx_min].offset);
 481         m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
 482
 483         /* ignore samples when resyncing */
 484         if (m->poll_resync)
 485                 return false;
 486
 487         /* always accept offset if we are farther off than the round-trip delay */
 488         if (fabs(offset) > delay)
 489                 return false;
 490
 491         /* we need a few samples before looking at them */
 492         if (m->packet_count < 4)
 493                 return false;
 494
 495         /* do not accept anything worse than the maximum possible error of the best sample */
 496         if (fabs(offset) > m->samples[idx_min].delay)
 497                 return true;
 498
 499         /* compare the difference between the current offset to the previous offset and jitter */
 500         return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
 501 }
 502
 503 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
 504         assert(m);
 505
 506         if (m->poll_resync) {
 507                 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 508                 m->poll_resync = false;
 509                 return;
 510         }
 511
 512         /* set to minimal poll interval */
 513         if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
 514                 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 515                 return;
 516         }
 517
 518         /* increase polling interval */
 519         if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
 520                 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 521                         m->poll_interval_usec *= 2;
 522                 return;
 523         }
 524
 525         /* decrease polling interval */
 526         if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
 527                 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
 528                         m->poll_interval_usec /= 2;
 529                 return;
 530         }
 531 }
 532
 533 static bool sockaddr_equal(union sockaddr_union *a, union sockaddr_union *b) {
 534         assert(a);
 535         assert(b);
 536
 537         if (a->sa.sa_family != b->sa.sa_family)
 538                 return false;
 539
 540         if (a->sa.sa_family == AF_INET)
 541                 return a->in.sin_addr.s_addr == b->in.sin_addr.s_addr;
 542
 543         if (a->sa.sa_family == AF_INET6)
 544                 return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr)) == 0;
 545
 546         return false;
 547 }
 548
 549 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 550         Manager *m = userdata;
 551         struct ntp_msg ntpmsg;
 552
 553         struct iovec iov = {
 554                 .iov_base = &ntpmsg,
 555                 .iov_len = sizeof(ntpmsg),
 556         };
 557         union {
 558                 struct cmsghdr cmsghdr;
 559                 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
 560         } control;
 561         union sockaddr_union server_addr;
 562         struct msghdr msghdr = {
 563                 .msg_iov = &iov,
 564                 .msg_iovlen = 1,
 565                 .msg_control = &control,
 566                 .msg_controllen = sizeof(control),
 567                 .msg_name = &server_addr,
 568                 .msg_namelen = sizeof(server_addr),
 569         };
 570         struct cmsghdr *cmsg;
 571         struct timespec now_ts;
 572         struct timeval *recv_time;
 573         ssize_t len;
 574         double origin, receive, trans, dest;
 575         double delay, offset;
 576         bool spike;
 577         int leap_sec;
 578         int r;
 579
 580         assert(source);
 581         assert(m);
 582
 583         if (revents & (EPOLLHUP|EPOLLERR)) {
 584                 log_warning("Server connection returned error.");
 585                 return manager_connect(m);
 586         }
 587
 588         len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
 589         if (len < 0) {
 590                 if (errno == EAGAIN)
 591                         return 0;
 592
 593                 log_warning("Error receiving message. Disconnecting.");
 594                 return manager_connect(m);
 595         }
 596
 597         if (iov.iov_len < sizeof(struct ntp_msg)) {
 598                 log_warning("Invalid response from server. Disconnecting.");
 599                 return manager_connect(m);
 600         }
 601
 602         if (!m->current_server_name ||
 603             !m->current_server_address ||
 604             !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
 605                 log_debug("Response from unknown server.");
 606                 return 0;
 607         }
 608
 609         recv_time = NULL;
 610         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
 611                 if (cmsg->cmsg_level != SOL_SOCKET)
 612                         continue;
 613
 614                 switch (cmsg->cmsg_type) {
 615                 case SCM_TIMESTAMP:
 616                         recv_time = (struct timeval *) CMSG_DATA(cmsg);
 617                         break;
 618                 }
 619         }
 620         if (!recv_time) {
 621                 log_error("Invalid packet timestamp.");
 622                 return -EINVAL;
 623         }
 624
 625         if (!m->pending) {
 626                 log_debug("Unexpected reply. Ignoring.");
 627                 return 0;
 628         }
 629
 630         /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
 631         if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
 632             be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
 633                 log_debug("Invalid reply; not our transmit time. Ignoring.");
 634                 return 0;
 635         }
 636
 637         m->event_timeout = sd_event_source_unref(m->event_timeout);
 638
 639         if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
 640             be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
 641                 log_debug("Invalid reply, returned times before epoch. Ignoring.");
 642                 return manager_connect(m);
 643         }
 644
 645         if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC) {
 646                 log_debug("Server is not synchronized. Disconnecting.");
 647                 return manager_connect(m);
 648         }
 649
 650         if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
 651                 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
 652                 return manager_connect(m);
 653         }
 654
 655         if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
 656                 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
 657                 return manager_connect(m);
 658         }
 659
 660         /* valid packet */
 661         m->pending = false;
 662         m->retry_interval = 0;
 663
 664         /* announce leap seconds */
 665         if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
 666                 leap_sec = 1;
 667         else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
 668                 leap_sec = -1;
 669         else
 670                 leap_sec = 0;
 671
 672         /*
 673          * "Timestamp Name          ID   When Generated
 674          *  ------------------------------------------------------------
 675          *  Originate Timestamp     T1   time request sent by client
 676          *  Receive Timestamp       T2   time request received by server
 677          *  Transmit Timestamp      T3   time reply sent by server
 678          *  Destination Timestamp   T4   time reply received by client
 679          *
 680          *  The round-trip delay, d, and system clock offset, t, are defined as:
 681          *  d = (T4 - T1) - (T3 - T2)     t = ((T2 - T1) + (T3 - T4)) / 2"
 682          */
 683         assert_se(clock_gettime(CLOCK_MONOTONIC, &now_ts) >= 0);
 684         origin = tv_to_d(recv_time) - (ts_to_d(&now_ts) - ts_to_d(&m->trans_time_mon)) + OFFSET_1900_1970;
 685         receive = ntp_ts_to_d(&ntpmsg.recv_time);
 686         trans = ntp_ts_to_d(&ntpmsg.trans_time);
 687         dest = tv_to_d(recv_time) + OFFSET_1900_1970;
 688
 689         offset = ((receive - origin) + (trans - dest)) / 2;
 690         delay = (dest - origin) - (trans - receive);
 691
 692         spike = manager_sample_spike_detection(m, offset, delay);
 693
 694         manager_adjust_poll(m, offset, spike);
 695
 696         log_debug("NTP response:\n"
 697                   "  leap         : %u\n"
 698                   "  version      : %u\n"
 699                   "  mode         : %u\n"
 700                   "  stratum      : %u\n"
 701                   "  precision    : %.6f sec (%d)\n"
 702                   "  reference    : %.4s\n"
 703                   "  origin       : %.3f\n"
 704                   "  receive      : %.3f\n"
 705                   "  transmit     : %.3f\n"
 706                   "  dest         : %.3f\n"
 707                   "  offset       : %+.3f sec\n"
 708                   "  delay        : %+.3f sec\n"
 709                   "  packet count : %"PRIu64"\n"
 710                   "  jitter       : %.3f%s\n"
 711                   "  poll interval: " USEC_FMT "\n",
 712                   NTP_FIELD_LEAP(ntpmsg.field),
 713                   NTP_FIELD_VERSION(ntpmsg.field),
 714                   NTP_FIELD_MODE(ntpmsg.field),
 715                   ntpmsg.stratum,
 716                   exp2(ntpmsg.precision), ntpmsg.precision,
 717                   ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
 718                   origin - OFFSET_1900_1970,
 719                   receive - OFFSET_1900_1970,
 720                   trans - OFFSET_1900_1970,
 721                   dest - OFFSET_1900_1970,
 722                   offset, delay,
 723                   m->packet_count,
 724                   m->samples_jitter, spike ? " spike" : "",
 725                   m->poll_interval_usec / USEC_PER_SEC);
 726
 727         if (!spike) {
 728                 m->sync = true;
 729                 r = manager_adjust_clock(m, offset, leap_sec);
 730                 if (r < 0)
 731                         log_error("Failed to call clock_adjtime(): %m");
 732         }
 733
 734         log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
 735                  m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
 736                  spike ? " (ignored)" : "");
 737
 738         r = manager_arm_timer(m, m->poll_interval_usec);
 739         if (r < 0) {
 740                 log_error("Failed to rearm timer: %s", strerror(-r));
 741                 return r;
 742         }
 743
 744         return 0;
 745 }
 746
 747 static int manager_listen_setup(Manager *m) {
 748         union sockaddr_union addr = {};
 749         static const int tos = IPTOS_LOWDELAY;
 750         static const int on = 1;
 751         int r;
 752
 753         assert(m);
 754
 755         assert(m->server_socket < 0);
 756         assert(!m->event_receive);
 757         assert(m->current_server_address);
 758
 759         addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
 760
 761         m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 762         if (m->server_socket < 0)
 763                 return -errno;
 764
 765         r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
 766         if (r < 0)
 767                 return -errno;
 768
 769         r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on));
 770         if (r < 0)
 771                 return -errno;
 772
 773         setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
 774
 775         return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
 776 }
 777
 778 static int manager_begin(Manager *m) {
 779         _cleanup_free_ char *pretty = NULL;
 780         int r;
 781
 782         assert(m);
 783         assert_return(m->current_server_name, -EHOSTUNREACH);
 784         assert_return(m->current_server_address, -EHOSTUNREACH);
 785
 786         m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 787
 788         sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
 789         log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
 790         sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
 791
 792         r = manager_listen_setup(m);
 793         if (r < 0) {
 794                 log_warning("Failed to setup connection socket: %s", strerror(-r));
 795                 return r;
 796         }
 797
 798         r = manager_clock_watch_setup(m);
 799         if (r < 0)
 800                 return r;
 801
 802         return manager_send_request(m);
 803 }
 804
 805 static void server_name_flush_addresses(ServerName *n) {
 806         ServerAddress *a;
 807
 808         assert(n);
 809
 810         while ((a = n->addresses)) {
 811                 LIST_REMOVE(addresses, n->addresses, a);
 812                 free(a);
 813         }
 814 }
 815
 816 static void manager_flush_names(Manager *m) {
 817         ServerName *n;
 818
 819         assert(m);
 820
 821         while ((n = m->servers)) {
 822                 LIST_REMOVE(names, m->servers, n);
 823                 free(n->string);
 824                 server_name_flush_addresses(n);
 825                 free(n);
 826         }
 827 }
 828
 829 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
 830         Manager *m = userdata;
 831         ServerAddress *a, *last = NULL;
 832
 833         assert(q);
 834         assert(m);
 835         assert(m->current_server_name);
 836
 837         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 838
 839         if (ret != 0) {
 840                 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
 841
 842                 /* Try next host */
 843                 return manager_connect(m);
 844         }
 845
 846         server_name_flush_addresses(m->current_server_name);
 847
 848         for (; ai; ai = ai->ai_next) {
 849                 _cleanup_free_ char *pretty = NULL;
 850
 851                 assert(ai->ai_addr);
 852                 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
 853                 assert(ai->ai_addrlen <= sizeof(union sockaddr_union));
 854
 855                 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
 856                         log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
 857                         continue;
 858                 }
 859
 860                 a = new0(ServerAddress, 1);
 861                 if (!a)
 862                         return log_oom();
 863
 864                 memcpy(&a->sockaddr, ai->ai_addr, ai->ai_addrlen);
 865                 a->socklen = ai->ai_addrlen;
 866
 867                 LIST_INSERT_AFTER(addresses, m->current_server_name->addresses, last, a);
 868                 last = a;
 869
 870                 sockaddr_pretty(&a->sockaddr.sa, a->socklen, true, &pretty);
 871                 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
 872         }
 873
 874         if (!m->current_server_name->addresses) {
 875                 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
 876
 877                 /* Try next host */
 878                 return manager_connect(m);
 879         }
 880
 881         m->current_server_address = m->current_server_name->addresses;
 882
 883         return manager_begin(m);
 884 }
 885
 886 static int manager_retry(sd_event_source *source, usec_t usec, void *userdata) {
 887         Manager *m = userdata;
 888
 889         assert(m);
 890
 891         return manager_connect(m);
 892 }
 893
 894 static int manager_connect(Manager *m) {
 895
 896         struct addrinfo hints = {
 897                 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
 898                 .ai_socktype = SOCK_DGRAM,
 899         };
 900         int r;
 901
 902         assert(m);
 903
 904         manager_disconnect(m);
 905
 906         m->event_retry = sd_event_source_unref(m->event_retry);
 907         if (!ratelimit_test(&m->ratelimit)) {
 908                 log_debug("Slowing down attempts to contact servers.");
 909
 910                 r = sd_event_add_time(m->event, &m->event_retry, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + RETRY_USEC, 0, manager_retry, m);
 911                 if (r < 0) {
 912                         log_error("Failed to create retry timer: %s", strerror(-r));
 913                         return r;
 914                 }
 915
 916                 return 0;
 917         }
 918
 919         /* If we already are operating on some address, switch to the
 920          * next one. */
 921         if (m->current_server_address && m->current_server_address->addresses_next)
 922                 m->current_server_address = m->current_server_address->addresses_next;
 923         else {
 924                 /* Hmm, we are through all addresses, let's look for the next host instead */
 925                 m->current_server_address = NULL;
 926
 927                 if (m->current_server_name && m->current_server_name->names_next)
 928                         m->current_server_name = m->current_server_name->names_next;
 929                 else {
 930                         if (!m->servers) {
 931                                 m->current_server_name = NULL;
 932                                 log_debug("No server found.");
 933                                 return 0;
 934                         }
 935
 936                         m->current_server_name = m->servers;
 937                 }
 938
 939                 /* Tell the resolver to reread /etc/resolv.conf, in
 940                  * case it changed. */
 941                 res_init();
 942
 943                 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
 944                 if (r < 0) {
 945                         log_error("Failed to create resolver: %s", strerror(-r));
 946                         return r;
 947                 }
 948
 949                 return 1;
 950         }
 951
 952         r = manager_begin(m);
 953         if (r < 0)
 954                 return r;
 955
 956         return 1;
 957 }
 958
 959 static int manager_add_server(Manager *m, const char *server) {
 960         ServerName *n, *tail;
 961
 962         assert(m);
 963         assert(server);
 964
 965         n = new0(ServerName, 1);
 966         if (!n)
 967                 return -ENOMEM;
 968
 969         n->string = strdup(server);
 970         if (!n->string) {
 971                 free(n);
 972                 return -ENOMEM;
 973         }
 974
 975         LIST_FIND_TAIL(names, m->servers, tail);
 976         LIST_INSERT_AFTER(names, m->servers, tail, n);
 977
 978         return 0;
 979 }
 980
 981 static int manager_add_server_string(Manager *m, const char *string) {
 982         char *w, *state;
 983         size_t l;
 984         int r;
 985
 986         assert(m);
 987         assert(string);
 988
 989         FOREACH_WORD_QUOTED(w, l, string, state) {
 990                 char t[l+1];
 991
 992                 memcpy(t, w, l);
 993                 t[l] = 0;
 994
 995                 r = manager_add_server(m, t);
 996                 if (r < 0)
 997                         log_error("Failed to add server %s to configuration, ignoring: %s", t, strerror(-r));
 998         }
 999
1000         return 0;
1001 }
1002
1003 static void manager_disconnect(Manager *m) {
1004         assert(m);
1005
1006         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
1007
1008         m->event_timer = sd_event_source_unref(m->event_timer);
1009
1010         m->event_receive = sd_event_source_unref(m->event_receive);
1011         m->server_socket = safe_close(m->server_socket);
1012
1013         m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
1014         m->clock_watch_fd = safe_close(m->clock_watch_fd);
1015
1016         m->event_timeout = sd_event_source_unref(m->event_timeout);
1017
1018         sd_notifyf(false, "STATUS=Idle.");
1019 }
1020
1021 static int manager_new(Manager **ret) {
1022         _cleanup_manager_free_ Manager *m = NULL;
1023         int r;
1024
1025         assert(ret);
1026
1027         m = new0(Manager, 1);
1028         if (!m)
1029                 return -ENOMEM;
1030
1031         m->server_socket = m->clock_watch_fd = -1;
1032
1033         RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1034
1035         r = sd_event_default(&m->event);
1036         if (r < 0)
1037                 return r;
1038
1039         sd_event_set_watchdog(m->event, true);
1040
1041         sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
1042         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1043
1044         r = sd_resolve_default(&m->resolve);
1045         if (r < 0)
1046                 return r;
1047
1048         r = sd_resolve_attach_event(m->resolve, m->event, 0);
1049         if (r < 0)
1050                 return r;
1051
1052         r = manager_clock_watch_setup(m);
1053         if (r < 0)
1054                 return r;
1055
1056         *ret = m;
1057         m = NULL;
1058
1059         return 0;
1060 }
1061
1062 static void manager_free(Manager *m) {
1063         if (!m)
1064                 return;
1065
1066         manager_disconnect(m);
1067         manager_flush_names(m);
1068
1069         sd_event_source_unref(m->event_retry);
1070
1071         sd_event_source_unref(m->network_event_source);
1072         sd_network_monitor_unref(m->network_monitor);
1073
1074         sd_resolve_unref(m->resolve);
1075         sd_event_unref(m->event);
1076
1077         free(m);
1078 }
1079
1080 int config_parse_servers(
1081                 const char *unit,
1082                 const char *filename,
1083                 unsigned line,
1084                 const char *section,
1085                 unsigned section_line,
1086                 const char *lvalue,
1087                 int ltype,
1088                 const char *rvalue,
1089                 void *data,
1090                 void *userdata) {
1091
1092         Manager *m = userdata;
1093
1094         assert(filename);
1095         assert(lvalue);
1096         assert(rvalue);
1097
1098         manager_flush_names(m);
1099         manager_add_server_string(m, rvalue);
1100
1101         return 0;
1102 }
1103
1104 static int manager_parse_config_file(Manager *m) {
1105         static const char fn[] = "/etc/systemd/timesyncd.conf";
1106         _cleanup_fclose_ FILE *f = NULL;
1107         int r;
1108
1109         assert(m);
1110
1111         f = fopen(fn, "re");
1112         if (!f) {
1113                 if (errno == ENOENT)
1114                         return 0;
1115
1116                 log_warning("Failed to open configuration file %s: %m", fn);
1117                 return -errno;
1118         }
1119
1120         r = config_parse(NULL, fn, f, "Time\0", config_item_perf_lookup,
1121                          (void*) timesyncd_gperf_lookup, false, false, m);
1122         if (r < 0)
1123                 log_warning("Failed to parse configuration file: %s", strerror(-r));
1124
1125         return r;
1126 }
1127
1128 static bool network_is_online(void) {
1129         _cleanup_free_ char *state = NULL;
1130         int r;
1131
1132         r = sd_network_get_operational_state(&state);
1133         if (r >= 0 && STR_IN_SET(state, "routable", "degraded"))
1134                 return true;
1135
1136         return false;
1137 }
1138
1139 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents,
1140                                          void *userdata) {
1141         Manager *m = userdata;
1142         bool connected, online;
1143         int r;
1144
1145         assert(m);
1146
1147         /* check if the machine is online */
1148         online = network_is_online();
1149
1150         /* check if the client is currently connected */
1151         connected = (m->server_socket != -1);
1152
1153         if (connected && !online) {
1154                 log_info("No network connectivity, watching for changes.");
1155                 manager_disconnect(m);
1156         } else if (!connected && online) {
1157                 log_info("Network configuration changed, trying to establish connection.");
1158                 if (m->current_server_address) {
1159                         r = manager_begin(m);
1160                         if (r < 0)
1161                                 return r;
1162                 } else {
1163                         r = manager_connect(m);
1164                         if (r < 0)
1165                                 return r;
1166                 }
1167         }
1168
1169         sd_network_monitor_flush(m->network_monitor);
1170
1171         return 0;
1172 }
1173
1174 static int manager_network_monitor_listen(Manager *m) {
1175         _cleanup_event_source_unref_ sd_event_source *event_source = NULL;
1176         _cleanup_network_monitor_unref_ sd_network_monitor *monitor = NULL;
1177         int r, fd, events;
1178
1179         r = sd_network_monitor_new(NULL, &monitor);
1180         if (r < 0)
1181                 return r;
1182
1183         fd = sd_network_monitor_get_fd(monitor);
1184         if (fd < 0)
1185                 return fd;
1186
1187         events = sd_network_monitor_get_events(monitor);
1188         if (events < 0)
1189                 return events;
1190
1191         r = sd_event_add_io(m->event, &event_source, fd, events,
1192                             &manager_network_event_handler, m);
1193         if (r < 0)
1194                 return r;
1195
1196         m->network_monitor = monitor;
1197         m->network_event_source = event_source;
1198         monitor = NULL;
1199         event_source = NULL;
1200
1201         return 0;
1202 }
1203
1204 int main(int argc, char *argv[]) {
1205         const char *user = "systemd-timesync";
1206         _cleanup_manager_free_ Manager *m = NULL;
1207         uid_t uid;
1208         gid_t gid;
1209         int r;
1210
1211         if (argc > 1) {
1212                 log_error("This program does not take arguments.");
1213                 return EXIT_FAILURE;
1214         }
1215
1216         log_set_target(LOG_TARGET_AUTO);
1217         log_set_facility(LOG_CRON);
1218         log_parse_environment();
1219         log_open();
1220
1221         umask(0022);
1222
1223         r = get_user_creds(&user, &uid, &gid, NULL, NULL);
1224         if (r < 0) {
1225                 log_error("Cannot resolve user name %s: %s", user, strerror(-r));
1226                 return r;
1227         }
1228
1229         r = load_clock_timestamp(uid, gid);
1230         if (r < 0)
1231                 goto out;
1232
1233         r = drop_privileges(uid, gid, (1ULL << CAP_SYS_TIME));
1234         if (r < 0)
1235                 goto out;
1236
1237         assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
1238
1239         r = manager_new(&m);
1240         if (r < 0) {
1241                 log_error("Failed to allocate manager: %s", strerror(-r));
1242                 goto out;
1243         }
1244
1245         manager_add_server_string(m, NTP_SERVERS);
1246         manager_parse_config_file(m);
1247
1248         r = manager_network_monitor_listen(m);
1249         if (r < 0) {
1250                 log_error("Failed to listen to networkd events: %s", strerror(-r));
1251                 goto out;
1252         }
1253
1254         log_debug("systemd-timesyncd running as pid %lu", (unsigned long) getpid());
1255         sd_notify(false, "READY=1");
1256
1257         if (network_is_online()) {
1258                 r = manager_connect(m);
1259                 if (r < 0)
1260                         goto out;
1261         }
1262
1263         r = sd_event_loop(m->event);
1264         if (r < 0) {
1265                 log_error("Failed to run event loop: %s", strerror(-r));
1266                 goto out;
1267         }
1268
1269         sd_event_get_exit_code(m->event, &r);
1270
1271         /* if we got an authoritative time, store it in the file system */
1272         if (m->sync)
1273                 touch("/var/lib/systemd/clock");
1274
1275 out:
1276         sd_notify(false, "STATUS=Shutting down...");
1277
1278         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1279 }