[systembsd.git] / src / interfaces / timedated / timedated.c

/*
 * Copyright (c) 2014 Ian Sutton <ian@kremlin.cc>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <unistd.h>
#include <limits.h>
#include <signal.h>

#include <sys/types.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <errno.h>
#include <time.h>
#include <string.h>
#include <tzfile.h>

#include <glib/gprintf.h>
#include <glib-unix.h>
#include <glib/gstdio.h>
#include <polkit/polkit.h>

#include "timedated-gen.h"
#include "timedated.h"

#include "../../util.h"

#define TZNAME_MAX PATH_MAX

GPtrArray *timedated_freeable;
Timedate1 *timedated_interf;

GMainLoop *timedated_loop;

guint bus_descriptor;
gboolean dbus_interface_exported; /* reliable because of gdbus operational guarantees */

const gchar *OS_LOCALTIME       = "/etc/localtime";      /* current timezone file */
const gchar *OS_TIMEZONE_PATH   = "/usr/share/zoneinfo"; /* path to system timezone files */

struct timezone_checksum_pair {

    gchar *path;
    gchar *sum;
    gboolean posix;
    gboolean right;
};

static struct timezone_checksum_pair tz_table[5000];

/* --- begin method/property/dbus signal code --- */

static gboolean
on_handle_set_time(Timedate1 *td1_passed_interf,
                   GDBusMethodInvocation *invoc,
                   const gchar *greet,
                   gpointer data) {

    GVariant *params;
    gint64 proposed_time, cur_time;
    const gchar *bus_name;
    gboolean policykit_auth;
    check_auth_result is_authed;
    gboolean relative; /* relative if passed time_t is meant to be added to current time */
    struct timespec *new_time;

    params = g_dbus_method_invocation_get_parameters(invoc);
    g_variant_get(params, "(xbb)", &proposed_time, &relative, &policykit_auth);
    bus_name = g_dbus_method_invocation_get_sender(invoc);

    is_authed = polkit_try_auth(bus_name, "org.freedesktop.timedate1.set-time", policykit_auth);

    switch(is_authed) {

        case AUTHORIZED_NATIVELY:
        case AUTHORIZED_BY_PROMPT:
            break;

        case UNAUTHORIZED_NATIVELY:
        case UNAUTHORIZED_FAILED_PROMPT:
            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EACCES", "Insufficient permissions to set system time.");
            return FALSE;

        case ERROR_BADBUS:
            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EFAULT", "Provided bus name is invalid.");
            return FALSE;

        case ERROR_BADACTION:
            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EFAULT", "Provided action ID is invalid.");
            return FALSE;

        case ERROR_GENERIC:
        default:
            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ECANCELED", "Failed to set system time for unknown reasons.");
            return FALSE;
    }

    if(!proposed_time) {
        
        timedate1_complete_set_time(td1_passed_interf, invoc);
        return TRUE;

    } else if(relative) {

        cur_time = g_get_real_time();

        if(proposed_time < 0 && cur_time + proposed_time > cur_time) {

            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EINVAL", "Resultant time out of bounds.");
            return FALSE;

        } else if(proposed_time > 0 && cur_time + proposed_time < cur_time) {

            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EINVAL", "Resultant time out of bounds.");
            return FALSE;
        }

        new_time = mktimespec(proposed_time);

        if(!clock_settime(CLOCK_REALTIME, new_time)) {

            timedate1_complete_set_time(td1_passed_interf, invoc);
            return TRUE;

        } else {

            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ECANCELED", "Failed to set system time for unknown reasons.");
            return FALSE;
        }

    } else if(proposed_time > 0) {


        new_time = mktimespec(proposed_time);

        if(!clock_settime(CLOCK_REALTIME, new_time)) {

            timedate1_complete_set_time(td1_passed_interf, invoc);
            return TRUE;

        } else {

            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ECANCELED", "Failed to set system time for unknown reasons.");
            return FALSE;
        }

    } else {

        g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EINVAL", "Resultant time out of bounds.");
        return FALSE;
    }
}

static gboolean
on_handle_set_timezone(Timedate1 *td1_passed_interf,
                   GDBusMethodInvocation *invoc,
                   const gchar *greet,
                   gpointer data) {

    GVariant *params;
    gchar *proposed_tz;
    const gchar *bus_name;
    gboolean policykit_auth;
    check_auth_result is_authed;

    gchar *tz_target_path;
    struct stat *statbuf;
    extern int errno;

    params = g_dbus_method_invocation_get_parameters(invoc);
    g_variant_get(params, "(sb)", &proposed_tz, &policykit_auth);
    bus_name = g_dbus_method_invocation_get_sender(invoc);

    is_authed = polkit_try_auth(bus_name, "org.freedesktop.timedate1.set-timezone", policykit_auth);

    switch(is_authed) {

        case AUTHORIZED_NATIVELY:
        case AUTHORIZED_BY_PROMPT:
            break;

        case UNAUTHORIZED_NATIVELY:
        case UNAUTHORIZED_FAILED_PROMPT:
            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EACCES", "Insufficient permissions to set timezone.");
            return FALSE;

        case ERROR_BADBUS:
            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EFAULT", "Provided bus name is invalid.");
            return FALSE;

        case ERROR_BADACTION:
            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EFAULT", "Provided action ID is invalid.");
            return FALSE;

        case ERROR_GENERIC:
        default:
            g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ECANCELED", "Failed to set timezone for unknown reasons.");
            return FALSE;
    }

    statbuf        = (struct stat*) calloc(1, sizeof(struct stat));
    tz_target_path = (gchar *) calloc(1, TZNAME_MAX);

    g_ptr_array_add(timedated_freeable, statbuf);
    g_ptr_array_add(timedated_freeable, tz_target_path);

    strlcat(tz_target_path, TZDIR, TZNAME_MAX);
    strlcat(tz_target_path, "/", TZNAME_MAX);
    strlcat(tz_target_path, proposed_tz, TZNAME_MAX);

    if(strstr(tz_target_path, "../")) {

        g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EBADF", "Provided timezone is invalid.");
        return FALSE;
    }

    if(!statbuf)
        return FALSE;

    if(lstat(tz_target_path, statbuf)) {

        switch(errno) {

            case ENOENT:
                g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ENOENT", "Specified timezone does not exist.");
                break;

            default:
                g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EBADF", "Specified timezone is invalid.");
                break;
        }

        return FALSE;
    }
    
    if(!S_ISREG(statbuf->st_mode)) {

        g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EBADF", "Specified path is of an inappropriate type.");
        return FALSE;
    }

    memset(statbuf, 0, sizeof statbuf);

    if(!lstat(TZDEFAULT, statbuf))
        if(remove(TZDEFAULT))
            return FALSE;

    if(symlink(tz_target_path, TZDEFAULT))
        return FALSE;

    
    timedate1_complete_set_timezone(td1_passed_interf, invoc);

    return TRUE;
}

