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