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