static gboolean
on_handle_set_local_rtc(Timedate1 *td1_passed_interf,
                        GDBusMethodInvocation *invoc,
                        const gchar *greet,
                        gpointer data) {

    g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ENODEV", "OpenBSD does not support setting the realtime clock in local time, only UTC.");
    return TRUE;
}

static gboolean
on_handle_set_ntp(Timedate1 *td1_passed_interf,
                  GDBusMethodInvocation *invoc,
                  const gchar *greet,
                  gpointer data) {
    return FALSE;
}

const gchar *
our_get_timezone() {

    GStatBuf *stat_zoneinfo;
    gchar *find_cmd, *readlink_path, *ret, *argvp, *hash_to_match;
    gint argcp;
    GError *err;
    struct timezone_checksum_pair tmp;

    find_cmd      = (gchar *)    g_malloc0(2048);
    stat_zoneinfo = (GStatBuf *) g_malloc0(8192);
    err           = (GError *)   g_malloc0(2048);

    if(g_stat(OS_LOCALTIME, stat_zoneinfo)) {

        g_printf("could not read from %s! please symlink or copy a timezone file from %s to %s!\n", OS_LOCALTIME, OS_TIMEZONE_PATH, OS_LOCALTIME);
        ret = NULL;

    } else if(g_file_test(OS_LOCALTIME, G_FILE_TEST_IS_SYMLINK)) {

        readlink_path = g_file_read_link(OS_LOCALTIME, &err);

        gchar *split[2] = { readlink_path, "" };
        tmp = parse_timezone_path(split);

        ret = tmp.path;

        if(readlink_path)
            g_free(readlink_path);

    } else {

        g_printf("%s is not a symlink! attempting to match checksums in %s...\n", OS_LOCALTIME, OS_TIMEZONE_PATH);
        hash_to_match = get_file_sha256(OS_LOCALTIME);

        /* ret = lookup_hash(hash_to_match); */
        return FALSE; /* TODO fix me for real */

        if(hash_to_match)
            g_free(hash_to_match);
    }

    
    return ret;
}

/* openbsd does not support setting the RTC to localtime, only UTC */
gboolean
our_get_local_rtc() { 

    gboolean ret = FALSE;

    return ret;
}

gboolean
our_get_can_ntp() {
 
    const gboolean ret = FALSE;

    return ret;
}

gboolean
our_get_ntp() {
 
    const gboolean ret = FALSE;

    return ret;
}

gboolean
our_get_ntpsynchronized() {
 
    const gboolean ret = FALSE;

    return ret;
}

guint64
our_get_time_usec() {

    guint64 ret = 0;

    return ret;
}

guint64
our_get_rtc_time_usec() {

    guint64 ret = 0;

    return ret;
}

/* --- end method/property/dbus signal code, begin bus/name handlers --- */

static void timedated_on_bus_acquired(GDBusConnection *conn,
                                      const gchar *name,
                                      gpointer user_data) {

    g_printf("got bus/name, exporting %s's interface...\n", name);

    timedated_interf = timedate1_skeleton_new();

    /* attach function pointers to generated struct's method handlers */
    g_signal_connect(timedated_interf, "handle-set-time",     G_CALLBACK(on_handle_set_time),     NULL);
    g_signal_connect(timedated_interf, "handle-set-timezone", G_CALLBACK(on_handle_set_timezone), NULL);
    g_signal_connect(timedated_interf, "handle-set-local-rtc", G_CALLBACK(on_handle_set_local_rtc), NULL);
    g_signal_connect(timedated_interf, "handle-set-ntp",      G_CALLBACK(on_handle_set_ntp),      NULL);

    /* set our properties before export */
    timedate1_set_timezone(timedated_interf, our_get_timezone());
    timedate1_set_local_rtc(timedated_interf, our_get_local_rtc());
    timedate1_set_can_ntp(timedated_interf, our_get_can_ntp());
    timedate1_set_ntp(timedated_interf, our_get_ntp());
    timedate1_set_ntpsynchronized(timedated_interf, our_get_ntpsynchronized());
    timedate1_set_time_usec(timedated_interf, our_get_time_usec());
    timedate1_set_rtctime_usec(timedated_interf, our_get_rtc_time_usec());
    
    if(!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(timedated_interf),
                                         conn,
                                         "/org/freedesktop/timedate1",
                                         NULL)) {

        g_printf("failed to export %s's interface!\n", name);
        timedated_mem_clean();

    } else {

        dbus_interface_exported = TRUE;
        g_printf("exported %s's interface on the system bus...\n", name);
    }
}

