src/timedate/timedate-sntp.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
   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 /*
  23  * "Simple Network Time Protocol Version 4 (SNTPv4) is a subset of the
  24  * Network Time Protocol (NTP) used to synchronize computer clocks in
  25  * the Internet. SNTPv4 can be used when the ultimate performance of
  26  * a full NTP implementation based on RFC 1305 is neither needed nor
  27  * justified."
  28  *
  29  * "Unlike most NTP clients, SNTP clients normally operate with only a
  30  * single server at a time."
  31  *
  32  * http://tools.ietf.org/html/rfc4330
  33  */
  34
  35 #include <stdlib.h>
  36 #include <errno.h>
  37 #include <fcntl.h>
  38 #include <unistd.h>
  39 #include <string.h>
  40 #include <time.h>
  41 #include <math.h>
  42 #include <arpa/inet.h>
  43 #include <netinet/in.h>
  44 #include <netinet/ip.h>
  45 #include <sys/timerfd.h>
  46 #include <sys/timex.h>
  47 #include <sys/socket.h>
  48
  49 #include "missing.h"
  50 #include "util.h"
  51 #include "sparse-endian.h"
  52 #include "log.h"
  53 #include "sd-event.h"
  54 #include "timedate-sntp.h"
  55
  56 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
  57
  58 #ifndef ADJ_SETOFFSET
  59 #define ADJ_SETOFFSET                   0x0100  /* add 'time' to current time */
  60 #endif
  61
  62 /* Maximum delta in seconds which the system clock is gradually adjusted
  63  * to approach the network time. Deltas larger that this are set by letting
  64  * the system time jump. The maximum for adjtime is 500ms.
  65  */
  66 #define NTP_MAX_ADJUST                  0.2
  67
  68 /*
  69  * "Define the required accuracy of the system clock, then calculate the
  70  * maximum timeout. Use the longest maximum timeout possible given the system
  71  * constraints to minimize time server aggregate load."
  72  *
  73  * "A client MUST NOT under any conditions use a poll interval less
  74  * than 15 seconds."
  75  */
  76 #define NTP_POLL_INTERVAL_MIN_SEC       16
  77 #define NTP_POLL_INTERVAL_MAX_SEC       2048
  78 #define NTP_ACCURACY_SEC                0.1
  79
  80 #define NTP_LEAP_PLUSSEC                1
  81 #define NTP_LEAP_MINUSSEC               2
  82 #define NTP_LEAP_NOTINSYNC              3
  83 #define NTP_MODE_CLIENT                 3
  84 #define NTP_MODE_SERVER                 4
  85 #define NTP_FIELD_LEAP(f)               (((f) >> 6) & 3)
  86 #define NTP_FIELD_VERSION(f)            (((f) >> 3) & 7)
  87 #define NTP_FIELD_MODE(f)               ((f) & 7)
  88 #define NTP_FIELD(l, v, m)              (((l) << 6) | ((v) << 3) | (m))
  89
  90 /*
  91  * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
  92  * in seconds relative to 0h on 1 January 1900."
  93  */
  94 #define OFFSET_1900_1970        2208988800UL
  95
  96 struct ntp_ts {
  97         be32_t sec;
  98         be32_t frac;
  99 } _packed_;
 100
 101 struct ntp_ts_short {
 102         be16_t sec;
 103         be16_t frac;
 104 } _packed_;
 105
 106 struct ntp_msg {
 107         uint8_t field;
 108         uint8_t stratum;
 109         int8_t poll;
 110         int8_t precision;
 111         struct ntp_ts_short root_delay;
 112         struct ntp_ts_short root_dispersion;
 113         char refid[4];
 114         struct ntp_ts reference_time;
 115         struct ntp_ts origin_time;
 116         struct ntp_ts recv_time;
 117         struct ntp_ts trans_time;
 118 } _packed_;
 119
 120 struct SNTPContext {
 121         void (*report)(usec_t poll, double offset, double delay, double jitter, bool spike);
 122
 123         /* peer */
 124         sd_event_source *event_receive;
 125         char *server;
 126         struct sockaddr_in server_addr;
 127         int server_socket;
 128         uint64_t packet_count;
 129
 130         /* last sent packet */
 131         struct timespec trans_time_mon;
 132         struct timespec trans_time;
 133         usec_t retry_interval;
 134         bool pending;
 135
 136         /* poll timer */
 137         sd_event_source *event_timer;
 138         usec_t poll_interval_usec;
 139         bool poll_resync;
 140
 141         /* history data */
 142         struct {
 143                 double offset;
 144                 double delay;
 145         } samples[8];
 146         unsigned int samples_idx;
 147         double samples_jitter;
 148
 149         /* last change */
 150         bool jumped;
 151
 152         /* watch for time changes */
 153         sd_event_source *event_clock_watch;
 154         int clock_watch_fd;
 155 };
 156
 157 static int sntp_arm_timer(SNTPContext *sntp, usec_t next);
 158 static int sntp_clock_watch_setup(SNTPContext *sntp);
 159
 160 static double ntp_ts_to_d(const struct ntp_ts *ts) {
 161         return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
 162 }
 163
 164 static double tv_to_d(const struct timeval *tv) {
 165         return tv->tv_sec + (1.0e-6 * tv->tv_usec);
 166 }
 167
 168 static double ts_to_d(const struct timespec *ts) {
 169         return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
 170 }
 171
 172 static void d_to_tv(double d, struct timeval *tv) {
 173         tv->tv_sec = (long)d;
 174         tv->tv_usec = (d - tv->tv_sec) * 1000 * 1000;
 175
 176         /* the kernel expects -0.3s as {-1, 7000.000} */
 177         if (tv->tv_usec < 0) {
 178                 tv->tv_sec  -= 1;
 179                 tv->tv_usec += 1000 * 1000;
 180         }
 181 }
 182
 183 static double square(double d) {
 184         return d * d;
 185 }
 186
 187 static int sntp_send_request(SNTPContext *sntp) {
 188         struct ntp_msg ntpmsg = {};
 189         struct sockaddr_in addr = {};
 190         ssize_t len;
 191         int r;
 192
 193         /*
 194          * "The client initializes the NTP message header, sends the request
 195          * to the server, and strips the time of day from the Transmit
 196          * Timestamp field of the reply.  For this purpose, all the NTP
 197          * header fields are set to 0, except the Mode, VN, and optional
 198          * Transmit Timestamp fields."
 199          */
 200         ntpmsg.field = NTP_FIELD(0, 4, NTP_MODE_CLIENT);
 201
 202         /*
 203          * Set transmit timestamp, remember it; the server will send that back
 204          * as the origin timestamp and we have an indication that this is the
 205          * matching answer to our request.
 206          *
 207          * The actual value does not matter, We do not care about the correct
 208          * NTP UINT_MAX fraction, we just pass the plain nanosecond value.
 209          */
 210         clock_gettime(CLOCK_MONOTONIC, &sntp->trans_time_mon);
 211         clock_gettime(CLOCK_REALTIME, &sntp->trans_time);
 212         ntpmsg.trans_time.sec = htobe32(sntp->trans_time.tv_sec + OFFSET_1900_1970);
 213         ntpmsg.trans_time.frac = htobe32(sntp->trans_time.tv_nsec);
 214
 215         addr.sin_family = AF_INET;
 216         addr.sin_port = htobe16(123);
 217         addr.sin_addr.s_addr = inet_addr(sntp->server);
 218         len = sendto(sntp->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &addr, sizeof(addr));
 219         if (len == sizeof(ntpmsg)) {
 220                 sntp->pending = true;
 221                 log_debug("Sent NTP request to: %s", sntp->server);
 222         } else
 223                 log_debug("Sending NTP request to %s failed: %m", sntp->server);
 224
 225         /* re-arm timer with incresing timeout, in case the packets never arrive back */
 226         if (sntp->retry_interval > 0) {
 227                 if (sntp->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 228                         sntp->retry_interval *= 2;
 229         } else
 230                 sntp->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 231         r = sntp_arm_timer(sntp, sntp->retry_interval);
 232         if (r < 0)
 233                 return r;
 234
 235         return 0;
 236 }
 237
 238 static int sntp_timer(sd_event_source *source, usec_t usec, void *userdata) {
 239         SNTPContext *sntp = userdata;
 240
 241         assert(sntp);
 242
 243         sntp_send_request(sntp);
 244         return 0;
 245 }
 246
 247 static int sntp_arm_timer(SNTPContext *sntp, usec_t next) {
 248         sd_event *e;
 249         int r;
 250
 251         assert(sntp);
 252         assert(sntp->event_receive);
 253
 254         if (next == 0) {
 255                 sntp->event_timer = sd_event_source_unref(sntp->event_timer);
 256                 return 0;
 257         }
 258
 259         if (sntp->event_timer) {
 260                 r = sd_event_source_set_time(sntp->event_timer, now(CLOCK_MONOTONIC) + next);
 261                 if (r < 0)
 262                         return r;
 263
 264                 return sd_event_source_set_enabled(sntp->event_timer, SD_EVENT_ONESHOT);
 265         }
 266
 267         e = sd_event_source_get_event(sntp->event_receive);
 268         r = sd_event_add_monotonic(e, &sntp->event_timer, now(CLOCK_MONOTONIC) + next, 0, sntp_timer, sntp);
 269         if (r < 0)
 270                 return r;
 271
 272         return 0;
 273 }
 274
 275 static int sntp_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 276         SNTPContext *sntp = userdata;
 277
 278         assert(sntp);
 279         assert(sntp->event_receive);
 280
 281         /* rearm timer */
 282         sntp_clock_watch_setup(sntp);
 283
 284         /* skip our own jumps */
 285         if (sntp->jumped) {
 286                 sntp->jumped = false;
 287                 return 0;
 288         }
 289
 290         /* resync */
 291         log_info("System time changed, resyncing.");
 292         sntp->poll_resync = true;
 293         sntp_send_request(sntp);
 294
 295         return 0;
 296 }
 297
 298 /* wake up when the system time changes underneath us */
 299 static int sntp_clock_watch_setup(SNTPContext *sntp) {
 300         struct itimerspec its = { .it_value.tv_sec = TIME_T_MAX };
 301         _cleanup_close_ int fd = -1;
 302         sd_event *e;
 303         sd_event_source *source;
 304         int r;
 305
 306         assert(sntp);
 307         assert(sntp->event_receive);
 308
 309         fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
 310         if (fd < 0) {
 311                 log_error("Failed to create timerfd: %m");
 312                 return -errno;
 313         }
 314
 315         if (timerfd_settime(fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
 316                 log_error("Failed to set up timerfd: %m");
 317                 return -errno;
 318         }
 319
 320         e = sd_event_source_get_event(sntp->event_receive);
 321         r = sd_event_add_io(e, &source, fd, EPOLLIN, sntp_clock_watch, sntp);
 322         if (r < 0) {
 323                 log_error("Failed to create clock watch event source: %s", strerror(-r));
 324                 return r;
 325         }
 326
 327         sd_event_source_unref(sntp->event_clock_watch);
 328         sntp->event_clock_watch = source;
 329
 330         if (sntp->clock_watch_fd >= 0)
 331                 close(sntp->clock_watch_fd);
 332         sntp->clock_watch_fd = fd;
 333         fd = -1;
 334
 335         return 0;
 336 }
 337
 338 static int sntp_adjust_clock(SNTPContext *sntp, double offset, int leap_sec) {
 339         struct timex tmx = {};
 340         int r;
 341
 342         /*
 343          * For small deltas, tell the kernel to gradually adjust the system
 344          * clock to the NTP time, larger deltas are just directly set.
 345          *
 346          * Clear STA_UNSYNC, it will enable the kernel's 11-minute mode, which
 347          * syncs the system time periodically to the hardware clock.
 348          */
 349         if (offset < NTP_MAX_ADJUST && offset > -NTP_MAX_ADJUST) {
 350                 tmx.modes |= ADJ_STATUS | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
 351                 tmx.status = STA_PLL;
 352                 tmx.offset = offset * 1000 * 1000;
 353                 tmx.constant = log2i(sntp->poll_interval_usec / USEC_PER_SEC) - 6;
 354                 tmx.maxerror = 0;
 355                 tmx.esterror = 0;
 356                 log_debug("  adjust (slew): %+f sec\n", (double)tmx.offset / USEC_PER_SEC);
 357         } else {
 358                 tmx.modes = ADJ_SETOFFSET;
 359                 d_to_tv(offset, &tmx.time);
 360
 361                 sntp->jumped = true;
 362                 log_debug("  adjust (jump): %+f sec\n", tv_to_d(&tmx.time));
 363         }
 364
 365         switch (leap_sec) {
 366         case 1:
 367                 tmx.status |= STA_INS;
 368                 break;
 369         case -1:
 370                 tmx.status |= STA_DEL;
 371                 break;
 372         }
 373
 374         r = clock_adjtime(CLOCK_REALTIME, &tmx);
 375         if (r < 0)
 376                 return r;
 377
 378         log_debug("  status       : %04i %s\n"
 379                   "  time now     : %li.%06li\n"
 380                   "  constant     : %li\n"
 381                   "  offset       : %+f sec\n"
 382                   "  freq offset  : %+li (%+.3f ppm)\n",
 383                   tmx.status, tmx.status & STA_UNSYNC ? "" : "sync",
 384                   tmx.time.tv_sec, tmx.time.tv_usec,
 385                   tmx.constant,
 386                   (double)tmx.offset / USEC_PER_SEC,
 387                   tmx.freq, (double)tmx.freq / 65536);
 388
 389         return 0;
 390 }
 391
 392 static bool sntp_sample_spike_detection(SNTPContext *sntp, double offset, double delay) {
 393         unsigned int i, idx_cur, idx_new, idx_min;
 394         double jitter;
 395         double j;
 396
 397         /* store the current data in our samples array */
 398         idx_cur = sntp->samples_idx;
 399         idx_new = (idx_cur + 1) % ELEMENTSOF(sntp->samples);
 400         sntp->samples_idx = idx_new;
 401         sntp->samples[idx_new].offset = offset;
 402         sntp->samples[idx_new].delay = delay;
 403
 404         sntp->packet_count++;
 405         jitter = sntp->samples_jitter;
 406
 407         /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
 408         for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(sntp->samples); i++)
 409                 if (sntp->samples[i].delay > 0 && sntp->samples[i].delay < sntp->samples[idx_min].delay)
 410                         idx_min = i;
 411
 412         j = 0;
 413         for (i = 0; i < ELEMENTSOF(sntp->samples); i++)
 414                 j += square(sntp->samples[i].offset - sntp->samples[idx_min].offset);
 415         sntp->samples_jitter = sqrt(j / (ELEMENTSOF(sntp->samples) - 1));
 416
 417         /* ignore samples when resyncing */
 418         if (sntp->poll_resync)
 419                 return false;
 420
 421         /* always accept offset if we are farther off than the round-trip delay */
 422         if (fabs(offset) > delay)
 423                 return false;
 424
 425         /* we need a few samples before looking at them */
 426         if (sntp->packet_count < 4)
 427                 return false;
 428
 429         /* do not accept anything worse than the maximum possible error of the best sample */
 430         if (fabs(offset) > sntp->samples[idx_min].delay)
 431                 return true;
 432
 433         /* compare the difference between the current offset to the previous offset and jitter */
 434         return fabs(offset - sntp->samples[idx_cur].offset) > 3 * jitter;
 435 }
 436
 437 static void sntp_adjust_poll(SNTPContext *sntp, double offset, bool spike) {
 438         if (sntp->poll_resync) {
 439                 sntp->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 440                 sntp->poll_resync = false;
 441                 return;
 442         }
 443
 444         /* set to minimal poll interval */
 445         if (fabs(offset) > NTP_ACCURACY_SEC) {
 446                 sntp->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 447                 return;
 448         }
 449
 450         /* increase polling interval */
 451         if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
 452                 if (sntp->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 453                         sntp->poll_interval_usec *= 2;
 454                 return;
 455         }
 456
 457         /* decrease polling interval */
 458         if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
 459                 if (sntp->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
 460                         sntp->poll_interval_usec /= 2;
 461                 return;
 462         }
 463 }
 464
 465 static int sntp_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 466         SNTPContext *sntp = userdata;
 467         unsigned char buf[sizeof(struct ntp_msg)];
 468         struct iovec iov = {
 469                 .iov_base = buf,
 470                 .iov_len = sizeof(buf),
 471         };
 472         union {
 473                 struct cmsghdr cmsghdr;
 474                 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
 475         } control;
 476         struct sockaddr_in server_addr;
 477         struct msghdr msghdr = {
 478                 .msg_iov = &iov,
 479                 .msg_iovlen = 1,
 480                 .msg_control = &control,
 481                 .msg_controllen = sizeof(control),
 482                 .msg_name = &server_addr,
 483                 .msg_namelen = sizeof(server_addr),
 484         };
 485         struct cmsghdr *cmsg;
 486         struct timespec now_ts;
 487         struct timeval *recv_time;
 488         ssize_t len;
 489         struct ntp_msg *ntpmsg;
 490         double origin, receive, trans, dest;
 491         double delay, offset;
 492         bool spike;
 493         int leap_sec;
 494         int r;
 495
 496         if (revents & (EPOLLHUP|EPOLLERR)) {
 497                 log_debug("Server connection returned error, closing.");
 498                 sntp_server_disconnect(sntp);
 499                 return -ENOTCONN;
 500         }
 501
 502         len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
 503         if (len < 0) {
 504                 log_debug("Error receiving message, disconnecting");
 505                 return -EINVAL;
 506         }
 507
 508         if (iov.iov_len < sizeof(struct ntp_msg)) {
 509                 log_debug("Invalid response from server, disconnecting");
 510                 return -EINVAL;
 511         }
 512
 513         if (sntp->server_addr.sin_addr.s_addr != server_addr.sin_addr.s_addr) {
 514                 log_debug("Response from unknown server, disconnecting");
 515                 return -EINVAL;
 516         }
 517
 518         recv_time = NULL;
 519         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
 520                 if (cmsg->cmsg_level != SOL_SOCKET)
 521                         continue;
 522
 523                 switch (cmsg->cmsg_type) {
 524                 case SCM_TIMESTAMP:
 525                         recv_time = (struct timeval *) CMSG_DATA(cmsg);
 526                         break;
 527                 }
 528         }
 529         if (!recv_time) {
 530                 log_debug("Invalid packet timestamp, disconnecting");
 531                 return -EINVAL;
 532         }
 533
 534         ntpmsg = iov.iov_base;
 535         if (!sntp->pending) {
 536                 log_debug("Unexpected reply, ignoring");
 537                 return 0;
 538         }
 539
 540         /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
 541         if (be32toh(ntpmsg->origin_time.sec) != sntp->trans_time.tv_sec + OFFSET_1900_1970||
 542             be32toh(ntpmsg->origin_time.frac) != sntp->trans_time.tv_nsec) {
 543                 log_debug("Invalid reply, not our transmit time, ignoring");
 544                 return 0;
 545         }
 546
 547         if (NTP_FIELD_LEAP(ntpmsg->field) == NTP_LEAP_NOTINSYNC) {
 548                 log_debug("Server is not synchronized, disconnecting");
 549                 return -EINVAL;
 550         }
 551
 552         if (NTP_FIELD_VERSION(ntpmsg->field) != 4) {
 553                 log_debug("Response NTPv%d, disconnecting", NTP_FIELD_VERSION(ntpmsg->field));
 554                 return -EINVAL;
 555         }
 556
 557         if (NTP_FIELD_MODE(ntpmsg->field) != NTP_MODE_SERVER) {
 558                 log_debug("Unsupported mode %d, disconnecting", NTP_FIELD_MODE(ntpmsg->field));
 559                 return -EINVAL;
 560         }
 561
 562         /* valid packet */
 563         sntp->pending = false;
 564         sntp->retry_interval = 0;
 565
 566         /* announce leap seconds */
 567         if (NTP_FIELD_LEAP(ntpmsg->field) & NTP_LEAP_PLUSSEC)
 568                 leap_sec = 1;
 569         else if (NTP_FIELD_LEAP(ntpmsg->field) & NTP_LEAP_MINUSSEC)
 570                 leap_sec = -1;
 571         else
 572                 leap_sec = 0;
 573
 574         /*
 575          * "Timestamp Name          ID   When Generated
 576          *  ------------------------------------------------------------
 577          *  Originate Timestamp     T1   time request sent by client
 578          *  Receive Timestamp       T2   time request received by server
 579          *  Transmit Timestamp      T3   time reply sent by server
 580          *  Destination Timestamp   T4   time reply received by client
 581          *
 582          *  The roundtrip delay d and system clock offset t are defined as:
 583          *  d = (T4 - T1) - (T3 - T2)     t = ((T2 - T1) + (T3 - T4)) / 2"
 584          */
 585         clock_gettime(CLOCK_MONOTONIC, &now_ts);
 586         origin = tv_to_d(recv_time) - (ts_to_d(&now_ts) - ts_to_d(&sntp->trans_time_mon)) + OFFSET_1900_1970;
 587         receive = ntp_ts_to_d(&ntpmsg->recv_time);
 588         trans = ntp_ts_to_d(&ntpmsg->trans_time);
 589         dest = tv_to_d(recv_time) + OFFSET_1900_1970;
 590
 591         offset = ((receive - origin) + (trans - dest)) / 2;
 592         delay = (dest - origin) - (trans - receive);
 593
 594         spike = sntp_sample_spike_detection(sntp, offset, delay);
 595
 596         sntp_adjust_poll(sntp, offset, spike);
 597
 598         log_debug("NTP response:\n"
 599                   "  leap         : %u\n"
 600                   "  version      : %u\n"
 601                   "  mode         : %u\n"
 602                   "  stratum      : %u\n"
 603                   "  precision    : %f sec (%d)\n"
 604                   "  reference    : %.4s\n"
 605                   "  origin       : %f\n"
 606                   "  receive      : %f\n"
 607                   "  transmit     : %f\n"
 608                   "  dest         : %f\n"
 609                   "  offset       : %+f sec\n"
 610                   "  delay        : %+f sec\n"
 611                   "  packet count : %"PRIu64"\n"
 612                   "  jitter       : %f%s\n"
 613                   "  poll interval: %llu\n",
 614                   NTP_FIELD_LEAP(ntpmsg->field),
 615                   NTP_FIELD_VERSION(ntpmsg->field),
 616                   NTP_FIELD_MODE(ntpmsg->field),
 617                   ntpmsg->stratum,
 618                   exp2(ntpmsg->precision), ntpmsg->precision,
 619                   ntpmsg->stratum == 1 ? ntpmsg->refid : "n/a",
 620                   origin - OFFSET_1900_1970,
 621                   receive - OFFSET_1900_1970,
 622                   trans - OFFSET_1900_1970,
 623                   dest - OFFSET_1900_1970,
 624                   offset, delay,
 625                   sntp->packet_count,
 626                   sntp->samples_jitter, spike ? " spike" : "",
 627                   sntp->poll_interval_usec / USEC_PER_SEC);
 628
 629         if (sntp->report)
 630                 sntp->report(sntp->poll_interval_usec, offset, delay, sntp->samples_jitter, spike);
 631
 632         if (!spike) {
 633                 r = sntp_adjust_clock(sntp, offset, leap_sec);
 634                 if (r < 0)
 635                         log_error("Failed to call clock_adjtime(): %m");
 636         }
 637
 638         r = sntp_arm_timer(sntp, sntp->poll_interval_usec);
 639         if (r < 0)
 640                 return r;
 641
 642         return 0;
 643 }
 644
 645 int sntp_server_connect(SNTPContext *sntp, const char *server) {
 646         _cleanup_free_ char *s = NULL;
 647
 648         assert(sntp);
 649         assert(server);
 650         assert(sntp->server_socket >= 0);
 651
 652         s = strdup(server);
 653         if (!s)
 654                 return -ENOMEM;
 655
 656         free(sntp->server);
 657         sntp->server = s;
 658         s = NULL;
 659
 660         zero(sntp->server_addr);
 661         sntp->server_addr.sin_family = AF_INET;
 662         sntp->server_addr.sin_addr.s_addr = inet_addr(server);
 663
 664         sntp->poll_interval_usec = 2 * NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 665
 666         return sntp_send_request(sntp);
 667 }
 668
 669 void sntp_server_disconnect(SNTPContext *sntp) {
 670         if (!sntp->server)
 671                 return;
 672
 673         sntp->event_timer = sd_event_source_unref(sntp->event_timer);
 674
 675         sntp->event_clock_watch = sd_event_source_unref(sntp->event_clock_watch);
 676         if (sntp->clock_watch_fd > 0)
 677                 close(sntp->clock_watch_fd);
 678         sntp->clock_watch_fd = -1;
 679
 680         sntp->event_receive = sd_event_source_unref(sntp->event_receive);
 681         if (sntp->server_socket > 0)
 682                 close(sntp->server_socket);
 683         sntp->server_socket = -1;
 684
 685         zero(sntp->server_addr);
 686         free(sntp->server);
 687         sntp->server = NULL;
 688 }
 689
 690 static int sntp_listen_setup(SNTPContext *sntp, sd_event *e) {
 691         _cleanup_close_ int fd = -1;
 692         struct sockaddr_in addr;
 693         const int on = 1;
 694         const int tos = IPTOS_LOWDELAY;
 695         int r;
 696
 697         fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 698         if (fd < 0)
 699                 return -errno;
 700
 701         zero(addr);
 702         addr.sin_family = AF_INET;
 703         r = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
 704         if (r < 0)
 705                 return -errno;
 706
 707         r = setsockopt(fd, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on));
 708         if (r < 0)
 709                 return -errno;
 710
 711         r = setsockopt(fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
 712         if (r < 0)
 713                 return -errno;
 714
 715         r = sd_event_add_io(e, &sntp->event_receive, fd, EPOLLIN, sntp_receive_response, sntp);
 716         if (r < 0)
 717                 return r;
 718
 719         sntp->server_socket = fd;
 720         fd = -1;
 721
 722         return 0;
 723 }
 724
 725 void sntp_report_register(SNTPContext *sntp, void (*report)(usec_t poll_usec, double offset, double delay, double jitter, bool spike)) {
 726         sntp->report = report;
 727 }
 728
 729 int sntp_new(SNTPContext **sntp, sd_event *e) {
 730         _cleanup_free_ SNTPContext *c;
 731         int r;
 732
 733         c = new0(SNTPContext, 1);
 734         if (!c)
 735                 return -ENOMEM;
 736
 737         r = sntp_listen_setup(c, e);
 738         if (r < 0)
 739                 return r;
 740
 741         r = sntp_clock_watch_setup(c);
 742         if (r < 0)
 743                 return r;
 744
 745         *sntp = c;
 746         c = NULL;
 747
 748         return 0;
 749 }
 750
 751 SNTPContext *sntp_unref(SNTPContext *sntp) {
 752         sntp_server_disconnect(sntp);
 753         free(sntp);
 754         return NULL;
 755 }