[thirdparty/systemd.git] / src / timedate / timedatectl.c

/***
  This file is part of systemd.

  Copyright 2012 Lennart Poettering
  Copyright 2013 Kay Sievers

  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 <http://www.gnu.org/licenses/>.
***/

#include <getopt.h>
#include <locale.h>
#include <stdbool.h>
#include <stdlib.h>

#include "sd-bus.h"

#include "bus-error.h"
#include "bus-util.h"
#include "pager.h"
#include "parse-util.h"
#include "spawn-polkit-agent.h"
#include "strv.h"
#include "terminal-util.h"
#include "util.h"

static bool arg_no_pager = false;
static bool arg_ask_password = true;
static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
static char *arg_host = NULL;
static bool arg_adjust_system_clock = false;

static void polkit_agent_open_if_enabled(void) {

        /* Open the polkit agent as a child process if necessary */
        if (!arg_ask_password)
                return;

        if (arg_transport != BUS_TRANSPORT_LOCAL)
                return;

        polkit_agent_open();
}

typedef struct StatusInfo {
        usec_t time;
        char *timezone;

        usec_t rtc_time;
        int rtc_local;

        int ntp_enabled;
        int ntp_capable;
        int ntp_synced;
} StatusInfo;

static void status_info_clear(StatusInfo *info) {
        if (info) {
                free(info->timezone);
                zero(*info);
        }
}

static void print_status_info(const StatusInfo *i) {
        char a[FORMAT_TIMESTAMP_MAX];
        struct tm tm;
        time_t sec;
        bool have_time = false;
        const char *old_tz = NULL, *tz;
        int r;

        assert(i);

        /* Save the old $TZ */
        tz = getenv("TZ");
        if (tz)
                old_tz = strdupa(tz);

        /* Set the new $TZ */
        if (setenv("TZ", isempty(i->timezone) ? "UTC" : i->timezone, true) < 0)
                log_warning_errno(errno, "Failed to set TZ environment variable, ignoring: %m");
        else
                tzset();

        if (i->time != 0) {
                sec = (time_t) (i->time / USEC_PER_SEC);
                have_time = true;
        } else if (IN_SET(arg_transport, BUS_TRANSPORT_LOCAL, BUS_TRANSPORT_MACHINE)) {
                sec = time(NULL);
                have_time = true;
        } else
                log_warning("Could not get time from timedated and not operating locally, ignoring.");

        if (have_time) {
                xstrftime(a, "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&sec, &tm));
                printf("                      Local time: %.*s\n", (int) sizeof(a), a);

                xstrftime(a, "%a %Y-%m-%d %H:%M:%S UTC", gmtime_r(&sec, &tm));
                printf("                  Universal time: %.*s\n", (int) sizeof(a), a);
        } else {
                printf("                      Local time: %s\n", "n/a");
                printf("                  Universal time: %s\n", "n/a");
        }

        if (i->rtc_time > 0) {
                time_t rtc_sec;

                rtc_sec = (time_t) (i->rtc_time / USEC_PER_SEC);
                xstrftime(a, "%a %Y-%m-%d %H:%M:%S", gmtime_r(&rtc_sec, &tm));
                printf("                        RTC time: %.*s\n", (int) sizeof(a), a);
        } else
                printf("                        RTC time: %s\n", "n/a");

        if (have_time)
                xstrftime(a, "%Z, %z", localtime_r(&sec, &tm));

        /* Restore the $TZ */
        if (old_tz)
                r = setenv("TZ", old_tz, true);
        else
                r = unsetenv("TZ");
        if (r < 0)
                log_warning_errno(errno, "Failed to set TZ environment variable, ignoring: %m");
        else
                tzset();

        printf("                       Time zone: %s (%.*s)\n"
               "       System clock synchronized: %s\n"
               "systemd-timesyncd.service active: %s\n"
               "                 RTC in local TZ: %s\n",
               strna(i->timezone), (int) sizeof(a), have_time ? a : "n/a",
               i->ntp_capable ? yes_no(i->ntp_enabled) : "n/a",
               yes_no(i->ntp_synced),
               yes_no(i->rtc_local));

        if (i->rtc_local)
                printf("\n%s"
                       "Warning: The system is configured to read the RTC time in the local time zone.\n"
                       "         This mode can not be fully supported. It will create various problems\n"
                       "         with time zone changes and daylight saving time adjustments. The RTC\n"
                       "         time is never updated, it relies on external facilities to maintain it.\n"
                       "         If at all possible, use RTC in UTC by calling\n"
                       "         'timedatectl set-local-rtc 0'.%s\n", ansi_highlight(), ansi_normal());
}

static int show_status(sd_bus *bus, char **args, unsigned n) {
        _cleanup_(status_info_clear) StatusInfo info = {};
        static const struct bus_properties_map map[]  = {
                { "Timezone",        "s", NULL, offsetof(StatusInfo, timezone) },
                { "LocalRTC",        "b", NULL, offsetof(StatusInfo, rtc_local) },
                { "NTP",             "b", NULL, offsetof(StatusInfo, ntp_enabled) },
                { "CanNTP",          "b", NULL, offsetof(StatusInfo, ntp_capable) },
                { "NTPSynchronized", "b", NULL, offsetof(StatusInfo, ntp_synced) },
                { "TimeUSec",        "t", NULL, offsetof(StatusInfo, time) },
                { "RTCTimeUSec",     "t", NULL, offsetof(StatusInfo, rtc_time) },
                {}
        };

        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        int r;

        assert(bus);

        r = bus_map_all_properties(bus,
                                   "org.freedesktop.timedate1",
                                   "/org/freedesktop/timedate1",
                                   map,
                                   &error,
                                   &info);
        if (r < 0)
                return log_error_errno(r, "Failed to query server: %s", bus_error_message(&error, r));

        print_status_info(&info);

        return r;
}

static int set_time(sd_bus *bus, char **args, unsigned n) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        bool relative = false, interactive = arg_ask_password;
        usec_t t;
        int r;

        assert(args);
        assert(n == 2);

        polkit_agent_open_if_enabled();

        r = parse_timestamp(args[1], &t);
        if (r < 0) {
                log_error("Failed to parse time specification: %s", args[1]);
                return r;
        }

        r = sd_bus_call_method(bus,
                               "org.freedesktop.timedate1",
                               "/org/freedesktop/timedate1",
                               "org.freedesktop.timedate1",
                               "SetTime",
                               &error,
                               NULL,
                               "xbb", (int64_t)t, relative, interactive);
        if (r < 0)
                log_error("Failed to set time: %s", bus_error_message(&error, -r));

        return r;
}