static void timedated_on_name_acquired(GDBusConnection *conn,
                                       const gchar *name,
                                       gpointer user_data) {

   g_printf("success!\n"); 
}

static void timedated_on_name_lost(GDBusConnection *conn,
                                   const gchar *name,
                                   gpointer user_data) {

    if(!conn) {

        g_printf("failed to connect to the system bus while trying to acquire name '%s': either dbus-daemon isn't running or we don't have permission to push names and/or their interfaces to it.\n", name);
        timedated_mem_clean();
    }

    g_print("lost name %s, exiting...\n", name);

    timedated_mem_clean();
}

/* --- end bus/name handlers, begin misc unix functions --- */

/* safe call to clean and then exit
 * this stops our GMainLoop safely before letting main() return */
void timedated_mem_clean() {

    g_printf("exiting...\n");

    if(dbus_interface_exported)
        g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(timedated_interf));

     if(g_main_loop_is_running(timedated_loop))
        g_main_loop_quit(timedated_loop);

}

/* wrapper for glib's unix signal handling; called only once if terminating signal is raised against us */
gboolean unix_sig_terminate_handler(gpointer data) {

    g_printf("caught SIGINT/HUP/TERM, exiting\n");

    timedated_mem_clean();
    return G_SOURCE_REMOVE;
}

void set_signal_handlers() {

    /* we don't care about its descriptor, we never need to unregister these */
    g_unix_signal_add(SIGINT,  unix_sig_terminate_handler, NULL);
    g_unix_signal_add(SIGHUP,  unix_sig_terminate_handler, NULL);
    g_unix_signal_add(SIGTERM, unix_sig_terminate_handler, NULL);
}

int main() {

    set_signal_handlers();

    /*if(!build_lookup_table())
        return 1; */

    timedated_loop = g_main_loop_new(NULL, TRUE);
    timedated_freeable = g_ptr_array_new();

     bus_descriptor = g_bus_own_name(G_BUS_TYPE_SYSTEM,
                                    "org.freedesktop.timedate1",
                                    G_BUS_NAME_OWNER_FLAGS_NONE,
                                    timedated_on_bus_acquired,
                                    timedated_on_name_acquired,
                                    timedated_on_name_lost,
                                    NULL,
                                    NULL);

    g_main_loop_run(timedated_loop);
    /* runs until single g_main_loop_quit() call is raised inside <interface>_mem_clean() */
    g_main_loop_unref(timedated_loop);

    /* guaranteed unownable */
    g_bus_unown_name(bus_descriptor);

    /* at this point no operations can occur with our data, it is safe to free it + its container */
    g_ptr_array_free(timedated_freeable, TRUE);

    return 0;
}

static struct timezone_checksum_pair parse_timezone_path(gchar **pair) {

    gchar *prefix_pattern, *right_prefix_pattern, *posix_prefix_pattern, *lean_path;
    GRegex *prefix, *posix, *right;
    GError *err = NULL;
    struct timezone_checksum_pair ret = { NULL, NULL, FALSE, FALSE };

    if(!pair[0])
        return ret;

    prefix_pattern = (gchar *) g_malloc0(4096);
    right_prefix_pattern = (gchar *) g_malloc0(4096);
    posix_prefix_pattern = (gchar *) g_malloc0(4096);

    g_sprintf(prefix_pattern, "%s/", OS_TIMEZONE_PATH);
    g_sprintf(posix_prefix_pattern, "%s/posix/", OS_TIMEZONE_PATH);
    g_sprintf(right_prefix_pattern, "%s/right/", OS_TIMEZONE_PATH);

    prefix = g_regex_new(prefix_pattern, 0, 0, &err);
    posix  = g_regex_new(posix_prefix_pattern, 0, 0, &err);
    right  = g_regex_new(right_prefix_pattern, 0, 0, &err);

    if(g_regex_match_full(posix, pair[0], -1, 0, G_REGEX_MATCH_NOTEMPTY, NULL, NULL)) {

        ret.posix = TRUE;
        lean_path = g_regex_replace_literal(posix, pair[0], -1, 0, "", G_REGEX_MATCH_NOTEMPTY, NULL);

    } else if(g_regex_match_full(right, pair[0], -1, 0, G_REGEX_MATCH_NOTEMPTY, NULL, NULL)) {
 
       ret.right = TRUE;
       lean_path = g_regex_replace_literal(right, pair[0], -1, 0, "", G_REGEX_MATCH_NOTEMPTY, NULL);

    } else
        lean_path = g_regex_replace_literal(prefix, pair[0], -1, 0, "", G_REGEX_MATCH_NOTEMPTY, NULL);

    ret.path = lean_path;

    ret.sum = g_malloc0(256);
    g_strlcpy(ret.sum, pair[1], 66);

    g_regex_unref(prefix);
    g_regex_unref(right);
    g_regex_unref(posix);

    return ret;
}

