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 "sd-daemon.h"
  23 #include "sd-event.h"
  24
  25 #include "capability.h"
  26 #include "clock-util.h"
  27 #include "fd-util.h"
  28 #include "network-util.h"
  29 #include "signal-util.h"
  30 #include "timesyncd-conf.h"
  31 #include "timesyncd-manager.h"
  32 #include "user-util.h"
  33
  34 static int load_clock_timestamp(uid_t uid, gid_t gid) {
  35         _cleanup_close_ int fd = -1;
  36         usec_t min = TIME_EPOCH * USEC_PER_SEC;
  37         usec_t ct;
  38         int r;
  39
  40         /* Let's try to make sure that the clock is always
  41          * monotonically increasing, by saving the clock whenever we
  42          * have a new NTP time, or when we shut down, and restoring it
  43          * when we start again. This is particularly helpful on
  44          * systems lacking a battery backed RTC. We also will adjust
  45          * the time to at least the build time of systemd. */
  46
  47         fd = open("/var/lib/systemd/clock", O_RDWR|O_CLOEXEC, 0644);
  48         if (fd >= 0) {
  49                 struct stat st;
  50                 usec_t stamp;
  51
  52                 /* check if the recorded time is later than the compiled-in one */
  53                 r = fstat(fd, &st);
  54                 if (r >= 0) {
  55                         stamp = timespec_load(&st.st_mtim);
  56                         if (stamp > min)
  57                                 min = stamp;
  58                 }
  59
  60                 /* Try to fix the access mode, so that we can still
  61                    touch the file after dropping priviliges */
  62                 (void) fchmod(fd, 0644);
  63                 (void) fchown(fd, uid, gid);
  64
  65         } else
  66                 /* create stamp file with the compiled-in date */
  67                 (void) touch_file("/var/lib/systemd/clock", true, min, uid, gid, 0644);
  68
  69         ct = now(CLOCK_REALTIME);
  70         if (ct < min) {
  71                 struct timespec ts;
  72                 char date[FORMAT_TIMESTAMP_MAX];
  73
  74                 log_info("System clock time unset or jumped backwards, restoring from recorded timestamp: %s",
  75                          format_timestamp(date, sizeof(date), min));
  76
  77                 if (clock_settime(CLOCK_REALTIME, timespec_store(&ts, min)) < 0)
  78                         log_error_errno(errno, "Failed to restore system clock: %m");
  79         }
  80
  81         return 0;
  82 }
  83
  84 int main(int argc, char *argv[]) {
  85         _cleanup_(manager_freep) Manager *m = NULL;
  86         const char *user = "systemd-timesync";
  87         uid_t uid;
  88         gid_t gid;
  89         int r;
  90
  91         log_set_target(LOG_TARGET_AUTO);
  92         log_set_facility(LOG_CRON);
  93         log_parse_environment();
  94         log_open();
  95
  96         umask(0022);
  97
  98         if (argc != 1) {
  99                 log_error("This program does not take arguments.");
 100                 r = -EINVAL;
 101                 goto finish;
 102         }
 103
 104         r = get_user_creds(&user, &uid, &gid, NULL, NULL);
 105         if (r < 0) {
 106                 log_error_errno(r, "Cannot resolve user name %s: %m", user);
 107                 goto finish;
 108         }
 109
 110         r = load_clock_timestamp(uid, gid);
 111         if (r < 0)
 112                 goto finish;
 113
 114         r = drop_privileges(uid, gid, (1ULL << CAP_SYS_TIME));
 115         if (r < 0)
 116                 goto finish;
 117
 118         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, -1) >= 0);
 119
 120         r = manager_new(&m);
 121         if (r < 0) {
 122                 log_error_errno(r, "Failed to allocate manager: %m");
 123                 goto finish;
 124         }
 125
 126         if (clock_is_localtime() > 0) {
 127                 log_info("The system is configured to read the RTC time in the local time zone. "
 128                          "This mode can not be fully supported. All system time to RTC updates are disabled.");
 129                 m->rtc_local_time = true;
 130         }
 131
 132         r = manager_parse_config_file(m);
 133         if (r < 0)
 134                 log_warning_errno(r, "Failed to parse configuration file: %m");
 135
 136         log_debug("systemd-timesyncd running as pid " PID_FMT, getpid());
 137         sd_notify(false,
 138                   "READY=1\n"
 139                   "STATUS=Daemon is running");
 140
 141         if (network_is_online()) {
 142                 r = manager_connect(m);
 143                 if (r < 0)
 144                         goto finish;
 145         }
 146
 147         r = sd_event_loop(m->event);
 148         if (r < 0) {
 149                 log_error_errno(r, "Failed to run event loop: %m");
 150                 goto finish;
 151         }
 152
 153         /* if we got an authoritative time, store it in the file system */
 154         if (m->sync)
 155                 (void) touch("/var/lib/systemd/clock");
 156
 157         sd_event_get_exit_code(m->event, &r);
 158
 159 finish:
 160         sd_notify(false,
 161                   "STOPPING=1\n"
 162                   "STATUS=Shutting down...");
 163
 164         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 165 }