OSS/slack-timedate
1
0
Fork 0
Code Issues Pull Requests Actions Releases 2 Activity
81232f6104
slack-timedate/slack-timedate.cpp

275 lines
8.3 KiB
C++
Raw Blame History

/*
* Copyright (C) 2013-2024 Eugen Wissner <belka@caraus.de>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include <cstring>
#include <filesystem>
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/stat.h>
#include "slack-timedate.h"
static void slack_method_call (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data) {
gchar *timezone, *response;
gboolean user_interaction, relative, is_localtime, use_ntp;
gint64 usec_utc;
// Set time zone
if (g_strcmp0 (method_name, "SetTimezone") == 0) {
g_variant_get (parameters, "(&sb)", &timezone, &user_interaction);
if (slack_set_timezone (timezone)) g_dbus_method_invocation_return_value (invocation,
NULL);
else g_dbus_method_invocation_return_error (invocation,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Write operation failed");
g_free (timezone);
} else if (g_strcmp0 (method_name, "SetTime") == 0) {
g_variant_get (parameters, "(xbb)", &usec_utc, &relative, &user_interaction);
// Set time
//if (!slack_set_time (usec_utc, slack_get_is_localtime ())) {
if (slack_set_time(usec_utc, relative))
{
g_dbus_method_invocation_return_value(invocation, NULL);
}
else
{
g_dbus_method_invocation_return_error(invocation, G_IO_ERROR, G_IO_ERROR_FAILED,
"Failed to set system clock");
}
} else if (g_strcmp0 (method_name, "SetNTP") == 0) {
g_variant_get (parameters, "(bb)", &use_ntp, &user_interaction);
// Enable NTP
if (slack_set_ntp (use_ntp)) g_dbus_method_invocation_return_value (invocation,
NULL);
else g_dbus_method_invocation_return_error (invocation,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Error enabling NTP");
}
return;
}
static GVariant *slack_get_property (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *prop_name, GError **slack_err, gpointer user_data) {
if (g_strcmp0 ("Timezone", prop_name) == 0) {
return g_variant_new_string (slack_get_timezone ());
} if (g_strcmp0 ("LocalRTC", prop_name) == 0) {
return g_variant_new_boolean (slack_get_is_localtime ());
} if (g_strcmp0 ("NTP", prop_name) == 0) {
return g_variant_new_boolean (slack_get_ntp ());
}
return NULL;
}
static void on_timedate_acquired (GDBusConnection *connection, const gchar *name, gpointer user_data) {
guint registration_id;
GDBusNodeInfo *introspection_data;
GError *slack_err;
const GDBusInterfaceVTable interface_vtable = {
slack_method_call,
slack_get_property,
NULL
};
slack_err = NULL;
introspection_data = g_dbus_node_info_new_for_xml (INTROSPECTION_XML, &slack_err);
if (introspection_data == NULL)
g_error ("Failed to parse D-Bus introspection XML: %s\n", slack_err->message);
slack_err = NULL;
registration_id = g_dbus_connection_register_object (connection,
BUS_PATH,
introspection_data->interfaces[0],
&interface_vtable,
NULL,
NULL,
&slack_err);
if (registration_id <= 0) {
g_critical ("Failed to register callbacks for the exported object with the D-Bus interface: %s\n", slack_err->message);
g_error_free (slack_err);
}
g_dbus_node_info_unref (introspection_data);
}
static void on_timedate_lost (GDBusConnection *connection, const gchar *name, gpointer user_data) {
g_warning ("Failed to acquire the service %s.\n", name);
exit (1);
}
gboolean timeout_callback (Glib::RefPtr<Glib::MainLoop> loop2quit) {
loop2quit->quit();
return false;
}
int main(int argc, char **argv)
{
guint owner_id = g_bus_own_name (G_BUS_TYPE_SYSTEM,
BUS_NAME,
static_cast<GBusNameOwnerFlags>(G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE),
on_timedate_acquired,
NULL,
on_timedate_lost,
NULL,
NULL);
Glib::RefPtr<Glib::MainLoop> loop = Glib::MainLoop::create(false);
Glib::signal_timeout().connect_seconds(sigc::bind(&timeout_callback, loop), DEFAULT_EXIT_SEC);
loop->run();
g_bus_unown_name (owner_id);
return EXIT_SUCCESS;
}
gchar *slack_get_timezone () {
gchar *zone_copied_from, *zone;
zone_copied_from = g_file_read_link ("/etc/localtime-copied-from", NULL);
if (zone_copied_from == NULL) return NULL;
zone = g_strdup (zone_copied_from + strlen ("/usr/share/zoneinfo/") * sizeof (gchar));
g_free (zone_copied_from);
return zone;
}
gboolean slack_set_timezone (gchar *zone) {
gchar *zone_file;
GFile *etc_localtime, *localtime_link, *g_zone_file;
zone_file = g_strconcat ("/usr/share/zoneinfo/", zone, NULL);
if (Glib::file_test(zone_file, Glib::FILE_TEST_IS_REGULAR))
{
etc_localtime = g_file_new_for_path ("/etc/localtime");
localtime_link = g_file_new_for_path ("/etc/localtime-copied-from");
g_zone_file = g_file_new_for_path (zone_file);
if (!g_file_copy (g_zone_file, etc_localtime, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, NULL)) {
return FALSE;
}
if (!g_file_delete (localtime_link, NULL, NULL)) {
return FALSE;
}
if (!g_file_make_symbolic_link (localtime_link, zone_file, NULL, NULL)) {
return FALSE;
}
g_free (zone_file);
g_object_unref (etc_localtime);
g_object_unref (localtime_link);
g_object_unref (g_zone_file);
return true;
}
return false;
}
gboolean slack_set_time(gint64 seconds_since_epoch, gboolean relative)
{
timespec ts;
if (relative)
{
if (clock_gettime(CLOCK_REALTIME, &ts) == -1)
{
return FALSE;
}
ts.tv_sec += static_cast<time_t>(seconds_since_epoch / USEC_PER_SEC);
ts.tv_nsec += (seconds_since_epoch % USEC_PER_SEC) * NSEC_PER_USEC;
if (ts.tv_nsec < 0)
{
--ts.tv_sec;
ts.tv_nsec += USEC_PER_SEC;
}
}
else
{
ts.tv_sec = static_cast<time_t>(seconds_since_epoch / USEC_PER_SEC);
ts.tv_nsec = (seconds_since_epoch % USEC_PER_SEC) * NSEC_PER_USEC;
}
return clock_settime (CLOCK_REALTIME, &ts) == 0;
}
gboolean slack_get_is_localtime()
{
std::ifstream fh{ "/etc/hardwareclock", std::ios::in };
if (!fh.is_open())
{
return false;
}
std::array<char, 10> time_str; // "localtime" is longer than "UTC" and has 9 letters + \0
while (fh.good())
{
fh.getline(time_str.data(), time_str.size());
fh.clear(fh.rdstate() & (~std::ios_base::failbit));
if (std::strncmp(time_str.data(), "localtime", time_str.size()) == 0)
{
return true;
}
}
return false;
}
gboolean slack_get_ntp()
{
return Glib::file_test("/etc/rc.d/rc.ntpd", Glib::FileTest::FILE_TEST_IS_EXECUTABLE);
}
gboolean slack_set_ntp(gboolean xntp)
{
std::filesystem::perms rc_mode = std::filesystem::perms::owner_read | std::filesystem::perms::owner_write
| std::filesystem::perms::group_read | std::filesystem::perms::others_read;
if (xntp)
{
rc_mode |= std::filesystem::perms::owner_exec
| std::filesystem::perms::group_exec | std::filesystem::perms::others_exec;
g_message("Please don't forget to configure the NTP daemon");
/* It doesn't matter if fails.
* The ntpdate command is considered obsolete, but "orthodox" ntpd -g
* will fail if your system clock is off for more than half an hour. */
g_spawn_command_line_async("/usr/sbin/ntpdate pool.ntp.org", NULL);
}
if (Glib::file_test("/etc/rc.d/rc.ntpd", Glib::FileTest::FILE_TEST_IS_REGULAR))
{
std::error_code ec;
std::filesystem::permissions("/etc/rc.d/rc.ntpd", rc_mode, ec);
return !ec;
}
else
{
g_error("The NTP daemon isn't installed");
return false;
}
}
Reference in New Issue View Git Blame Copy Permalink