/* TODO need to deconstruct tz_table on exit
static gboolean build_lookup_table() {

        gchar *find_cmd, **map_pairs, *find_output, *path_buf, *sum_buf, **entry_buf;
        GError *err;
        gboolean ret;
        gint i;

        i   = 0;
        err = NULL;
        ret = TRUE;

        find_cmd    = (gchar *) g_malloc0(4096);
        find_output = (gchar *) g_malloc0(1000000);

        g_sprintf(find_cmd, "/bin/sh -c \"find %s -type f -exec cksum -a sha256 {} \\; | sed -E 's/SHA256 \\(//g' | sed -E 's/\\) = /=/g'\"", OS_TIMEZONE_PATH);

        if(!g_spawn_command_line_sync(find_cmd, &find_output, NULL, NULL, &err)) {

            g_printf("error running `%s`\n", find_cmd);
            ret = FALSE;
        }

        map_pairs = g_strsplit(find_output, "\n", INT_MAX);

        while(map_pairs[i] && (entry_buf = g_strsplit(map_pairs[i], "=", INT_MAX))) {

            tz_table[i] = parse_timezone_path(entry_buf);

            g_strfreev(entry_buf);
            i++;
        }

        g_free(find_output);
        g_free(find_cmd);
        g_free(map_pairs);

        return ret;
}

static gchar *lookup_hash(gchar *hash) {

    gint i = 0;

    while(tz_table[i].sum)
        if(!g_strcmp0(tz_table[i].sum, hash))
            return tz_table[i].path;
        else
            i++;

    return NULL;
}*/

/* takes number of microseconds since epoch and returns a 
 * ptr to a timespec suitable to be passed to clock_settime(3)
 */
static struct timespec* mktimespec(gint64 us) {

    long nanoseconds;
    time_t seconds;

    gint64 div_buf_remainder, div_buf_s, div_buf_ns;
    struct timespec *ret;

    div_buf_s         = (us / 1000000); /* us / 10^6 = s */
    div_buf_remainder = (us % 1000000); /* fraction of second lost from prev. line */
    div_buf_ns        = div_buf_remainder * 1000; /* us * 10^3 = ns */

    seconds     = (time_t) div_buf_s; /* porting note: most systems use 32 bit time, adjust accordingly */
    nanoseconds = (long)   div_buf_ns;

    ret = (struct timespec *) calloc(1, sizeof(struct timespec));

    ret->tv_sec  = seconds;
    ret->tv_nsec = nanoseconds;

    g_ptr_array_add(timedated_freeable, ret);

    return ret;
}
Commit	Line	Data
3b82e3c1	1	/*
	2	* Copyright (c) 2014 Ian Sutton <ian@kremlin.cc>
	3	*
	4	* Permission to use, copy, modify, and distribute this software for any
	5	* purpose with or without fee is hereby granted, provided that the above
	6	* copyright notice and this permission notice appear in all copies.
	7	*
	8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	15	*/
	16
b6ad18ad	17	#include <unistd.h>
b6ad18ad	18	#include <limits.h>
c12c41f4	19	#include <signal.h>
b6ad18ad	20
a3d2e50f	21	#include <sys/types.h>
a8f71719	22	#include <sys/time.h>
c8a3e18e	23	#include <sys/stat.h>
c8a3e18e	24	#include <errno.h>
a3d2e50f	25	#include <time.h>
b6ad18ad	26	#include <string.h>
c8a3e18e	27	#include <tzfile.h>
b6ad18ad	28
b6ad18ad	29	#include <glib/gprintf.h>
8caf1f61	30	#include <glib-unix.h>
1066bd36	31	#include <glib/gstdio.h>
904d744d	32	#include <polkit/polkit.h>
b6ad18ad	33
1e8c7c88	34	#include "timedated-gen.h"
a33bcdfa	35	#include "timedated.h"
1e8c7c88	36
ed4cf3c8	37	#include "../../util.h"
483e90b7	38
c8a3e18e	39	#define TZNAME_MAX PATH_MAX
c8a3e18e	40
b6ad18ad	41	GPtrArray *timedated_freeable;
	42	Timedate1 *timedated_interf;
	43
c12c41f4	44	GMainLoop *timedated_loop;
	45
	46	guint bus_descriptor;
	47	gboolean dbus_interface_exported; /* reliable because of gdbus operational guarantees */
	48
03f12ac7	49	const gchar OS_LOCALTIME = "/etc/localtime"; / current timezone file */
	50	const gchar OS_TIMEZONE_PATH = "/usr/share/zoneinfo"; / path to system timezone files */
	51
	52	struct timezone_checksum_pair {
	53
	54	gchar *path;
	55	gchar *sum;
	56	gboolean posix;
	57	gboolean right;
	58	};
	59
	60	static struct timezone_checksum_pair tz_table[5000];
