From 37d9aeb4da8169c85ef5e96eefd4b0da30dcb83a Mon Sep 17 00:00:00 2001 From: Alexandre Rostovtsev Date: Wed, 5 Sep 2012 12:48:04 -0400 Subject: Add timedated implementation Includes a chunk of copy-pasted code from systemd for dealing with RTC. Should probably be replaced with something more glib-ish eventually. --- .gitignore | 1 + Makefile.am | 31 +- TODO | 2 +- configure.ac | 2 + data/timedate1.xml | 26 ++ src/copypaste/hwclock.c | 193 +++++++++++++ src/copypaste/hwclock.h | 32 +++ src/copypaste/macro.h | 186 ++++++++++++ src/copypaste/util.c | 279 ++++++++++++++++++ src/copypaste/util.h | 110 ++++++++ src/main.c | 6 + src/timedated.c | 729 ++++++++++++++++++++++++++++++++++++++++++++++++ src/timedated.h | 31 ++ 13 files changed, 1625 insertions(+), 3 deletions(-) create mode 100644 data/timedate1.xml create mode 100644 src/copypaste/hwclock.c create mode 100644 src/copypaste/hwclock.h create mode 100644 src/copypaste/macro.h create mode 100644 src/copypaste/util.c create mode 100644 src/copypaste/util.h create mode 100644 src/timedated.c create mode 100644 src/timedated.h diff --git a/.gitignore b/.gitignore index 8fae933..d96a32a 100644 --- a/.gitignore +++ b/.gitignore @@ -21,6 +21,7 @@ /stamp-h1 /src/hostname1-generated.[ch] /src/locale1-generated.[ch] +/src/timedate1-generated.[ch] # Relative rules *.o diff --git a/Makefile.am b/Makefile.am index b0694bf..32890fb 100644 --- a/Makefile.am +++ b/Makefile.am @@ -3,6 +3,7 @@ ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS} EXTRA_DIST = \ data/hostname1.xml \ data/locale1.xml \ + data/timedate1.xml \ $(NULL) pkgdata_DATA = \ @@ -12,6 +13,7 @@ pkgdata_DATA = \ AM_CPPFLAGS = \ -include $(top_builddir)/config.h \ -DSYSCONFDIR=\""$(sysconfdir)"\" \ + -DDATADIR=\""$(datadir)"\" \ -DLIBEXECDIR=\""$(libexecdir)"\" \ -DPKGDATADIR=\""$(pkgdatadir)"\" \ $(OPENRC_SETTINGSD_CFLAGS) \ @@ -33,13 +35,30 @@ localed_built_sources = \ src/locale1-generated.h \ $(NULL) +timedated_built_sources = \ + src/timedate1-generated.c \ + src/timedate1-generated.h \ + $(NULL) + +copypaste_sources = \ + src/copypaste/hwclock.c \ + src/copypaste/hwclock.h \ + src/copypaste/macro.h \ + src/copypaste/util.c \ + src/copypaste/util.h \ + $(NULL) + openrc_settingsd_SOURCES = \ $(hostnamed_built_sources) \ $(localed_built_sources) \ + $(timedated_built_sources) \ + $(copypaste_sources) \ src/hostnamed.c \ src/hostnamed.h \ src/localed.c \ src/localed.h \ + src/timedated.c \ + src/timedated.h \ src/bus-utils.c \ src/bus-utils.h \ src/shell-utils.c \ @@ -63,5 +82,13 @@ $(localed_built_sources) : data/locale1.xml $(srcdir)/data/locale1.xml; \ mv locale1-generated.{c,h} $(top_srcdir)/src/ ) -BUILT_SOURCES = $(hostnamed_built_sources) $(localed_built_sources) -CLEANFILES = $(hostnamed_built_sources) $(localed_built_sources) +$(timedated_built_sources) : data/timedate1.xml + ( $(GDBUS_CODEGEN) \ + --interface-prefix org.freedesktop. \ + --c-namespace OpenrcSettingsdTimedated \ + --generate-c-code timedate1-generated \ + $(srcdir)/data/timedate1.xml; \ + mv timedate1-generated.{c,h} $(top_srcdir)/src/ ) + +BUILT_SOURCES = $(hostnamed_built_sources) $(localed_built_sources) $(timedated_built_sources) +CLEANFILES = $(hostnamed_built_sources) $(localed_built_sources) $(timedated_built_sources) diff --git a/TODO b/TODO index d75749a..ff32ee0 100644 --- a/TODO +++ b/TODO @@ -9,7 +9,7 @@ document that this case is not supported? Write an init.d file to read RC_SYS so that we can piggyback on openrc's built-in virtualization detection. -Implement timedated. +De-systemd-ize hwclock.c Do something about runtime dependency on systemd's org.freedesktop.hostname1.policy, org.freedesktop.locale1.policy, and org.freedesktop.timedate1.policy files. diff --git a/configure.ac b/configure.ac index 9e64fea..4e2e9ac 100644 --- a/configure.ac +++ b/configure.ac @@ -10,6 +10,8 @@ LT_INIT([disable-static pic-only]) AC_PREFIX_DEFAULT([/usr]) AC_PROG_MKDIR_P +AC_SEARCH_LIBS([rc_service_exists], [rc], [], [AC_MSG_ERROR([OpenRC's librc not found])]) +AC_SEARCH_LIBS([clock_gettime], [rt], [], [AC_MSG_ERROR([librt not found])]) PKG_CHECK_MODULES(OPENRC_SETTINGSD, [gio-unix-2.0 >= 2.30 gio-2.0 >= 2.30 glib-2.0 >= 2.30 dbus-1 polkit-gobject-1]) AC_SUBST(OPENRC_SETTINGSD_CFLAGS) AC_SUBST(OPENRC_SETTINGSD_LIBS) diff --git a/data/timedate1.xml b/data/timedate1.xml new file mode 100644 index 0000000..18aa6d6 --- /dev/null +++ b/data/timedate1.xml @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/copypaste/hwclock.c b/src/copypaste/hwclock.c new file mode 100644 index 0000000..ddf206d --- /dev/null +++ b/src/copypaste/hwclock.c @@ -0,0 +1,193 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2010-2012 Lennart Poettering + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "macro.h" +#include "util.h" +#include "hwclock.h" + +static int rtc_open(int flags) { + int fd; + DIR *d; + + /* First, we try to make use of the /dev/rtc symlink. If that + * doesn't exist, we open the first RTC which has hctosys=1 + * set. If we don't find any we just take the first RTC that + * exists at all. */ + + fd = open("/dev/rtc", flags); + if (fd >= 0) + return fd; + + d = opendir("/sys/class/rtc"); + if (!d) + goto fallback; + + for (;;) { + char *p, *v; + struct dirent buf, *de; + int r; + + r = readdir_r(d, &buf, &de); + if (r != 0) + goto fallback; + + if (!de) + goto fallback; + + if (ignore_file(de->d_name)) + continue; + + p = strjoin("/sys/class/rtc/", de->d_name, "/hctosys", NULL); + if (!p) { + closedir(d); + return -ENOMEM; + } + + r = read_one_line_file(p, &v); + free(p); + + if (r < 0) + continue; + + r = parse_boolean(v); + free(v); + + if (r <= 0) + continue; + + p = strappend("/dev/", de->d_name); + fd = open(p, flags); + free(p); + + if (fd >= 0) { + closedir(d); + return fd; + } + } + +fallback: + if (d) + closedir(d); + + fd = open("/dev/rtc0", flags); + if (fd < 0) + return -errno; + + return fd; +} + +int hwclock_get_time(struct tm *tm) { + int fd; + int err = 0; + + assert(tm); + + fd = rtc_open(O_RDONLY|O_CLOEXEC); + if (fd < 0) + return -errno; + + /* This leaves the timezone fields of struct tm + * uninitialized! */ + if (ioctl(fd, RTC_RD_TIME, tm) < 0) + err = -errno; + + /* We don't know daylight saving, so we reset this in order not + * to confused mktime(). */ + tm->tm_isdst = -1; + + close_nointr_nofail(fd); + + return err; +} + +int hwclock_set_time(const struct tm *tm) { + int fd; + int err = 0; + + assert(tm); + + fd = rtc_open(O_RDONLY|O_CLOEXEC); + if (fd < 0) + return -errno; + + if (ioctl(fd, RTC_SET_TIME, tm) < 0) + err = -errno; + + close_nointr_nofail(fd); + + return err; +} + +int hwclock_apply_localtime_delta(int *min) { + const struct timeval *tv_null = NULL; + struct timespec ts; + struct tm *tm; + int minuteswest; + struct timezone tz; + + assert_se(clock_gettime(CLOCK_REALTIME, &ts) == 0); + assert_se(tm = localtime(&ts.tv_sec)); + minuteswest = tm->tm_gmtoff / 60; + + tz.tz_minuteswest = -minuteswest; + tz.tz_dsttime = 0; /* DST_NONE*/ + + /* + * If the hardware clock does not run in UTC, but in local time: + * The very first time we set the kernel's timezone, it will warp + * the clock so that it runs in UTC instead of local time. + */ + if (settimeofday(tv_null, &tz) < 0) + return -errno; + if (min) + *min = minuteswest; + return 0; +} + +int hwclock_reset_localtime_delta(void) { + const struct timeval *tv_null = NULL; + struct timezone tz; + + tz.tz_minuteswest = 0; + tz.tz_dsttime = 0; /* DST_NONE*/ + + if (settimeofday(tv_null, &tz) < 0) + return -errno; + + return 0; +} diff --git a/src/copypaste/hwclock.h b/src/copypaste/hwclock.h new file mode 100644 index 0000000..1092e53 --- /dev/null +++ b/src/copypaste/hwclock.h @@ -0,0 +1,32 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +#ifndef foohwclockhfoo +#define foohwclockhfoo + +/*** + This file is part of systemd. + + Copyright 2010-2012 Lennart Poettering + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include + +int hwclock_apply_localtime_delta(int *min); +int hwclock_reset_localtime_delta(void); +int hwclock_get_time(struct tm *tm); +int hwclock_set_time(const struct tm *tm); + +#endif diff --git a/src/copypaste/macro.h b/src/copypaste/macro.h new file mode 100644 index 0000000..e41b5a7 --- /dev/null +++ b/src/copypaste/macro.h @@ -0,0 +1,186 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +#pragma once + +/*** + This file is part of systemd. + + Copyright 2010 Lennart Poettering + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include + +#include +#include +#include +#include +#include + +#define _printf_attr_(a,b) __attribute__ ((format (printf, a, b))) +#define _sentinel_ __attribute__ ((sentinel)) +#define _noreturn_ __attribute__((noreturn)) +#define _unused_ __attribute__ ((unused)) +#define _destructor_ __attribute__ ((destructor)) +#define _pure_ __attribute__ ((pure)) +#define _const_ __attribute__ ((const)) +#define _deprecated_ __attribute__ ((deprecated)) +#define _packed_ __attribute__ ((packed)) +#define _malloc_ __attribute__ ((malloc)) +#define _weak_ __attribute__ ((weak)) +#define _likely_(x) (__builtin_expect(!!(x),1)) +#define _unlikely_(x) (__builtin_expect(!!(x),0)) +#define _public_ __attribute__ ((visibility("default"))) +#define _hidden_ __attribute__ ((visibility("hidden"))) +#define _weakref_(x) __attribute__((weakref(#x))) +#define _introspect_(x) __attribute__((section("introspect." x))) +#define _alignas_(x) __attribute__((aligned(__alignof(x)))) + +#define XSTRINGIFY(x) #x +#define STRINGIFY(x) XSTRINGIFY(x) + +/* Rounds up */ +#define ALIGN(l) ALIGN_TO((l), sizeof(void*)) +static inline size_t ALIGN_TO(size_t l, size_t ali) { + return ((l + ali - 1) & ~(ali - 1)); +} + +#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0])) + +/* + * container_of - cast a member of a structure out to the containing structure + * @ptr: the pointer to the member. + * @type: the type of the container struct this is embedded in. + * @member: the name of the member within the struct. + * + */ +#define container_of(ptr, type, member) ({ \ + const typeof( ((type *)0)->member ) *__mptr = (ptr); \ + (type *)( (char *)__mptr - offsetof(type,member) );}) + +#ifndef MAX +#define MAX(a,b) \ + __extension__ ({ \ + typeof(a) _a = (a); \ + typeof(b) _b = (b); \ + _a > _b ? _a : _b; \ + }) +#endif + +#define MAX3(a,b,c) \ + MAX(MAX(a,b),c) + +#ifndef MIN +#define MIN(a,b) \ + __extension__ ({ \ + typeof(a) _a = (a); \ + typeof(b) _b = (b); \ + _a < _b ? _a : _b; \ + }) +#endif + +#define MIN3(a,b,c) \ + MIN(MIN(a,b),c) + +#define assert_se(expr) \ + do { \ + if (_unlikely_(!(expr))) \ +/* log_assert_failed(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); */ \ + g_error ("Assertion '%s' failed at %s:%u, function %s(). Aborting.", #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \ + } while (false) \ + +/* We override the glibc assert() here. */ +#undef assert +#ifdef NDEBUG +#define assert(expr) do {} while(false) +#else +#define assert(expr) assert_se(expr) +#endif + +#define assert_not_reached(t) \ + do { \ +/* log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); */ \ + g_error ("Code should not be reached '%s' at %s:%u, function %s(). Aborting.", t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \ + } while (false) + +#define assert_cc(expr) \ + do { \ + switch (0) { \ + case 0: \ + case !!(expr): \ + ; \ + } \ + } while (false) + +#define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p))) +#define UINT_TO_PTR(u) ((void*) ((uintptr_t) (u))) + +#define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p))) +#define UINT32_TO_PTR(u) ((void*) ((uintptr_t) (u))) + +#define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p))) +#define ULONG_TO_PTR(u) ((void*) ((uintptr_t) (u))) + +#define PTR_TO_INT(p) ((int) ((intptr_t) (p))) +#define INT_TO_PTR(u) ((void*) ((intptr_t) (u))) + +#define TO_INT32(p) ((int32_t) ((intptr_t) (p))) +#define INT32_TO_PTR(u) ((void*) ((intptr_t) (u))) + +#define PTR_TO_LONG(p) ((long) ((intptr_t) (p))) +#define LONG_TO_PTR(u) ((void*) ((intptr_t) (u))) + +#define memzero(x,l) (memset((x), 0, (l))) +#define zero(x) (memzero(&(x), sizeof(x))) + +#define char_array_0(x) x[sizeof(x)-1] = 0; + +#define IOVEC_SET_STRING(i, s) \ + do { \ + struct iovec *_i = &(i); \ + char *_s = (char *)(s); \ + _i->iov_base = _s; \ + _i->iov_len = strlen(_s); \ + } while(false) + +static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) { + unsigned j; + size_t r = 0; + + for (j = 0; j < n; j++) + r += i[j].iov_len; + + return r; +} + +static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) { + unsigned j; + + for (j = 0; j < n; j++) { + size_t sub; + + if (_unlikely_(k <= 0)) + break; + + sub = MIN(i[j].iov_len, k); + i[j].iov_len -= sub; + i[j].iov_base = (uint8_t*) i[j].iov_base + sub; + k -= sub; + } + + return k; +} + +/* #include "log.h" */ diff --git a/src/copypaste/util.c b/src/copypaste/util.c new file mode 100644 index 0000000..5375921 --- /dev/null +++ b/src/copypaste/util.c @@ -0,0 +1,279 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2010 Lennart Poettering + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "macro.h" +#include "util.h" + +int saved_argc = 0; +char **saved_argv = NULL; + +usec_t now(clockid_t clock_id) { + struct timespec ts; + + assert_se(clock_gettime(clock_id, &ts) == 0); + + return timespec_load(&ts); +} + +usec_t timespec_load(const struct timespec *ts) { + assert(ts); + + return + (usec_t) ts->tv_sec * USEC_PER_SEC + + (usec_t) ts->tv_nsec / NSEC_PER_USEC; +} + +bool endswith(const char *s, const char *postfix) { + size_t sl, pl; + + assert(s); + assert(postfix); + + sl = strlen(s); + pl = strlen(postfix); + + if (pl == 0) + return true; + + if (sl < pl) + return false; + + return memcmp(s + sl - pl, postfix, pl) == 0; +} + +int close_nointr(int fd) { + assert(fd >= 0); + + for (;;) { + int r; + + r = close(fd); + if (r >= 0) + return r; + + if (errno != EINTR) + return -errno; + } +} + +void close_nointr_nofail(int fd) { + int saved_errno = errno; + + /* like close_nointr() but cannot fail, and guarantees errno + * is unchanged */ + + assert_se(close_nointr(fd) == 0); + + errno = saved_errno; +} + +int parse_boolean(const char *v) { + assert(v); + + if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on")) + return 1; + else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off")) + return 0; + + return -EINVAL; +} + +int read_one_line_file(const char *fn, char **line) { + FILE *f; + int r; + char t[LINE_MAX], *c; + + assert(fn); + assert(line); + + f = fopen(fn, "re"); + if (!f) + return -errno; + + if (!fgets(t, sizeof(t), f)) { + + if (ferror(f)) { + r = -errno; + goto finish; + } + + t[0] = 0; + } + + c = strdup(t); + if (!c) { + r = -ENOMEM; + goto finish; + } + + truncate_nl(c); + + *line = c; + r = 0; + +finish: + fclose(f); + return r; +} + +char *truncate_nl(char *s) { + assert(s); + + s[strcspn(s, NEWLINE)] = 0; + return s; +} + +char *strnappend(const char *s, const char *suffix, size_t b) { + size_t a; + char *r; + + if (!s && !suffix) + return strdup(""); + + if (!s) + return strndup(suffix, b); + + if (!suffix) + return strdup(s); + + assert(s); + assert(suffix); + + a = strlen(s); + + if (!(r = new(char, a+b+1))) + return NULL; + + memcpy(r, s, a); + memcpy(r+a, suffix, b); + r[a+b] = 0; + + return r; +} + +char *strappend(const char *s, const char *suffix) { + return strnappend(s, suffix, suffix ? strlen(suffix) : 0); +} + +bool ignore_file(const char *filename) { + assert(filename); + + return + filename[0] == '.' || + streq(filename, "lost+found") || + streq(filename, "aquota.user") || + streq(filename, "aquota.group") || + endswith(filename, "~") || + endswith(filename, ".rpmnew") || + endswith(filename, ".rpmsave") || + endswith(filename, ".rpmorig") || + endswith(filename, ".dpkg-old") || + endswith(filename, ".dpkg-new") || + endswith(filename, ".swp"); +} + +char *strjoin(const char *x, ...) { + va_list ap; + size_t l; + char *r, *p; + + va_start(ap, x); + + if (x) { + l = strlen(x); + + for (;;) { + const char *t; + + t = va_arg(ap, const char *); + if (!t) + break; + + l += strlen(t); + } + } else + l = 0; + + va_end(ap); + + r = new(char, l+1); + if (!r) + return NULL; + + if (x) { + p = stpcpy(r, x); + + va_start(ap, x); + + for (;;) { + const char *t; + + t = va_arg(ap, const char *); + if (!t) + break; + + p = stpcpy(p, t); + } + + va_end(ap); + } else + r[0] = 0; + + return r; +} diff --git a/src/copypaste/util.h b/src/copypaste/util.h new file mode 100644 index 0000000..c3b8dcf --- /dev/null +++ b/src/copypaste/util.h @@ -0,0 +1,110 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +#pragma once + +/*** + This file is part of systemd. + + Copyright 2010 Lennart Poettering + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see . +***/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "macro.h" + +typedef uint64_t usec_t; +typedef uint64_t nsec_t; + +typedef struct dual_timestamp { + usec_t realtime; + usec_t monotonic; +} dual_timestamp; + +#define MSEC_PER_SEC 1000ULL +#define USEC_PER_SEC 1000000ULL +#define USEC_PER_MSEC 1000ULL +#define NSEC_PER_SEC 1000000000ULL +#define NSEC_PER_MSEC 1000000ULL +#define NSEC_PER_USEC 1000ULL + +#define USEC_PER_MINUTE (60ULL*USEC_PER_SEC) +#define NSEC_PER_MINUTE (60ULL*NSEC_PER_SEC) +#define USEC_PER_HOUR (60ULL*USEC_PER_MINUTE) +#define NSEC_PER_HOUR (60ULL*NSEC_PER_MINUTE) +#define USEC_PER_DAY (24ULL*USEC_PER_HOUR) +#define NSEC_PER_DAY (24ULL*NSEC_PER_HOUR) +#define USEC_PER_WEEK (7ULL*USEC_PER_DAY) +#define NSEC_PER_WEEK (7ULL*NSEC_PER_DAY) +#define USEC_PER_MONTH (2629800ULL*USEC_PER_SEC) +#define NSEC_PER_MONTH (2629800ULL*NSEC_PER_SEC) +#define USEC_PER_YEAR (31557600ULL*USEC_PER_SEC) +#define NSEC_PER_YEAR (31557600ULL*NSEC_PER_SEC) + +/* What is interpreted as whitespace? */ +#define WHITESPACE " \t\n\r" +#define NEWLINE "\n\r" +#define QUOTES "\"\'" +#define COMMENTS "#;\n" + +usec_t now(clockid_t clock); + +usec_t timespec_load(const struct timespec *ts); + +#define streq(a,b) (strcmp((a),(b)) == 0) +#define strneq(a, b, n) (strncmp((a), (b), (n)) == 0) + +#define new(t, n) ((t*) malloc(sizeof(t)*(n))) + +#define new0(t, n) ((t*) calloc((n), sizeof(t))) + +#define newa(t, n) ((t*) alloca(sizeof(t)*(n))) + +#define newdup(t, p, n) ((t*) memdup(p, sizeof(t)*(n))) + +#define malloc0(n) (calloc((n), 1)) + +int close_nointr(int fd); +void close_nointr_nofail(int fd); +void close_many(const int fds[], unsigned n_fd); + +int parse_boolean(const char *v); + +int read_one_line_file(const char *fn, char **line); + +char *strappend(const char *s, const char *suffix); +char *strnappend(const char *s, const char *suffix, size_t length); + +char *strstrip(char *s); +char *truncate_nl(char *s); + +bool ignore_file(const char *filename); + +char *strjoin(const char *x, ...) _sentinel_; + +extern int saved_argc; +extern char **saved_argv; diff --git a/src/main.c b/src/main.c index 887cccd..b7d6324 100644 --- a/src/main.c +++ b/src/main.c @@ -24,6 +24,7 @@ #include "hostnamed.h" #include "localed.h" +#include "timedated.h" #include "shell-utils.h" #include "config.h" @@ -32,11 +33,13 @@ static gboolean debug = FALSE; static gboolean read_only = FALSE; +static gchar *ntp_preferred_service = NULL; static GOptionEntry option_entries[] = { { "debug", 0, 0, G_OPTION_ARG_NONE, &debug, "Enable debugging messages", NULL }, { "read-only", 0, 0, G_OPTION_ARG_NONE, &read_only, "Run in read-only mode", NULL }, + { "ntp-service", 0, 0, G_OPTION_ARG_STRING, &ntp_preferred_service, "Preferred rc NTP service for timedated", NULL }, { NULL } }; @@ -76,12 +79,15 @@ main (gint argc, gchar *argv[]) shell_utils_init (); hostnamed_init (read_only); localed_init (read_only); + timedated_init (read_only, ntp_preferred_service); loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (loop); g_main_loop_unref (loop); + timedated_destroy (); localed_destroy (); hostnamed_destroy (); shell_utils_destroy (); + g_free (ntp_preferred_service); return 0; } diff --git a/src/timedated.c b/src/timedated.c new file mode 100644 index 0000000..bb16cf0 --- /dev/null +++ b/src/timedated.c @@ -0,0 +1,729 @@ +/* + Copyright 2012 Alexandre Rostovtsev + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include "copypaste/hwclock.h" +#include "timedated.h" +#include "timedate1-generated.h" +#include "bus-utils.h" +#include "shell-utils.h" + +#include "config.h" + +#define SERVICE_NAME "openrc-settingsd timedated" + +static guint bus_id = 0; +static gboolean read_only = FALSE; + +static OpenrcSettingsdTimedatedTimedate1 *timedate1 = NULL; + +static GFile *hwclock_file = NULL; +static GFile *timezone_file = NULL; +static GFile *localtime_file = NULL; + +gboolean local_rtc = FALSE; +gchar *timezone_name = NULL; +G_LOCK_DEFINE_STATIC (clock); + +gboolean use_ntp = FALSE; +static const gchar *ntp_preferred_service = NULL; +static const gchar *ntp_default_services[4] = { "ntpd", "chronyd", "busybox-ntpd", NULL }; +G_LOCK_DEFINE_STATIC (ntp); + +static gboolean +get_local_rtc (GError **error) +{ + gchar *clock = NULL; + gboolean ret = FALSE; + + clock = shell_utils_source_var (hwclock_file, "${clock}", error); + if (!g_strcmp0 (clock, "local")) + ret = TRUE; + return ret; +} + +static gchar * +get_timezone_name (GError **error) +{ + gchar *filebuf = NULL, *filebuf2 = NULL, *ret = NULL, *newline = NULL, *filename = NULL; + gchar *timezone_filename = NULL, *localtime_filename = NULL, *localtime2_filename = NULL; + GFile *localtime2_file = NULL; + + timezone_filename = g_file_get_path (timezone_file); + if (!g_file_load_contents (timezone_file, NULL, &filebuf, NULL, NULL, error)) { + g_prefix_error (error, "Unable to read '%s':", timezone_filename); + ret = g_strdup (""); + goto out; + } + if ((newline = strstr (filebuf, "\n")) != NULL) + *newline = 0; + ret = g_strdup (g_strstrip (filebuf)); + g_free (filebuf); + filebuf = NULL; + + /* Log if /etc/localtime is not up to date */ + localtime_filename = g_file_get_path (localtime_file); + localtime2_filename = g_strdup_printf (DATADIR "/zoneinfo/%s", ret); + localtime2_file = g_file_new_for_path (localtime2_filename); + + if (!g_file_load_contents (localtime_file, NULL, &filebuf, NULL, NULL, error)) { + g_prefix_error (error, "Unable to read '%s':", localtime_filename); + goto out; + } + if (!g_file_load_contents (localtime2_file, NULL, &filebuf2, NULL, NULL, error)) { + g_prefix_error (error, "Unable to read '%s':", localtime2_filename); + goto out; + } + if (g_strcmp0 (filebuf, filebuf2)) + g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s and %s differ; %s may be outdated or out of sync with %s", localtime_filename, localtime2_filename, localtime_filename, timezone_filename); + + out: + g_free (filebuf); + g_free (filebuf2); + g_free (timezone_filename); + g_free (localtime_filename); + g_free (localtime2_filename); + if (localtime_file != NULL) + g_object_unref (localtime2_file); + return ret; +} + +static gboolean +set_timezone (const gchar *_timezone_name, + GError **error) +{ + gchar *filebuf = NULL; + gchar *timezone_filename = NULL, *localtime_filename = NULL, *localtime2_filename = NULL; + GFile *localtime2_file = NULL; + gboolean ret = FALSE; + gsize length = 0; + + timezone_filename = g_file_get_path (timezone_file); + if (!g_file_replace_contents (timezone_file, _timezone_name, strlen (_timezone_name), NULL, FALSE, 0, NULL, NULL, error)) { + g_prefix_error (error, "Unable to write '%s':", timezone_filename); + goto out; + } + + localtime_filename = g_file_get_path (localtime_file); + localtime2_filename = g_strdup_printf (DATADIR "/zoneinfo/%s", _timezone_name); + localtime2_file = g_file_new_for_path (localtime2_filename); + if (!g_file_load_contents (localtime2_file, NULL, &filebuf, &length, NULL, error)) { + g_prefix_error (error, "Unable to read '%s':", localtime2_filename); + goto out; + } + if (!g_file_replace_contents (localtime_file, filebuf, length, NULL, FALSE, 0, NULL, NULL, error)) { + g_prefix_error (error, "Unable to write '%s':", localtime_filename); + goto out; + } + ret = TRUE; + + out: + g_free (filebuf); + g_free (timezone_filename); + g_free (localtime_filename); + g_free (localtime2_filename); + if (localtime_file != NULL) + g_object_unref (localtime2_file); + return ret; +} + +/* Return the ntp rc service we will use; return value should NOT be freed */ +static const gchar * +ntp_service () +{ + const gchar * const *s = NULL; + const gchar *service = NULL; + gchar *runlevel = NULL; + + if (ntp_preferred_service != NULL) + return ntp_preferred_service; + + runlevel = rc_runlevel_get(); + for (s = ntp_default_services; *s != NULL; s++) { + if (!rc_service_exists (*s)) + continue; + if (service == NULL) + service = *s; + if (rc_service_in_runlevel (*s, runlevel)) { + service = *s; + break; + } + } + free (runlevel); + + if (service == NULL) + service = ntp_default_services[0]; + return service; +} + +static gboolean +service_started (const gchar *service, + GError **error) +{ + RC_SERVICE state; + + if (!rc_service_exists (service)) { + g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "%s rc service not found", service); + return FALSE; + } + + state = rc_service_state (service); + return state == RC_SERVICE_STARTED || state == RC_SERVICE_STARTING || state == RC_SERVICE_INACTIVE; +} + +static gboolean +service_disable (const gchar *service, + GError **error) +{ + gchar *runlevel = NULL; + gchar *service_script = NULL; + const gchar *argv[3] = { NULL, "stop", NULL }; + gboolean ret = FALSE; + gint exit_status = 0; + + if (!rc_service_exists (service)) { + g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "%s rc service not found", service); + goto out; + } + + runlevel = rc_runlevel_get(); + if (rc_service_in_runlevel (service, runlevel)) { + g_debug ("Removing %s rc service from %s runlevel", service, runlevel); + if (!rc_service_delete (runlevel, service)) + g_warning ("Failed to remove %s rc service from %s runlevel", service, runlevel); + } + + if ((service_script = rc_service_resolve (service)) == NULL) { + g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "%s rc service does not resolve", service); + goto out; + } + + g_debug ("Stopping %s rc service", service); + argv[0] = service; + if (!g_spawn_sync (NULL, (gchar **)argv, NULL, 0, NULL, NULL, NULL, NULL, &exit_status, error)) { + g_prefix_error (error, "Failed to spawn %s rc service:", service); + goto out; + } + if (exit_status) { + g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, "%s rc service failed to stop with exit status %d", service, exit_status); + goto out; + } + ret = TRUE; + + out: + if (runlevel != NULL) + free (runlevel); + if (service_script != NULL) + free (service_script); + return ret; +} + +static gboolean +service_enable (const gchar *service, + GError **error) +{ + gchar *runlevel = NULL; + gchar *service_script = NULL; + const gchar *argv[3] = { NULL, "start", NULL }; + gboolean ret = FALSE; + gint exit_status = 0; + + if (!rc_service_exists (service)) { + g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "%s rc service not found", service); + goto out; + } + + runlevel = rc_runlevel_get(); + if (!rc_service_in_runlevel (service, runlevel)) { + g_debug ("Adding %s rc service to %s runlevel", service, runlevel); + if (!rc_service_add (runlevel, service)) + g_warning ("Failed to add %s rc service to %s runlevel", service, runlevel); + } + + if ((service_script = rc_service_resolve (service)) == NULL) { + g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "%s rc service does not resolve", service); + goto out; + } + + g_debug ("Starting %s rc service", service); + argv[0] = service; + if (!g_spawn_sync (NULL, (gchar **)argv, NULL, 0, NULL, NULL, NULL, NULL, &exit_status, error)) { + g_prefix_error (error, "Failed to spawn %s rc service:", service); + goto out; + } + if (exit_status) { + g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, "%s rc service failed to start with exit status %d", service, exit_status); + goto out; + } + ret = TRUE; + + out: + if (runlevel != NULL) + free (runlevel); + if (service_script != NULL) + free (service_script); + return ret; +} + +struct invoked_set_time { + GDBusMethodInvocation *invocation; + gint64 usec_utc; + gboolean relative; +}; + +static void +on_handle_set_time_authorized_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + GError *err = NULL; + struct invoked_set_time *data; + struct timespec ts = { 0, 0 }; + struct tm *tm = NULL; + + data = (struct invoked_set_time *) user_data; + if (!check_polkit_finish (res, &err)) { + g_dbus_method_invocation_return_gerror (data->invocation, err); + goto out; + } + + G_LOCK (clock); + if (!data->relative && data->usec_utc < 0) { + g_dbus_method_invocation_return_dbus_error (data->invocation, DBUS_ERROR_INVALID_ARGS, "Attempt to set time before epoch"); + goto unlock; + } + + if (data->relative) + if (clock_gettime (CLOCK_REALTIME, &ts)) { + int errsv = errno; + g_dbus_method_invocation_return_dbus_error (data->invocation, DBUS_ERROR_FAILED, strerror (errsv)); + goto unlock; + } + ts.tv_sec += data->usec_utc / 1000000; + ts.tv_nsec += (data->usec_utc % 1000000) * 1000; + if (clock_settime (CLOCK_REALTIME, &ts)) { + int errsv = errno; + g_dbus_method_invocation_return_dbus_error (data->invocation, DBUS_ERROR_FAILED, strerror (errsv)); + goto unlock; + } + + if (local_rtc) + tm = localtime(&ts.tv_sec); + else + tm = gmtime(&ts.tv_sec); + hwclock_set_time(tm); + + openrc_settingsd_timedated_timedate1_complete_set_time (timedate1, data->invocation); + + unlock: + G_UNLOCK (clock); + + out: + g_free (data); + if (err != NULL) + g_error_free (err); +} + +static gboolean +on_handle_set_time (OpenrcSettingsdTimedatedTimedate1 *timedate1, + GDBusMethodInvocation *invocation, + const gint64 usec_utc, + const gboolean relative, + const gboolean user_interaction, + gpointer user_data) +{ + if (read_only) + g_dbus_method_invocation_return_dbus_error (invocation, + DBUS_ERROR_NOT_SUPPORTED, + SERVICE_NAME " is in read-only mode"); + else { + struct invoked_set_time *data; + data = g_new0 (struct invoked_set_time, 1); + data->invocation = invocation; + data->usec_utc = usec_utc; + data->relative = relative; + check_polkit_async (g_dbus_method_invocation_get_sender (invocation), "org.freedesktop.timedate1.set-time", user_interaction, on_handle_set_time_authorized_cb, data); + } + + return TRUE; +} + +struct invoked_set_timezone { + GDBusMethodInvocation *invocation; + gchar *timezone; /* newly allocated */ +}; + +static void +on_handle_set_timezone_authorized_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + GError *err = NULL; + struct invoked_set_timezone *data; + + data = (struct invoked_set_timezone *) user_data; + if (!check_polkit_finish (res, &err)) { + g_dbus_method_invocation_return_gerror (data->invocation, err); + goto out; + } + + G_LOCK (clock); + if (!set_timezone(data->timezone, &err)) { + g_dbus_method_invocation_return_gerror (data->invocation, err); + goto unlock; + } + + if (local_rtc) { + struct timespec ts; + struct tm *tm; + + /* Update kernel's view of the rtc timezone */ + hwclock_apply_localtime_delta (NULL); + clock_gettime (CLOCK_REALTIME, &ts); + tm = localtime (&ts.tv_sec); + hwclock_set_time (tm); + } + + openrc_settingsd_timedated_timedate1_complete_set_timezone (timedate1, data->invocation); + g_free (timezone_name); + timezone_name = data->timezone; + openrc_settingsd_timedated_timedate1_set_timezone (timedate1, timezone_name); + + unlock: + G_UNLOCK (clock); + + out: + g_free (data); + if (err != NULL) + g_error_free (err); +} + +static gboolean +on_handle_set_timezone (OpenrcSettingsdTimedatedTimedate1 *timedate1, + GDBusMethodInvocation *invocation, + const gchar *timezone, + const gboolean user_interaction, + gpointer user_data) +{ + if (read_only) + g_dbus_method_invocation_return_dbus_error (invocation, + DBUS_ERROR_NOT_SUPPORTED, + SERVICE_NAME " is in read-only mode"); + else { + struct invoked_set_timezone *data; + data = g_new0 (struct invoked_set_timezone, 1); + data->invocation = invocation; + data->timezone = g_strdup (timezone); + check_polkit_async (g_dbus_method_invocation_get_sender (invocation), "org.freedesktop.timedate1.set-timezone", user_interaction, on_handle_set_timezone_authorized_cb, data); + } + + return TRUE; +} + +struct invoked_set_local_rtc { + GDBusMethodInvocation *invocation; + gboolean local_rtc; + gboolean fix_system; +}; + +static void +on_handle_set_local_rtc_authorized_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + GError *err = NULL; + struct invoked_set_local_rtc *data; + gchar *clock = NULL; + const gchar *clock_types[2] = { "UTC", "local" }; + + data = (struct invoked_set_local_rtc *) user_data; + if (!check_polkit_finish (res, &err)) { + g_dbus_method_invocation_return_gerror (data->invocation, err); + goto out; + } + + G_LOCK (clock); + clock = shell_utils_source_var (hwclock_file, "${clock}", NULL); + if (clock != NULL || data->local_rtc) + if (!shell_utils_trivial_set_and_save (hwclock_file, &err, "clock", NULL, clock_types[data->local_rtc], NULL)) { + g_dbus_method_invocation_return_gerror (data->invocation, err); + goto unlock; + } + + if (data->local_rtc != local_rtc) { + /* The clock sync code below taken almost verbatim from systemd's timedated.c, and is + * copyright 2011 Lennart Poettering */ + struct timespec ts; + + /* Update kernel's view of the rtc timezone */ + if (data->local_rtc) + hwclock_apply_localtime_delta (NULL); + else + hwclock_reset_localtime_delta (); + + clock_gettime (CLOCK_REALTIME, &ts); + if (data->fix_system) { + struct tm tm; + + /* Sync system clock from RTC; first, + * initialize the timezone fields of + * struct tm. */ + if (data->local_rtc) + tm = *localtime(&ts.tv_sec); + else + tm = *gmtime(&ts.tv_sec); + + /* Override the main fields of + * struct tm, but not the timezone + * fields */ + if (hwclock_get_time(&tm) >= 0) { + /* And set the system clock + * with this */ + if (data->local_rtc) + ts.tv_sec = mktime(&tm); + else + ts.tv_sec = timegm(&tm); + + clock_settime(CLOCK_REALTIME, &ts); + } + + } else { + struct tm *tm; + + /* Sync RTC from system clock */ + if (data->local_rtc) + tm = localtime(&ts.tv_sec); + else + tm = gmtime(&ts.tv_sec); + + hwclock_set_time(tm); + } + } + + openrc_settingsd_timedated_timedate1_complete_set_timezone (timedate1, data->invocation); + g_free (timezone_name); + local_rtc = data->local_rtc; + openrc_settingsd_timedated_timedate1_set_local_rtc (timedate1, local_rtc); + + unlock: + G_UNLOCK (clock); + + out: + g_free (clock); + g_free (data); + if (err != NULL) + g_error_free (err); +} + +static gboolean +on_handle_set_local_rtc (OpenrcSettingsdTimedatedTimedate1 *timedate1, + GDBusMethodInvocation *invocation, + const gboolean _local_rtc, + const gboolean fix_system, + const gboolean user_interaction, + gpointer user_data) +{ + if (read_only) + g_dbus_method_invocation_return_dbus_error (invocation, + DBUS_ERROR_NOT_SUPPORTED, + SERVICE_NAME " is in read-only mode"); + else { + struct invoked_set_local_rtc *data; + data = g_new0 (struct invoked_set_local_rtc, 1); + data->local_rtc = _local_rtc; + data->fix_system = fix_system; + check_polkit_async (g_dbus_method_invocation_get_sender (invocation), "org.freedesktop.timedate1.set-local-rtc", user_interaction, on_handle_set_local_rtc_authorized_cb, data); + } + + return TRUE; +} + +struct invoked_set_ntp { + GDBusMethodInvocation *invocation; + gboolean use_ntp; +}; + +static void +on_handle_set_ntp_authorized_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + GError *err = NULL; + struct invoked_set_ntp *data; + + data = (struct invoked_set_ntp *) user_data; + if (!check_polkit_finish (res, &err)) { + g_dbus_method_invocation_return_gerror (data->invocation, err); + goto out; + } + + G_LOCK (ntp); + if ((data->use_ntp && !service_enable (ntp_service(), &err)) || + (!data->use_ntp && !service_disable (ntp_service(), &err))) + { + g_dbus_method_invocation_return_gerror (data->invocation, err); + goto unlock; + } + + openrc_settingsd_timedated_timedate1_complete_set_ntp (timedate1, data->invocation); + use_ntp = data->use_ntp; + openrc_settingsd_timedated_timedate1_set_ntp (timedate1, use_ntp); + + unlock: + G_UNLOCK (ntp); + + out: + g_free (data); + if (err != NULL) + g_error_free (err); +} + +static gboolean +on_handle_set_ntp (OpenrcSettingsdTimedatedTimedate1 *timedate1, + GDBusMethodInvocation *invocation, + const gboolean _use_ntp, + const gboolean user_interaction, + gpointer user_data) +{ + if (read_only) + g_dbus_method_invocation_return_dbus_error (invocation, + DBUS_ERROR_NOT_SUPPORTED, + SERVICE_NAME " is in read-only mode"); + else { + struct invoked_set_ntp *data; + data = g_new0 (struct invoked_set_ntp, 1); + data->use_ntp = _use_ntp; + check_polkit_async (g_dbus_method_invocation_get_sender (invocation), "org.freedesktop.timedate1.set-ntp", user_interaction, on_handle_set_ntp_authorized_cb, data); + } + + return TRUE; +} + +static void +on_bus_acquired (GDBusConnection *connection, + const gchar *bus_name, + gpointer user_data) +{ + gchar *name; + GError *err = NULL; + + g_debug ("Acquired a message bus connection"); + + timedate1 = openrc_settingsd_timedated_timedate1_skeleton_new (); + + openrc_settingsd_timedated_timedate1_set_timezone (timedate1, timezone_name); + openrc_settingsd_timedated_timedate1_set_local_rtc (timedate1, local_rtc); + openrc_settingsd_timedated_timedate1_set_ntp (timedate1, use_ntp); + + g_signal_connect (timedate1, "handle-set-time", G_CALLBACK (on_handle_set_time), NULL); + g_signal_connect (timedate1, "handle-set-timezone", G_CALLBACK (on_handle_set_timezone), NULL); + g_signal_connect (timedate1, "handle-set-local-rtc", G_CALLBACK (on_handle_set_local_rtc), NULL); + g_signal_connect (timedate1, "handle-set-ntp", G_CALLBACK (on_handle_set_ntp), NULL); + + if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (timedate1), + connection, + "/org/freedesktop/timedate1", + &err)) { + if (err != NULL) { + g_printerr ("Failed to export interface on /org/freedesktop/timedate1: %s\n", err->message); + g_error_free (err); + } + } +} + +static void +on_name_acquired (GDBusConnection *connection, + const gchar *bus_name, + gpointer user_data) +{ + g_debug ("Acquired the name %s", bus_name); +} + +static void +on_name_lost (GDBusConnection *connection, + const gchar *bus_name, + gpointer user_data) +{ + if (connection == NULL) + g_printerr ("Failed to acquire a dbus connection\n"); + else + g_printerr ("Failed to acquire dbus name %s\n", bus_name); + exit(-1); +} + +void +timedated_init (gboolean _read_only, + const gchar *_ntp_preferred_service) +{ + GError *err = NULL; + + read_only = _read_only; + ntp_preferred_service = _ntp_preferred_service; + + hwclock_file = g_file_new_for_path (SYSCONFDIR "/conf.d/hwclock"); + timezone_file = g_file_new_for_path (SYSCONFDIR "/timezone"); + localtime_file = g_file_new_for_path (SYSCONFDIR "/localtime"); + + local_rtc = get_local_rtc (&err); + if (err != NULL) { + g_debug ("%s", err->message); + g_clear_error (&err); + } + timezone_name = get_timezone_name (&err); + if (err != NULL) { + g_warning ("%s", err->message); + g_clear_error (&err); + } + use_ntp = service_started (ntp_service (), &err); + if (err != NULL) { + g_warning ("%s", err->message); + g_clear_error (&err); + } + + bus_id = g_bus_own_name (G_BUS_TYPE_SYSTEM, + "org.freedesktop.timedate1", + G_BUS_NAME_OWNER_FLAGS_NONE, + on_bus_acquired, + on_name_acquired, + on_name_lost, + NULL, + NULL); +} + +void +timedated_destroy (void) +{ + g_bus_unown_name (bus_id); + bus_id = 0; + read_only = FALSE; + ntp_preferred_service = NULL; + + g_object_unref (hwclock_file); + g_object_unref (timezone_file); + g_object_unref (localtime_file); +} diff --git a/src/timedated.h b/src/timedated.h new file mode 100644 index 0000000..b7282b2 --- /dev/null +++ b/src/timedated.h @@ -0,0 +1,31 @@ +/* + Copyright 2012 Alexandre Rostovtsev + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef OPENRC_TIMEDATED_H +#define OPENRC_TIMEDATED_H + +#include + +void +timedated_init (gboolean read_only, + const gchar *_ntp_preferred_service); + +void +timedated_destroy (void); + +#endif -- cgit v1.2.3-65-gdbad