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

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  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 <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <getopt.h>
#include <locale.h>
#include <string.h>
#include <sys/timex.h>

#include "sd-bus.h"
#include "bus-util.h"
#include "bus-error.h"
#include "util.h"
#include "spawn-polkit-agent.h"
#include "build.h"
#include "strv.h"
#include "pager.h"
#include "time-dst.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 pager_open_if_enabled(void) {

        if (arg_no_pager)
                return;

        pager_open(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;
        bool rtc_local;

        bool ntp_enabled;
        bool ntp_capable;
        bool ntp_synced;
} StatusInfo;

static const char *jump_str(int delta_minutes, char *s, size_t size) {
        if (delta_minutes == 60)
                return "one hour forward";
        if (delta_minutes == -60)
                return "one hour backwards";
        if (delta_minutes < 0) {
                snprintf(s, size, "%i minutes backwards", -delta_minutes);
                return s;
        }
        if (delta_minutes > 0) {
                snprintf(s, size, "%i minutes forward", delta_minutes);
                return s;
        }
        return "";
}

static void print_status_info(const StatusInfo *i) {
        char a[FORMAT_TIMESTAMP_MAX];
        char b[FORMAT_TIMESTAMP_MAX];
        char s[32];
        struct tm tm;
        time_t sec;
        bool have_time = false;
        _cleanup_free_ char *zc = NULL, *zn = NULL;
        time_t t, tc, tn;
        int dn = 0;
        bool is_dstc = false, is_dstn = false;
        int r;

        assert(i);

        /* Enforce the values of /etc/localtime */
        if (getenv("TZ")) {
                fprintf(stderr, "Warning: Ignoring the TZ variable. Reading the system's time zone setting only.\n\n");
                unsetenv("TZ");
        }

        if (i->time != 0) {
                sec = (time_t) (i->time / USEC_PER_SEC);
                have_time = true;
        } else if (arg_transport == BUS_TRANSPORT_LOCAL) {
                sec = time(NULL);
                have_time = true;
        } else
                fprintf(stderr, "Warning: Could not get time from timedated and not operating locally.\n\n");

        if (have_time) {
                zero(tm);
                assert_se(strftime(a, sizeof(a), "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&sec, &tm)) > 0);
                char_array_0(a);
                printf("      Local time: %s\n", a);

                zero(tm);
                assert_se(strftime(a, sizeof(a), "%a %Y-%m-%d %H:%M:%S UTC", gmtime_r(&sec, &tm)) > 0);
                char_array_0(a);
                printf("  Universal time: %s\n", 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);
                zero(tm);
                assert_se(strftime(a, sizeof(a), "%a %Y-%m-%d %H:%M:%S", gmtime_r(&rtc_sec, &tm)) > 0);
                char_array_0(a);
                printf("        RTC time: %s\n", a);
        } else
                printf("        RTC time: %s\n", "n/a");

        if (have_time) {
                zero(tm);
                assert_se(strftime(a, sizeof(a), "%Z, %z", localtime_r(&sec, &tm)) > 0);
                char_array_0(a);
        }

        printf("       Time zone: %s (%s)\n"
               "     NTP enabled: %s\n"
               "NTP synchronized: %s\n"
               " RTC in local TZ: %s\n",
               strna(i->timezone), 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 (have_time) {
                r = time_get_dst(sec, "/etc/localtime",
                                 &tc, &zc, &is_dstc,
                                 &tn, &dn, &zn, &is_dstn);
                if (r < 0)
                        printf("      DST active: %s\n", "n/a");
                else {
                        printf("      DST active: %s\n", yes_no(is_dstc));

                        t = tc - 1;
                        zero(tm);
                        assert_se(strftime(a, sizeof(a), "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&t, &tm)) > 0);
                        char_array_0(a);

                        zero(tm);
                        assert_se(strftime(b, sizeof(b), "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&tc, &tm)) > 0);
                        char_array_0(b);
                        printf(" Last DST change: DST %s at\n"
                               "                  %s\n"
                               "                  %s\n",
                               is_dstc ? "began" : "ended", a, b);

                        t = tn - 1;
                        zero(tm);
                        assert_se(strftime(a, sizeof(a), "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&t, &tm)) > 0);
                        char_array_0(a);

                        zero(tm);
                        assert_se(strftime(b, sizeof(b), "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&tn, &tm)) > 0);
                        char_array_0(b);
                        printf(" Next DST change: DST %s (the clock jumps %s) at\n"
                               "                  %s\n"
                               "                  %s\n",
                               is_dstn ? "begins" : "ends", jump_str(dn, s, sizeof(s)), a, b);
                }
        } else
                printf("      DST active: %s\n", yes_no(is_dstc));

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

static int show_status(sd_bus *bus, char **args, unsigned n) {
        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) },
                {}
        };
        int r;

        assert(bus);

        r = bus_map_all_properties(bus,
                                   "org.freedesktop.timedate1",
                                   "/org/freedesktop/timedate1",
                                   map,
                                   &info);
        if (r < 0) {
                log_error_errno(r, "Failed to query server: %m");
                goto fail;
        }

        print_status_info(&info);

fail:
        free(info.timezone);
        return r;
}

static int set_time(sd_bus *bus, char **args, unsigned n) {
        _cleanup_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_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_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_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_if_enabled();
        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             Control whether NTP is enabled\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:
                        puts(PACKAGE_STRING);
                        puts(SYSTEMD_FEATURES);
                        return 0;

                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[]) {
        _cleanup_bus_close_unref_ 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_open_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:
        pager_close();

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