1066bd36	61
1ce41045	62	/* --- begin method/property/dbus signal code --- */
b6ad18ad	63
28b86015	64	static gboolean
a8f71719	65	on_handle_set_time(Timedate1 *td1_passed_interf,
28b86015	66	GDBusMethodInvocation *invoc,
	67	const gchar *greet,
	68	gpointer data) {
a8f71719	69
	70	GVariant *params;
	71	gint64 proposed_time, cur_time;
	72	const gchar *bus_name;
	73	gboolean policykit_auth;
	74	check_auth_result is_authed;
	75	gboolean relative; /* relative if passed time_t is meant to be added to current time */
644bae40	76	struct timespec *new_time;
a8f71719	77
	78	params = g_dbus_method_invocation_get_parameters(invoc);
	79	g_variant_get(params, "(xbb)", &proposed_time, &relative, &policykit_auth);
	80	bus_name = g_dbus_method_invocation_get_sender(invoc);
	81
	82	is_authed = polkit_try_auth(bus_name, "org.freedesktop.timedate1.set-time", policykit_auth);
	83
	84	switch(is_authed) {
	85
	86	case AUTHORIZED_NATIVELY:
	87	case AUTHORIZED_BY_PROMPT:
	88	break;
	89
	90	case UNAUTHORIZED_NATIVELY:
	91	case UNAUTHORIZED_FAILED_PROMPT:
	92	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EACCES", "Insufficient permissions to set system time.");
	93	return FALSE;
	94
	95	case ERROR_BADBUS:
	96	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EFAULT", "Provided bus name is invalid.");
	97	return FALSE;
	98
	99	case ERROR_BADACTION:
	100	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EFAULT", "Provided action ID is invalid.");
	101	return FALSE;
	102
	103	case ERROR_GENERIC:
	104	default:
	105	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ECANCELED", "Failed to set system time for unknown reasons.");
	106	return FALSE;
	107	}
	108
fe959043	109	if(!proposed_time) {
	110
	111	timedate1_complete_set_time(td1_passed_interf, invoc);
	112	return TRUE;
a8f71719	113
fe959043	114	} else if(relative) {
a8f71719	115
a8f71719	116	cur_time = g_get_real_time();
fe959043	117
10ddceeb	118	if(proposed_time < 0 && cur_time + proposed_time > cur_time) {
fe959043	119
	120	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EINVAL", "Resultant time out of bounds.");
	121	return FALSE;
	122
10ddceeb	123	} else if(proposed_time > 0 && cur_time + proposed_time < cur_time) {
fe959043	124
	125	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EINVAL", "Resultant time out of bounds.");
	126	return FALSE;
	127	}
	128
644bae40	129	new_time = mktimespec(proposed_time);
fe959043	130
644bae40	131	if(!clock_settime(CLOCK_REALTIME, new_time)) {
fe959043	132
	133	timedate1_complete_set_time(td1_passed_interf, invoc);
	134	return TRUE;
	135
	136	} else {
	137
	138	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ECANCELED", "Failed to set system time for unknown reasons.");
	139	return FALSE;
	140	}
	141
10ddceeb	142	} else if(proposed_time > 0) {
a8f71719	143
a8f71719	144
644bae40	145	new_time = mktimespec(proposed_time);
	146
	147	if(!clock_settime(CLOCK_REALTIME, new_time)) {
a8f71719	148
	149	timedate1_complete_set_time(td1_passed_interf, invoc);
	150	return TRUE;
	151
	152	} else {
	153
	154	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ECANCELED", "Failed to set system time for unknown reasons.");
	155	return FALSE;
	156	}
fe959043	157
a8f71719	158	} else {
a8f71719	159
fe959043	160	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EINVAL", "Resultant time out of bounds.");
a8f71719	161	return FALSE;
a8f71719	162	}
28b86015	163	}
b6ad18ad	164
28b86015	165	static gboolean
a8f71719	166	on_handle_set_timezone(Timedate1 *td1_passed_interf,
28b86015	167	GDBusMethodInvocation *invoc,
	168	const gchar *greet,
	169	gpointer data) {
c8a3e18e	170
	171	GVariant *params;
	172	gchar *proposed_tz;
	173	const gchar *bus_name;
	174	gboolean policykit_auth;
	175	check_auth_result is_authed;
	176
	177	gchar *tz_target_path;
	178	struct stat *statbuf;
	179	extern int errno;
	180
	181	params = g_dbus_method_invocation_get_parameters(invoc);
	182	g_variant_get(params, "(sb)", &proposed_tz, &policykit_auth);
	183	bus_name = g_dbus_method_invocation_get_sender(invoc);
	184
	185	is_authed = polkit_try_auth(bus_name, "org.freedesktop.timedate1.set-timezone", policykit_auth);
	186
	187	switch(is_authed) {
	188
	189	case AUTHORIZED_NATIVELY:
	190	case AUTHORIZED_BY_PROMPT:
	191	break;
	192
	193	case UNAUTHORIZED_NATIVELY:
	194	case UNAUTHORIZED_FAILED_PROMPT:
	195	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EACCES", "Insufficient permissions to set timezone.");
	196	return FALSE;
	197
	198	case ERROR_BADBUS:
	199	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EFAULT", "Provided bus name is invalid.");
	200	return FALSE;
	201
	202	case ERROR_BADACTION:
	203	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EFAULT", "Provided action ID is invalid.");
	204	return FALSE;
	205
	206	case ERROR_GENERIC:
	207	default:
	208	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ECANCELED", "Failed to set timezone for unknown reasons.");
	209	return FALSE;
	210	}
	211
	212	statbuf = (struct stat*) calloc(1, sizeof(struct stat));
	213	tz_target_path = (gchar *) calloc(1, TZNAME_MAX);
	214
	215	g_ptr_array_add(timedated_freeable, statbuf);
	216	g_ptr_array_add(timedated_freeable, tz_target_path);
	217
	218	strlcat(tz_target_path, TZDIR, TZNAME_MAX);
	219	strlcat(tz_target_path, "/", TZNAME_MAX);
	220	strlcat(tz_target_path, proposed_tz, TZNAME_MAX);
	221
0b7afeee	222	if(strstr(tz_target_path, "../")) {
	223
	224	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EBADF", "Provided timezone is invalid.");
	225	return FALSE;
	226	}
c8a3e18e	227
	228	if(!statbuf)
	229	return FALSE;
	230
	231	if(lstat(tz_target_path, statbuf)) {
	232
	233	switch(errno) {
	234
	235	case ENOENT:
	236	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ENOENT", "Specified timezone does not exist.");
	237	break;
	238
	239	default:
	240	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EBADF", "Specified timezone is invalid.");
	241	break;
	242	}
	243
	244	return FALSE;
	245	}
	246
	247	if(!S_ISREG(statbuf->st_mode)) {
	248
	249	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.EBADF", "Specified path is of an inappropriate type.");
	250	return FALSE;
	251	}
	252
	253	memset(statbuf, 0, sizeof statbuf);
	254
	255	if(!lstat(TZDEFAULT, statbuf))
	256	if(remove(TZDEFAULT))
	257	return FALSE;
	258
	259	if(symlink(tz_target_path, TZDEFAULT))
	260	return FALSE;
	261
	262
	263	timedate1_complete_set_timezone(td1_passed_interf, invoc);
	264
	265	return TRUE;
28b86015	266	}
	267
	268	static gboolean