static int set_timezone(sd_bus *bus, char **args, unsigned n) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        int r;

        assert(args);
        assert(n == 2);

        polkit_agent_open_if_enabled();

        r = sd_bus_call_method(bus,
                               "org.freedesktop.timedate1",
                               "/org/freedesktop/timedate1",
                               "org.freedesktop.timedate1",
                               "SetTimezone",
                               &error,
                               NULL,
                               "sb", args[1], arg_ask_password);
        if (r < 0)
                log_error("Failed to set time zone: %s", bus_error_message(&error, -r));

        return r;
}

static int set_local_rtc(sd_bus *bus, char **args, unsigned n) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        int r, b;

        assert(args);
        assert(n == 2);

        polkit_agent_open_if_enabled();

        b = parse_boolean(args[1]);
        if (b < 0) {
                log_error("Failed to parse local RTC setting: %s", args[1]);
                return b;
        }

        r = sd_bus_call_method(bus,
                               "org.freedesktop.timedate1",
                               "/org/freedesktop/timedate1",
                               "org.freedesktop.timedate1",
                               "SetLocalRTC",
                               &error,
                               NULL,
                               "bbb", b, arg_adjust_system_clock, arg_ask_password);
        if (r < 0)
                log_error("Failed to set local RTC: %s", bus_error_message(&error, -r));

        return r;
}

static int set_ntp(sd_bus *bus, char **args, unsigned n) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        int b, r;

        assert(args);
        assert(n == 2);

        polkit_agent_open_if_enabled();

        b = parse_boolean(args[1]);
        if (b < 0) {
                log_error("Failed to parse NTP setting: %s", args[1]);
                return b;
        }

        r = sd_bus_call_method(bus,
                               "org.freedesktop.timedate1",
                               "/org/freedesktop/timedate1",
                               "org.freedesktop.timedate1",
                               "SetNTP",
                               &error,
                               NULL,
                               "bb", b, arg_ask_password);
        if (r < 0)
                log_error("Failed to set ntp: %s", bus_error_message(&error, -r));

        return r;
}

static int list_timezones(sd_bus *bus, char **args, unsigned n) {
        _cleanup_strv_free_ char **zones = NULL;
        int r;

        assert(args);
        assert(n == 1);

        r = get_timezones(&zones);
        if (r < 0)
                return log_error_errno(r, "Failed to read list of time zones: %m");

        pager_open(arg_no_pager, false);
        strv_print(zones);

        return 0;
}