a8f71719	269	on_handle_set_local_rtc(Timedate1 *td1_passed_interf,
28b86015	270	GDBusMethodInvocation *invoc,
	271	const gchar *greet,
	272	gpointer data) {
0b7afeee	273
	274	g_dbus_method_invocation_return_dbus_error(invoc, "org.freedesktop.timedate1.Error.ENODEV", "OpenBSD does not support setting the realtime clock in local time, only UTC.");
	275	return TRUE;
28b86015	276	}
	277
	278	static gboolean
a8f71719	279	on_handle_set_ntp(Timedate1 *td1_passed_interf,
28b86015	280	GDBusMethodInvocation *invoc,
	281	const gchar *greet,
	282	gpointer data) {
	283	return FALSE;
	284	}
	285
	286	const gchar *
	287	our_get_timezone() {
	288
1066bd36	289	GStatBuf *stat_zoneinfo;
03f12ac7	290	gchar find_cmd, readlink_path, ret, argvp, *hash_to_match;
	291	gint argcp;
	292	GError *err;
	293	struct timezone_checksum_pair tmp;
1066bd36	294
03f12ac7	295	find_cmd = (gchar *) g_malloc0(2048);
	296	stat_zoneinfo = (GStatBuf *) g_malloc0(8192);
	297	err = (GError *) g_malloc0(2048);
1066bd36	298
	299	if(g_stat(OS_LOCALTIME, stat_zoneinfo)) {
	300
	301	g_printf("could not read from %s! please symlink or copy a timezone file from %s to %s!\n", OS_LOCALTIME, OS_TIMEZONE_PATH, OS_LOCALTIME);
	302	ret = NULL;
	303
	304	} else if(g_file_test(OS_LOCALTIME, G_FILE_TEST_IS_SYMLINK)) {
	305
	306	readlink_path = g_file_read_link(OS_LOCALTIME, &err);
03f12ac7	307
	308	gchar *split[2] = { readlink_path, "" };
	309	tmp = parse_timezone_path(split);
	310
	311	ret = tmp.path;
1066bd36	312
	313	if(readlink_path)
	314	g_free(readlink_path);
	315
	316	} else {
	317
	318	g_printf("%s is not a symlink! attempting to match checksums in %s...\n", OS_LOCALTIME, OS_TIMEZONE_PATH);
03f12ac7	319	hash_to_match = get_file_sha256(OS_LOCALTIME);
03f12ac7	320
644bae40	321	/* ret = lookup_hash(hash_to_match); */
644bae40	322	return FALSE; /* TODO fix me for real */
03f12ac7	323
	324	if(hash_to_match)
	325	g_free(hash_to_match);
1066bd36	326	}
1066bd36	327
c8a3e18e	328
c8a3e18e	329
1066bd36	330	return ret;
28b86015	331	}
28b86015	332
0b7afeee	333	/* openbsd does not support setting the RTC to localtime, only UTC */
28b86015	334	gboolean
	335	our_get_local_rtc() {
	336
	337	gboolean ret = FALSE;
	338
	339	return ret;
	340	}
	341
	342	gboolean
	343	our_get_can_ntp() {
	344
	345	const gboolean ret = FALSE;
	346
	347	return ret;
	348	}
	349
	350	gboolean
	351	our_get_ntp() {
	352
	353	const gboolean ret = FALSE;
	354
	355	return ret;
	356	}
b6ad18ad	357
28b86015	358	gboolean
	359	our_get_ntpsynchronized() {
	360
	361	const gboolean ret = FALSE;
b6ad18ad	362
28b86015	363	return ret;
28b86015	364	}
b6ad18ad	365
28b86015	366	guint64
28b86015	367	our_get_time_usec() {
b6ad18ad	368
28b86015	369	guint64 ret = 0;
b6ad18ad	370
28b86015	371	return ret;
	372	}
	373
	374	guint64
	375	our_get_rtc_time_usec() {
	376
	377	guint64 ret = 0;
	378
	379	return ret;
	380	}
b6ad18ad	381
1ce41045	382	/* --- end method/property/dbus signal code, begin bus/name handlers --- */
b6ad18ad	383
	384	static void timedated_on_bus_acquired(GDBusConnection *conn,
	385	const gchar *name,
	386	gpointer user_data) {
	387
254ceec0	388	g_printf("got bus/name, exporting %s's interface...\n", name);
b6ad18ad	389
	390	timedated_interf = timedate1_skeleton_new();
	391
28b86015	392	/* attach function pointers to generated struct's method handlers */
	393	g_signal_connect(timedated_interf, "handle-set-time", G_CALLBACK(on_handle_set_time), NULL);
	394	g_signal_connect(timedated_interf, "handle-set-timezone", G_CALLBACK(on_handle_set_timezone), NULL);
	395	g_signal_connect(timedated_interf, "handle-set-local-rtc", G_CALLBACK(on_handle_set_local_rtc), NULL);
	396	g_signal_connect(timedated_interf, "handle-set-ntp", G_CALLBACK(on_handle_set_ntp), NULL);
03f12ac7	397
28b86015	398	/* set our properties before export */
	399	timedate1_set_timezone(timedated_interf, our_get_timezone());
	400	timedate1_set_local_rtc(timedated_interf, our_get_local_rtc());
	401	timedate1_set_can_ntp(timedated_interf, our_get_can_ntp());
	402	timedate1_set_ntp(timedated_interf, our_get_ntp());
	403	timedate1_set_ntpsynchronized(timedated_interf, our_get_ntpsynchronized());
	404	timedate1_set_time_usec(timedated_interf, our_get_time_usec());
	405	timedate1_set_rtctime_usec(timedated_interf, our_get_rtc_time_usec());
	406
b6ad18ad	407	if(!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(timedated_interf),
	408	conn,
	409	"/org/freedesktop/timedate1",
	410	NULL)) {
	411
509599f0	412	g_printf("failed to export %s's interface!\n", name);
	413	timedated_mem_clean();
	414
	415	} else {
	416
	417	dbus_interface_exported = TRUE;
	418	g_printf("exported %s's interface on the system bus...\n", name);
b6ad18ad	419	}
509599f0	420	}
	421
	422	static void timedated_on_name_acquired(GDBusConnection *conn,
90f54407	423	const gchar *name,
509599f0	424	gpointer user_data) {
b6ad18ad	425
509599f0	426	g_printf("success!\n");
b6ad18ad	427	}
b6ad18ad	428
b6ad18ad	429	static void timedated_on_name_lost(GDBusConnection *conn,
	430	const gchar *name,
	431	gpointer user_data) {
	432
509599f0	433	if(!conn) {
b6ad18ad	434
509599f0	435	g_printf("failed to connect to the system bus while trying to acquire name '%s': either dbus-daemon isn't running or we don't have permission to push names and/or their interfaces to it.\n", name);
	436	timedated_mem_clean();
	437	}
b6ad18ad	438
509599f0	439	g_print("lost name %s, exiting...\n", name);
	440
	441	timedated_mem_clean();
b6ad18ad	442	}
b6ad18ad	443
b70beb08	444	/* --- end bus/name handlers, begin misc unix functions --- */
b70beb08	445
509599f0	446	/* safe call to clean and then exit
509599f0	447	* this stops our GMainLoop safely before letting main() return */
b70beb08	448	void timedated_mem_clean() {
b70beb08	449
341587db	450	g_printf("exiting...\n");
	451
	452	if(dbus_interface_exported)
	453	g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(timedated_interf));
	454
	455	if(g_main_loop_is_running(timedated_loop))
	456	g_main_loop_quit(timedated_loop);
	457
b70beb08	458	}
b70beb08	459
712eb329	460	/* wrapper for glib's unix signal handling; called only once if terminating signal is raised against us */
	461	gboolean unix_sig_terminate_handler(gpointer data) {
	462
	463	g_printf("caught SIGINT/HUP/TERM, exiting\n");
	464
	465	timedated_mem_clean();
	466	return G_SOURCE_REMOVE;
	467	}
	468
2ef2cfe1	469	void set_signal_handlers() {
	470
	471	/* we don't care about its descriptor, we never need to unregister these */
	472	g_unix_signal_add(SIGINT, unix_sig_terminate_handler, NULL);
	473	g_unix_signal_add(SIGHUP, unix_sig_terminate_handler, NULL);
	474	g_unix_signal_add(SIGTERM, unix_sig_terminate_handler, NULL);
	475	}
	476