static void help(void) {
        printf("%s [OPTIONS...] COMMAND ...\n\n"
               "Query or change system time and date settings.\n\n"
               "  -h --help                Show this help message\n"
               "     --version             Show package version\n"
               "     --no-pager            Do not pipe output into a pager\n"
               "     --no-ask-password     Do not prompt for password\n"
               "  -H --host=[USER@]HOST    Operate on remote host\n"
               "  -M --machine=CONTAINER   Operate on local container\n"
               "     --adjust-system-clock Adjust system clock when changing local RTC mode\n\n"
               "Commands:\n"
               "  status                   Show current time settings\n"
               "  set-time TIME            Set system time\n"
               "  set-timezone ZONE        Set system time zone\n"
               "  list-timezones           Show known time zones\n"
               "  set-local-rtc BOOL       Control whether RTC is in local time\n"
               "  set-ntp BOOL             Enable or disable network time synchronization\n",
               program_invocation_short_name);
}

static int parse_argv(int argc, char *argv[]) {

        enum {
                ARG_VERSION = 0x100,
                ARG_NO_PAGER,
                ARG_ADJUST_SYSTEM_CLOCK,
                ARG_NO_ASK_PASSWORD
        };

        static const struct option options[] = {
                { "help",                no_argument,       NULL, 'h'                     },
                { "version",             no_argument,       NULL, ARG_VERSION             },
                { "no-pager",            no_argument,       NULL, ARG_NO_PAGER            },
                { "host",                required_argument, NULL, 'H'                     },
                { "machine",             required_argument, NULL, 'M'                     },
                { "no-ask-password",     no_argument,       NULL, ARG_NO_ASK_PASSWORD     },
                { "adjust-system-clock", no_argument,       NULL, ARG_ADJUST_SYSTEM_CLOCK },
                {}
        };

        int c;

        assert(argc >= 0);
        assert(argv);

        while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0)

                switch (c) {

                case 'h':
                        help();
                        return 0;

                case ARG_VERSION:
                        return version();

                case 'H':
                        arg_transport = BUS_TRANSPORT_REMOTE;
                        arg_host = optarg;
                        break;

                case 'M':
                        arg_transport = BUS_TRANSPORT_MACHINE;
                        arg_host = optarg;
                        break;

                case ARG_NO_ASK_PASSWORD:
                        arg_ask_password = false;
                        break;

                case ARG_ADJUST_SYSTEM_CLOCK:
                        arg_adjust_system_clock = true;
                        break;

                case ARG_NO_PAGER:
                        arg_no_pager = true;
                        break;

                case '?':
                        return -EINVAL;

                default:
                        assert_not_reached("Unhandled option");
                }

        return 1;
}

static int timedatectl_main(sd_bus *bus, int argc, char *argv[]) {

        static const struct {
                const char* verb;
                const enum {
                        MORE,
                        LESS,
                        EQUAL
                } argc_cmp;
                const int argc;
                int (* const dispatch)(sd_bus *bus, char **args, unsigned n);
        } verbs[] = {
                { "status",                LESS,   1, show_status      },
                { "set-time",              EQUAL,  2, set_time         },
                { "set-timezone",          EQUAL,  2, set_timezone     },
                { "list-timezones",        EQUAL,  1, list_timezones   },
                { "set-local-rtc",         EQUAL,  2, set_local_rtc    },
                { "set-ntp",               EQUAL,  2, set_ntp,         },
        };

        int left;
        unsigned i;

        assert(argc >= 0);
        assert(argv);

        left = argc - optind;

        if (left <= 0)
                /* Special rule: no arguments means "status" */
                i = 0;
        else {
                if (streq(argv[optind], "help")) {
                        help();
                        return 0;
                }

                for (i = 0; i < ELEMENTSOF(verbs); i++)
                        if (streq(argv[optind], verbs[i].verb))
                                break;

                if (i >= ELEMENTSOF(verbs)) {
                        log_error("Unknown operation %s", argv[optind]);
                        return -EINVAL;
                }
        }

        switch (verbs[i].argc_cmp) {

        case EQUAL:
                if (left != verbs[i].argc) {
                        log_error("Invalid number of arguments.");
                        return -EINVAL;
                }

                break;

        case MORE:
                if (left < verbs[i].argc) {
                        log_error("Too few arguments.");
                        return -EINVAL;
                }

                break;

        case LESS:
                if (left > verbs[i].argc) {
                        log_error("Too many arguments.");
                        return -EINVAL;
                }

                break;

        default:
                assert_not_reached("Unknown comparison operator.");
        }

        return verbs[i].dispatch(bus, argv + optind, left);
}