1e8c7c88	477	int main() {
b6ad18ad	478
9728ae1f	479	set_signal_handlers();
9728ae1f	480
644bae40	481	/*if(!build_lookup_table())
644bae40	482	return 1; */
03f12ac7	483
90f54407	484	timedated_loop = g_main_loop_new(NULL, TRUE);
90f54407	485	timedated_freeable = g_ptr_array_new();
b6ad18ad	486
90f54407	487	bus_descriptor = g_bus_own_name(G_BUS_TYPE_SYSTEM,
b6ad18ad	488	"org.freedesktop.timedate1",
	489	G_BUS_NAME_OWNER_FLAGS_NONE,
	490	timedated_on_bus_acquired,
	491	timedated_on_name_acquired,
	492	timedated_on_name_lost,
	493	NULL,
	494	NULL);
	495
90f54407	496	g_main_loop_run(timedated_loop);
9728ae1f	497	/* runs until single g_main_loop_quit() call is raised inside <interface>_mem_clean() */
90f54407	498	g_main_loop_unref(timedated_loop);
b6ad18ad	499
9728ae1f	500	/* guaranteed unownable */
90f54407	501	g_bus_unown_name(bus_descriptor);
b6ad18ad	502
9728ae1f	503	/* at this point no operations can occur with our data, it is safe to free it + its container */
9728ae1f	504	g_ptr_array_free(timedated_freeable, TRUE);
b6ad18ad	505
90f54407	506	return 0;
1e8c7c88	507	}
1066bd36	508
03f12ac7	509	static struct timezone_checksum_pair parse_timezone_path(gchar **pair) {
1066bd36	510
03f12ac7	511	gchar prefix_pattern, right_prefix_pattern, posix_prefix_pattern, lean_path;
1066bd36	512	GRegex prefix, posix, *right;
1066bd36	513	GError *err = NULL;
03f12ac7	514	struct timezone_checksum_pair ret = { NULL, NULL, FALSE, FALSE };
1066bd36	515
03f12ac7	516	if(!pair[0])
03f12ac7	517	return ret;
1066bd36	518
1066bd36	519	prefix_pattern = (gchar *) g_malloc0(4096);
03f12ac7	520	right_prefix_pattern = (gchar *) g_malloc0(4096);
	521	posix_prefix_pattern = (gchar *) g_malloc0(4096);
	522
	523	g_sprintf(prefix_pattern, "%s/", OS_TIMEZONE_PATH);
	524	g_sprintf(posix_prefix_pattern, "%s/posix/", OS_TIMEZONE_PATH);
	525	g_sprintf(right_prefix_pattern, "%s/right/", OS_TIMEZONE_PATH);
1066bd36	526
1066bd36	527	prefix = g_regex_new(prefix_pattern, 0, 0, &err);
03f12ac7	528	posix = g_regex_new(posix_prefix_pattern, 0, 0, &err);
	529	right = g_regex_new(right_prefix_pattern, 0, 0, &err);
	530
	531	if(g_regex_match_full(posix, pair[0], -1, 0, G_REGEX_MATCH_NOTEMPTY, NULL, NULL)) {
	532
	533	ret.posix = TRUE;
	534	lean_path = g_regex_replace_literal(posix, pair[0], -1, 0, "", G_REGEX_MATCH_NOTEMPTY, NULL);
	535
	536	} else if(g_regex_match_full(right, pair[0], -1, 0, G_REGEX_MATCH_NOTEMPTY, NULL, NULL)) {
	537
	538	ret.right = TRUE;
	539	lean_path = g_regex_replace_literal(right, pair[0], -1, 0, "", G_REGEX_MATCH_NOTEMPTY, NULL);
	540
	541	} else
	542	lean_path = g_regex_replace_literal(prefix, pair[0], -1, 0, "", G_REGEX_MATCH_NOTEMPTY, NULL);
	543
	544	ret.path = lean_path;
	545
	546	ret.sum = g_malloc0(256);
	547	g_strlcpy(ret.sum, pair[1], 66);
1066bd36	548
	549	g_regex_unref(prefix);
	550	g_regex_unref(right);
	551	g_regex_unref(posix);
	552
03f12ac7	553	return ret;
	554	}
	555
644bae40	556	/* TODO need to deconstruct tz_table on exit
03f12ac7	557	static gboolean build_lookup_table() {
	558
	559	gchar find_cmd, map_pairs, find_output, path_buf, sum_buf, **entry_buf;
	560	GError *err;
	561	gboolean ret;
	562	gint i;
	563
	564	i = 0;
	565	err = NULL;
	566	ret = TRUE;
	567
	568	find_cmd = (gchar *) g_malloc0(4096);
	569	find_output = (gchar *) g_malloc0(1000000);
	570
	571	g_sprintf(find_cmd, "/bin/sh -c \"find %s -type f -exec cksum -a sha256 {} \\; \| sed -E 's/SHA256 \\(//g' \| sed -E 's/\\) = /=/g'\"", OS_TIMEZONE_PATH);
	572
	573	if(!g_spawn_command_line_sync(find_cmd, &find_output, NULL, NULL, &err)) {
	574
	575	g_printf("error running `%s`\n", find_cmd);
	576	ret = FALSE;
	577	}
	578
	579	map_pairs = g_strsplit(find_output, "\n", INT_MAX);
	580
	581	while(map_pairs[i] && (entry_buf = g_strsplit(map_pairs[i], "=", INT_MAX))) {
	582
	583	tz_table[i] = parse_timezone_path(entry_buf);
	584
	585	g_strfreev(entry_buf);
	586	i++;
	587	}
	588
	589	g_free(find_output);
	590	g_free(find_cmd);
	591	g_free(map_pairs);
	592
	593	return ret;
	594	}
	595
	596	static gchar lookup_hash(gchar hash) {
	597
	598	gint i = 0;
	599
	600	while(tz_table[i].sum)
	601	if(!g_strcmp0(tz_table[i].sum, hash))
	602	return tz_table[i].path;
	603	else
	604	i++;
	605
	606	return NULL;
644bae40	607	}*/
	608
	609	/* takes number of microseconds since epoch and returns a
	610	* ptr to a timespec suitable to be passed to clock_settime(3)
	611	*/
	612	static struct timespec* mktimespec(gint64 us) {
	613
	614	long nanoseconds;
	615	time_t seconds;
	616
	617	gint64 div_buf_remainder, div_buf_s, div_buf_ns;
	618	struct timespec *ret;
	619
	620	div_buf_s = (us / 1000000); /* us / 10^6 = s */
	621	div_buf_remainder = (us % 1000000); /* fraction of second lost from prev. line */
	622	div_buf_ns = div_buf_remainder * 1000; /* us * 10^3 = ns */
	623
	624	seconds = (time_t) div_buf_s; /* porting note: most systems use 32 bit time, adjust accordingly */
	625	nanoseconds = (long) div_buf_ns;
	626
	627	ret = (struct timespec *) calloc(1, sizeof(struct timespec));
	628
	629	ret->tv_sec = seconds;
	630	ret->tv_nsec = nanoseconds;
	631
	632	g_ptr_array_add(timedated_freeable, ret);
	633
	634	return ret;
1066bd36	635	}