int main(int argc, char *argv[]) {
        sd_bus *bus = NULL;
        int r;

        setlocale(LC_ALL, "");
        log_parse_environment();
        log_open();

        r = parse_argv(argc, argv);
        if (r <= 0)
                goto finish;

        r = bus_connect_transport(arg_transport, arg_host, false, &bus);
        if (r < 0) {
                log_error_errno(r, "Failed to create bus connection: %m");
                goto finish;
        }

        r = timedatectl_main(bus, argc, argv);

finish:
        sd_bus_flush_close_unref(bus);
        pager_close();

        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
Commit	Line	Data
6d0274f1 LP	1	/***
	2	This file is part of systemd.
	3
	4	Copyright 2012 Lennart Poettering
2f6a5907	5	Copyright 2013 Kay Sievers
6d0274f1 LP	6
	7	systemd is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU Lesser General Public License as published by
	9	the Free Software Foundation; either version 2.1 of the License, or
	10	(at your option) any later version.
	11
	12	systemd is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	Lesser General Public License for more details.
	16
	17	You should have received a copy of the GNU Lesser General Public License
	18	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	19	***/
	20
6d0274f1	21	#include <getopt.h>
a9cdc94f	22	#include <locale.h>
3f6fd1ba LP	23	#include <stdbool.h>
3f6fd1ba LP	24	#include <stdlib.h>
6d0274f1	25
a281d9c7	26	#include "sd-bus.h"
3f6fd1ba	27
a281d9c7	28	#include "bus-error.h"
3f6fd1ba LP	29	#include "bus-util.h"
3f6fd1ba LP	30	#include "pager.h"
6bedfcbb	31	#include "parse-util.h"
6d0274f1	32	#include "spawn-polkit-agent.h"
6d0274f1	33	#include "strv.h"
288a74cc	34	#include "terminal-util.h"
3f6fd1ba	35	#include "util.h"
6d0274f1	36
6d0274f1	37	static bool arg_no_pager = false;
6d0274f1	38	static bool arg_ask_password = true;
e1636421	39	static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
7085053a	40	static char *arg_host = NULL;
e1636421	41	static bool arg_adjust_system_clock = false;
6d0274f1	42
6d0274f1 LP	43	static void polkit_agent_open_if_enabled(void) {
	44
	45	/* Open the polkit agent as a child process if necessary */
6d0274f1 LP	46	if (!arg_ask_password)
	47	return;
	48
46e65dcc LP	49	if (arg_transport != BUS_TRANSPORT_LOCAL)
	50	return;
	51
6d0274f1 LP	52	polkit_agent_open();
	53	}
	54
	55	typedef struct StatusInfo {
2f6a5907	56	usec_t time;
ffc06c35	57	char *timezone;
2f6a5907 KS	58
2f6a5907 KS	59	usec_t rtc_time;
43dcc86a	60	int rtc_local;
2f6a5907	61
43dcc86a LP	62	int ntp_enabled;
	63	int ntp_capable;
	64	int ntp_synced;
6d0274f1 LP	65	} StatusInfo;
6d0274f1 LP	66
e7e55dbd DH	67	static void status_info_clear(StatusInfo *info) {
	68	if (info) {
	69	free(info->timezone);
	70	zero(*info);
	71	}
	72	}
	73
ffc06c35	74	static void print_status_info(const StatusInfo *i) {
f18ca9dc	75	char a[FORMAT_TIMESTAMP_MAX];
6d0274f1 LP	76	struct tm tm;
6d0274f1 LP	77	time_t sec;
9ff09bcb	78	bool have_time = false;
d95a74ed	79	const char old_tz = NULL, tz;
6d0274f1 LP	80	int r;
6d0274f1 LP	81
59965986 LP	82	assert(i);
59965986 LP	83
d95a74ed LP	84	/* Save the old $TZ */
	85	tz = getenv("TZ");
	86	if (tz)
	87	old_tz = strdupa(tz);
2311eb2f	88
d95a74ed	89	/* Set the new $TZ */
bdeb9e60	90	if (setenv("TZ", isempty(i->timezone) ? "UTC" : i->timezone, true) < 0)
d95a74ed LP	91	log_warning_errno(errno, "Failed to set TZ environment variable, ignoring: %m");
	92	else
	93	tzset();
3e5e74d5	94
9ff09bcb SL	95	if (i->time != 0) {
	96	sec = (time_t) (i->time / USEC_PER_SEC);
	97	have_time = true;
d95a74ed	98	} else if (IN_SET(arg_transport, BUS_TRANSPORT_LOCAL, BUS_TRANSPORT_MACHINE)) {
9ff09bcb SL	99	sec = time(NULL);
	100	have_time = true;
	101	} else
d95a74ed	102	log_warning("Could not get time from timedated and not operating locally, ignoring.");
6d0274f1	103
9ff09bcb	104	if (have_time) {
5ffa8c81	105	xstrftime(a, "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&sec, &tm));
3ec530a1	106	printf(" Local time: %.*s\n", (int) sizeof(a), a);
5ffa8c81 ZJS	107
5ffa8c81 ZJS	108	xstrftime(a, "%a %Y-%m-%d %H:%M:%S UTC", gmtime_r(&sec, &tm));
3ec530a1	109	printf(" Universal time: %.*s\n", (int) sizeof(a), a);
9ff09bcb	110	} else {
3ec530a1 ZJS	111	printf(" Local time: %s\n", "n/a");
3ec530a1 ZJS	112	printf(" Universal time: %s\n", "n/a");
9ff09bcb	113	}
6d0274f1	114
2f6a5907 KS	115	if (i->rtc_time > 0) {
2f6a5907 KS	116	time_t rtc_sec;
6d0274f1	117
d95a74ed	118	rtc_sec = (time_t) (i->rtc_time / USEC_PER_SEC);
5ffa8c81	119	xstrftime(a, "%a %Y-%m-%d %H:%M:%S", gmtime_r(&rtc_sec, &tm));
3ec530a1	120	printf(" RTC time: %.*s\n", (int) sizeof(a), a);
2f6a5907	121	} else
3ec530a1	122	printf(" RTC time: %s\n", "n/a");
6d0274f1	123
5ffa8c81 ZJS	124	if (have_time)
5ffa8c81 ZJS	125	xstrftime(a, "%Z, %z", localtime_r(&sec, &tm));
2667cc25	126
d95a74ed LP	127	/* Restore the $TZ */
	128	if (old_tz)
	129	r = setenv("TZ", old_tz, true);
	130	else
	131	r = unsetenv("TZ");
	132	if (r < 0)
	133	log_warning_errno(errno, "Failed to set TZ environment variable, ignoring: %m");
	134	else
	135	tzset();
	136
3ec530a1 ZJS	137	printf(" Time zone: %s (%.*s)\n"
	138	" System clock synchronized: %s\n"
	139	"systemd-timesyncd.service active: %s\n"
	140	" RTC in local TZ: %s\n",
5ffa8c81	141	strna(i->timezone), (int) sizeof(a), have_time ? a : "n/a",
2f6a5907 KS	142	i->ntp_capable ? yes_no(i->ntp_enabled) : "n/a",
	143	yes_no(i->ntp_synced),
	144	yes_no(i->rtc_local));
6d0274f1	145
2f6a5907	146	if (i->rtc_local)
54f8c958 LP	147	printf("\n%s"
	148	"Warning: The system is configured to read the RTC time in the local time zone.\n"
	149	" This mode can not be fully supported. It will create various problems\n"
	150	" with time zone changes and daylight saving time adjustments. The RTC\n"
	151	" time is never updated, it relies on external facilities to maintain it.\n"
	152	" If at all possible, use RTC in UTC by calling\n"
	153	" 'timedatectl set-local-rtc 0'.%s\n", ansi_highlight(), ansi_normal());
6d0274f1 LP	154	}
6d0274f1 LP	155
a281d9c7	156	static int show_status(sd_bus bus, char *args, unsigned n) {
e7e55dbd	157	_cleanup_(status_info_clear) StatusInfo info = {};
9f6eb1cd KS	158	static const struct bus_properties_map map[] = {
	159	{ "Timezone", "s", NULL, offsetof(StatusInfo, timezone) },
	160	{ "LocalRTC", "b", NULL, offsetof(StatusInfo, rtc_local) },
	161	{ "NTP", "b", NULL, offsetof(StatusInfo, ntp_enabled) },
	162	{ "CanNTP", "b", NULL, offsetof(StatusInfo, ntp_capable) },
	163	{ "NTPSynchronized", "b", NULL, offsetof(StatusInfo, ntp_synced) },
	164	{ "TimeUSec", "t", NULL, offsetof(StatusInfo, time) },
	165	{ "RTCTimeUSec", "t", NULL, offsetof(StatusInfo, rtc_time) },
ffc06c35 KS	166	{}
ffc06c35 KS	167	};
f9e0eefc LP	168
f9e0eefc LP	169	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
ffc06c35	170	int r;
6d0274f1	171
a281d9c7	172	assert(bus);
6d0274f1	173
ffc06c35 KS	174	r = bus_map_all_properties(bus,
	175	"org.freedesktop.timedate1",
	176	"/org/freedesktop/timedate1",
9f6eb1cd	177	map,
f9e0eefc	178	&error,
9f6eb1cd	179	&info);
e7e55dbd	180	if (r < 0)
f9e0eefc	181	return log_error_errno(r, "Failed to query server: %s", bus_error_message(&error, r));
6d0274f1 LP	182
6d0274f1 LP	183	print_status_info(&info);
ffc06c35	184
ffc06c35	185	return r;
6d0274f1 LP	186	}
6d0274f1 LP	187
a281d9c7	188	static int set_time(sd_bus bus, char *args, unsigned n) {
4afd3348	189	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
a281d9c7	190	bool relative = false, interactive = arg_ask_password;
6d0274f1	191	usec_t t;
6d0274f1 LP	192	int r;
	193
	194	assert(args);
	195	assert(n == 2);
	196
	197	polkit_agent_open_if_enabled();
	198
	199	r = parse_timestamp(args[1], &t);
	200	if (r < 0) {
	201	log_error("Failed to parse time specification: %s", args[1]);
	202	return r;
	203	}
	204
a281d9c7 TA	205	r = sd_bus_call_method(bus,
	206	"org.freedesktop.timedate1",
	207	"/org/freedesktop/timedate1",
	208	"org.freedesktop.timedate1",
	209	"SetTime",
	210	&error,
	211	NULL,
	212	"xbb", (int64_t)t, relative, interactive);
	213	if (r < 0)
	214	log_error("Failed to set time: %s", bus_error_message(&error, -r));
	215
	216	return r;
6d0274f1 LP	217	}
6d0274f1 LP	218
a281d9c7	219	static int set_timezone(sd_bus bus, char *args, unsigned n) {
4afd3348	220	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
a281d9c7	221	int r;
6d0274f1 LP	222
	223	assert(args);
	224	assert(n == 2);
	225
	226	polkit_agent_open_if_enabled();
	227
a281d9c7 TA	228	r = sd_bus_call_method(bus,
	229	"org.freedesktop.timedate1",
	230	"/org/freedesktop/timedate1",
	231	"org.freedesktop.timedate1",
	232	"SetTimezone",
	233	&error,
	234	NULL,
e5609878	235	"sb", args[1], arg_ask_password);
a281d9c7	236	if (r < 0)
07a062a7	237	log_error("Failed to set time zone: %s", bus_error_message(&error, -r));
a281d9c7 TA	238
a281d9c7 TA	239	return r;
6d0274f1 LP	240	}
6d0274f1 LP	241
a281d9c7	242	static int set_local_rtc(sd_bus bus, char *args, unsigned n) {
4afd3348	243	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
e5609878	244	int r, b;
6d0274f1 LP	245
	246	assert(args);
	247	assert(n == 2);
	248
	249	polkit_agent_open_if_enabled();
	250
e5609878 LP	251	b = parse_boolean(args[1]);
e5609878 LP	252	if (b < 0) {
6d0274f1	253	log_error("Failed to parse local RTC setting: %s", args[1]);
e5609878	254	return b;
6d0274f1 LP	255	}
6d0274f1 LP	256
a281d9c7 TA	257	r = sd_bus_call_method(bus,
	258	"org.freedesktop.timedate1",
	259	"/org/freedesktop/timedate1",
	260	"org.freedesktop.timedate1",
	261	"SetLocalRTC",
	262	&error,
	263	NULL,
e5609878	264	"bbb", b, arg_adjust_system_clock, arg_ask_password);
a281d9c7 TA	265	if (r < 0)
	266	log_error("Failed to set local RTC: %s", bus_error_message(&error, -r));
	267
	268	return r;
6d0274f1 LP	269	}
6d0274f1 LP	270
a281d9c7	271	static int set_ntp(sd_bus bus, char *args, unsigned n) {
4afd3348	272	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
e5609878	273	int b, r;
6d0274f1 LP	274
	275	assert(args);
	276	assert(n == 2);
	277
	278	polkit_agent_open_if_enabled();
	279
e5609878 LP	280	b = parse_boolean(args[1]);
e5609878 LP	281	if (b < 0) {
6d0274f1	282	log_error("Failed to parse NTP setting: %s", args[1]);
e5609878	283	return b;
6d0274f1 LP	284	}
6d0274f1 LP	285
a281d9c7 TA	286	r = sd_bus_call_method(bus,
	287	"org.freedesktop.timedate1",
	288	"/org/freedesktop/timedate1",
	289	"org.freedesktop.timedate1",
	290	"SetNTP",
	291	&error,
	292	NULL,
e5609878	293	"bb", b, arg_ask_password);
a281d9c7 TA	294	if (r < 0)
	295	log_error("Failed to set ntp: %s", bus_error_message(&error, -r));
	296
	297	return r;
6d0274f1 LP	298	}
6d0274f1 LP	299
a281d9c7	300	static int list_timezones(sd_bus bus, char *args, unsigned n) {
6d0274f1	301	_cleanup_strv_free_ char **zones = NULL;
75683450	302	int r;
6d0274f1 LP	303
	304	assert(args);
	305	assert(n == 1);
	306
75683450	307	r = get_timezones(&zones);
f647962d MS	308	if (r < 0)
f647962d MS	309	return log_error_errno(r, "Failed to read list of time zones: %m");
6d0274f1	310
ea4b98e6	311	pager_open(arg_no_pager, false);
7c2d8094	312	strv_print(zones);
6d0274f1 LP	313
	314	return 0;
	315	}
	316
601185b4	317	static void help(void) {
7591abd4 LP	318	printf("%s [OPTIONS...] COMMAND ...\n\n"
7591abd4 LP	319	"Query or change system time and date settings.\n\n"
07a062a7	320	" -h --help Show this help message\n"
4f8f66cb ZJS	321	" --version Show package version\n"
	322	" --no-pager Do not pipe output into a pager\n"
	323	" --no-ask-password Do not prompt for password\n"
	324	" -H --host=[USER@]HOST Operate on remote host\n"
	325	" -M --machine=CONTAINER Operate on local container\n"
	326	" --adjust-system-clock Adjust system clock when changing local RTC mode\n\n"
6d0274f1	327	"Commands:\n"
4f8f66cb ZJS	328	" status Show current time settings\n"
4f8f66cb ZJS	329	" set-time TIME Set system time\n"
07a062a7 JSJ	330	" set-timezone ZONE Set system time zone\n"
07a062a7 JSJ	331	" list-timezones Show known time zones\n"
4f8f66cb	332	" set-local-rtc BOOL Control whether RTC is in local time\n"
3906ab4a	333	" set-ntp BOOL Enable or disable network time synchronization\n",
6d0274f1	334	program_invocation_short_name);
6d0274f1 LP	335	}
	336
	337	static int parse_argv(int argc, char *argv[]) {
	338
	339	enum {
	340	ARG_VERSION = 0x100,
	341	ARG_NO_PAGER,
c9783430	342	ARG_ADJUST_SYSTEM_CLOCK,
6d0274f1 LP	343	ARG_NO_ASK_PASSWORD
	344	};
	345
	346	static const struct option options[] = {
c9783430 LP	347	{ "help", no_argument, NULL, 'h' },
	348	{ "version", no_argument, NULL, ARG_VERSION },
	349	{ "no-pager", no_argument, NULL, ARG_NO_PAGER },
	350	{ "host", required_argument, NULL, 'H' },
a281d9c7	351	{ "machine", required_argument, NULL, 'M' },
c9783430 LP	352	{ "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
c9783430 LP	353	{ "adjust-system-clock", no_argument, NULL, ARG_ADJUST_SYSTEM_CLOCK },
eb9da376	354	{}
6d0274f1 LP	355	};
	356
	357	int c;
	358
	359	assert(argc >= 0);
	360	assert(argv);
	361
601185b4	362	while ((c = getopt_long(argc, argv, "hH:M:", options, NULL)) >= 0)
6d0274f1 LP	363
	364	switch (c) {
	365
	366	case 'h':
601185b4 ZJS	367	help();
601185b4 ZJS	368	return 0;
6d0274f1 LP	369
6d0274f1 LP	370	case ARG_VERSION:
3f6fd1ba	371	return version();
6d0274f1	372
a281d9c7 TA	373	case 'H':
	374	arg_transport = BUS_TRANSPORT_REMOTE;
	375	arg_host = optarg;
6d0274f1 LP	376	break;
6d0274f1 LP	377
a281d9c7	378	case 'M':
de33fc62	379	arg_transport = BUS_TRANSPORT_MACHINE;
a281d9c7	380	arg_host = optarg;
6d0274f1 LP	381	break;
6d0274f1 LP	382
546158bc JJ	383	case ARG_NO_ASK_PASSWORD:
	384	arg_ask_password = false;
	385	break;
	386
c9783430 LP	387	case ARG_ADJUST_SYSTEM_CLOCK:
c9783430 LP	388	arg_adjust_system_clock = true;
6d0274f1 LP	389	break;
	390
	391	case ARG_NO_PAGER:
	392	arg_no_pager = true;
	393	break;
	394
	395	case '?':
	396	return -EINVAL;
	397
	398	default:
eb9da376	399	assert_not_reached("Unhandled option");
6d0274f1	400	}
6d0274f1 LP	401
	402	return 1;
	403	}
	404
a281d9c7	405	static int timedatectl_main(sd_bus bus, int argc, char argv[]) {
6d0274f1 LP	406
	407	static const struct {
	408	const char* verb;
	409	const enum {
	410	MORE,
	411	LESS,
	412	EQUAL
	413	} argc_cmp;
	414	const int argc;
a281d9c7	415	int (* const dispatch)(sd_bus bus, char *args, unsigned n);
6d0274f1 LP	416	} verbs[] = {
	417	{ "status", LESS, 1, show_status },
	418	{ "set-time", EQUAL, 2, set_time },
	419	{ "set-timezone", EQUAL, 2, set_timezone },
	420	{ "list-timezones", EQUAL, 1, list_timezones },
	421	{ "set-local-rtc", EQUAL, 2, set_local_rtc },
	422	{ "set-ntp", EQUAL, 2, set_ntp, },
	423	};
	424
	425	int left;
	426	unsigned i;
	427
	428	assert(argc >= 0);
	429	assert(argv);
6d0274f1 LP	430
	431	left = argc - optind;
	432
	433	if (left <= 0)
	434	/* Special rule: no arguments means "status" */
	435	i = 0;
	436	else {
	437	if (streq(argv[optind], "help")) {
	438	help();
	439	return 0;
	440	}
	441
	442	for (i = 0; i < ELEMENTSOF(verbs); i++)
	443	if (streq(argv[optind], verbs[i].verb))
	444	break;
	445
	446	if (i >= ELEMENTSOF(verbs)) {
	447	log_error("Unknown operation %s", argv[optind]);
	448	return -EINVAL;
	449	}
	450	}
	451
	452	switch (verbs[i].argc_cmp) {
	453
	454	case EQUAL:
	455	if (left != verbs[i].argc) {
	456	log_error("Invalid number of arguments.");
	457	return -EINVAL;
	458	}
	459
	460	break;
	461
	462	case MORE:
	463	if (left < verbs[i].argc) {
	464	log_error("Too few arguments.");
	465	return -EINVAL;
	466	}
	467
	468	break;
	469
	470	case LESS:
	471	if (left > verbs[i].argc) {
	472	log_error("Too many arguments.");
	473	return -EINVAL;
	474	}
	475
	476	break;
	477
	478	default:
	479	assert_not_reached("Unknown comparison operator.");
	480	}
	481
6d0274f1 LP	482	return verbs[i].dispatch(bus, argv + optind, left);
	483	}
	484
	485	int main(int argc, char *argv[]) {
cf647b69	486	sd_bus *bus = NULL;
84f6181c	487	int r;
6d0274f1	488
a9cdc94f	489	setlocale(LC_ALL, "");
6d0274f1 LP	490	log_parse_environment();
	491	log_open();
	492
	493	r = parse_argv(argc, argv);
84f6181c	494	if (r <= 0)
6d0274f1	495	goto finish;
6d0274f1	496
266f3e26	497	r = bus_connect_transport(arg_transport, arg_host, false, &bus);
a281d9c7	498	if (r < 0) {
da927ba9	499	log_error_errno(r, "Failed to create bus connection: %m");
a281d9c7	500	goto finish;
6d0274f1 LP	501	}
6d0274f1 LP	502
a281d9c7	503	r = timedatectl_main(bus, argc, argv);
6d0274f1	504
a281d9c7	505	finish:
cf647b69	506	sd_bus_flush_close_unref(bus);
6d0274f1 LP	507	pager_close();
6d0274f1 LP	508
84f6181c	509	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
6d0274f1	510	}