src/timesync/timesyncd-bus.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <sys/capability.h>
   4
   5 #include "sd-bus.h"
   6
   7 #include "alloc-util.h"
   8 #include "bus-get-properties.h"
   9 #include "bus-internal.h"
  10 #include "bus-log-control-api.h"
  11 #include "bus-polkit.h"
  12 #include "bus-protocol.h"
  13 #include "bus-util.h"
  14 #include "dns-domain.h"
  15 #include "in-addr-util.h"
  16 #include "log.h"
  17 #include "macro.h"
  18 #include "strv.h"
  19 #include "time-util.h"
  20 #include "timesyncd-bus.h"
  21 #include "user-util.h"
  22
  23 static int property_get_servers(
  24                 sd_bus *bus,
  25                 const char *path,
  26                 const char *interface,
  27                 const char *property,
  28                 sd_bus_message *reply,
  29                 void *userdata,
  30                 sd_bus_error *error) {
  31
  32         ServerName **s = ASSERT_PTR(userdata);
  33         int r;
  34
  35         assert(bus);
  36         assert(reply);
  37
  38         r = sd_bus_message_open_container(reply, 'a', "s");
  39         if (r < 0)
  40                 return r;
  41
  42         LIST_FOREACH(names, p, *s) {
  43                 r = sd_bus_message_append(reply, "s", p->string);
  44                 if (r < 0)
  45                         return r;
  46         }
  47
  48         return sd_bus_message_close_container(reply);
  49 }
  50
  51 static int method_set_runtime_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
  52         _cleanup_strv_free_ char **msg_names = NULL;
  53         Manager *m = ASSERT_PTR(userdata);
  54         int r;
  55
  56         assert(message);
  57
  58         r = sd_bus_message_read_strv(message, &msg_names);
  59         if (r < 0)
  60                 return r;
  61
  62         STRV_FOREACH(name, msg_names) {
  63                 r = dns_name_is_valid_or_address(*name);
  64                 if (r < 0)
  65                         return log_error_errno(r, "Failed to check validity of NTP server name or address '%s': %m", *name);
  66                 if (r == 0)
  67                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid NTP server name or address, refusing: %s", *name);
  68         }
  69
  70         r = bus_verify_polkit_async(
  71                         message,
  72                         "org.freedesktop.timesync1.set-runtime-servers",
  73                         /* details= */ NULL,
  74                         &m->polkit_registry,
  75                         error);
  76         if (r < 0)
  77                 return r;
  78         if (r == 0)
  79                 /* Polkit will call us back */
  80                 return 1;
  81
  82         manager_flush_runtime_servers(m);
  83
  84         STRV_FOREACH(name, msg_names) {
  85                 r = server_name_new(m, NULL, SERVER_RUNTIME, *name);
  86                 if (r < 0) {
  87                         manager_flush_runtime_servers(m);
  88
  89                         return log_error_errno(r, "Failed to add runtime server '%s': %m", *name);
  90                 }
  91         }
  92
  93         m->exhausted_servers = true;
  94         manager_set_server_name(m, NULL);
  95         (void) manager_connect(m);
  96
  97         return sd_bus_reply_method_return(message, NULL);
  98 }
  99
 100 static int property_get_current_server_name(
 101                 sd_bus *bus,
 102                 const char *path,
 103                 const char *interface,
 104                 const char *property,
 105                 sd_bus_message *reply,
 106                 void *userdata,
 107                 sd_bus_error *error) {
 108
 109         ServerName **s = ASSERT_PTR(userdata);
 110
 111         assert(bus);
 112         assert(reply);
 113
 114         return sd_bus_message_append(reply, "s", *s ? (*s)->string : NULL);
 115 }
 116
 117 static int property_get_current_server_address(
 118                 sd_bus *bus,
 119                 const char *path,
 120                 const char *interface,
 121                 const char *property,
 122                 sd_bus_message *reply,
 123                 void *userdata,
 124                 sd_bus_error *error) {
 125
 126         ServerAddress *a;
 127         int r;
 128
 129         assert(bus);
 130         assert(reply);
 131         assert(userdata);
 132
 133         a = *(ServerAddress **) userdata;
 134
 135         if (!a)
 136                 return sd_bus_message_append(reply, "(iay)", AF_UNSPEC, 0);
 137
 138         assert(IN_SET(a->sockaddr.sa.sa_family, AF_INET, AF_INET6));
 139
 140         r = sd_bus_message_open_container(reply, 'r', "iay");
 141         if (r < 0)
 142                 return r;
 143
 144         r = sd_bus_message_append(reply, "i", a->sockaddr.sa.sa_family);
 145         if (r < 0)
 146                 return r;
 147
 148         r = sd_bus_message_append_array(reply, 'y',
 149                                         a->sockaddr.sa.sa_family == AF_INET ? (void*) &a->sockaddr.in.sin_addr : (void*) &a->sockaddr.in6.sin6_addr,
 150                                         FAMILY_ADDRESS_SIZE(a->sockaddr.sa.sa_family));
 151         if (r < 0)
 152                 return r;
 153
 154         return sd_bus_message_close_container(reply);
 155 }
 156
 157 static usec_t ntp_ts_short_to_usec(const struct ntp_ts_short *ts) {
 158         return be16toh(ts->sec) * USEC_PER_SEC + (be16toh(ts->frac) * USEC_PER_SEC) / (usec_t) 0x10000ULL;
 159 }
 160
 161 static usec_t ntp_ts_to_usec(const struct ntp_ts *ts) {
 162         return (be32toh(ts->sec) - OFFSET_1900_1970) * USEC_PER_SEC + (be32toh(ts->frac) * USEC_PER_SEC) / (usec_t) 0x100000000ULL;
 163 }
 164
 165 static int property_get_ntp_message(
 166                 sd_bus *bus,
 167                 const char *path,
 168                 const char *interface,
 169                 const char *property,
 170                 sd_bus_message *reply,
 171                 void *userdata,
 172                 sd_bus_error *error) {
 173
 174         Manager *m = ASSERT_PTR(userdata);
 175         int r;
 176
 177         assert(reply);
 178
 179         r = sd_bus_message_open_container(reply, 'r', "uuuuittayttttbtt");
 180         if (r < 0)
 181                 return r;
 182
 183         r = sd_bus_message_append(reply, "uuuuitt",
 184                                   NTP_FIELD_LEAP(m->ntpmsg.field),
 185                                   NTP_FIELD_VERSION(m->ntpmsg.field),
 186                                   NTP_FIELD_MODE(m->ntpmsg.field),
 187                                   m->ntpmsg.stratum,
 188                                   m->ntpmsg.precision,
 189                                   ntp_ts_short_to_usec(&m->ntpmsg.root_delay),
 190                                   ntp_ts_short_to_usec(&m->ntpmsg.root_dispersion));
 191         if (r < 0)
 192                 return r;
 193
 194         r = sd_bus_message_append_array(reply, 'y', m->ntpmsg.refid, 4);
 195         if (r < 0)
 196                 return r;
 197
 198         r = sd_bus_message_append(reply, "ttttbtt",
 199                                   timespec_load(&m->origin_time),
 200                                   ntp_ts_to_usec(&m->ntpmsg.recv_time),
 201                                   ntp_ts_to_usec(&m->ntpmsg.trans_time),
 202                                   timespec_load(&m->dest_time),
 203                                   m->spike,
 204                                   m->packet_count,
 205                                   (usec_t) (m->samples_jitter * USEC_PER_SEC));
 206         if (r < 0)
 207                 return r;
 208
 209         return sd_bus_message_close_container(reply);
 210 }
 211
 212 static const sd_bus_vtable manager_vtable[] = {
 213         SD_BUS_VTABLE_START(0),
 214
 215         SD_BUS_PROPERTY("LinkNTPServers", "as", property_get_servers, offsetof(Manager, link_servers), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 216         SD_BUS_PROPERTY("SystemNTPServers", "as", property_get_servers, offsetof(Manager, system_servers), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 217         SD_BUS_PROPERTY("RuntimeNTPServers", "as", property_get_servers, offsetof(Manager, runtime_servers), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 218         SD_BUS_PROPERTY("FallbackNTPServers", "as", property_get_servers, offsetof(Manager, fallback_servers), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 219         SD_BUS_PROPERTY("ServerName", "s", property_get_current_server_name, offsetof(Manager, current_server_name), 0),
 220         SD_BUS_PROPERTY("ServerAddress", "(iay)", property_get_current_server_address, offsetof(Manager, current_server_address), 0),
 221         SD_BUS_PROPERTY("RootDistanceMaxUSec", "t", bus_property_get_usec, offsetof(Manager, root_distance_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 222         SD_BUS_PROPERTY("PollIntervalMinUSec", "t", bus_property_get_usec, offsetof(Manager, poll_interval_min_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 223         SD_BUS_PROPERTY("PollIntervalMaxUSec", "t", bus_property_get_usec, offsetof(Manager, poll_interval_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 224         SD_BUS_PROPERTY("PollIntervalUSec", "t", bus_property_get_usec, offsetof(Manager, poll_interval_usec), 0),
 225         SD_BUS_PROPERTY("NTPMessage", "(uuuuittayttttbtt)", property_get_ntp_message, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 226         SD_BUS_PROPERTY("Frequency", "x", NULL, offsetof(Manager, drift_freq), 0),
 227
 228         SD_BUS_METHOD_WITH_ARGS("SetRuntimeNTPServers",
 229                                 SD_BUS_ARGS("as", runtime_servers),
 230                                 SD_BUS_NO_RESULT,
 231                                 method_set_runtime_servers,
 232                                 SD_BUS_VTABLE_UNPRIVILEGED),
 233
 234         SD_BUS_VTABLE_END
 235 };
 236
 237 int manager_connect_bus(Manager *m) {
 238         int r;
 239
 240         assert(m);
 241
 242         if (m->bus)
 243                 return 0;
 244
 245         r = bus_open_system_watch_bind_with_description(&m->bus, "bus-api-timesync");
 246         if (r < 0)
 247                 return log_error_errno(r, "Failed to connect to bus: %m");
 248
 249         r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/timesync1", "org.freedesktop.timesync1.Manager", manager_vtable, m);
 250         if (r < 0)
 251                 return log_error_errno(r, "Failed to add manager object vtable: %m");
 252
 253         r = bus_log_control_api_register(m->bus);
 254         if (r < 0)
 255                 return r;
 256
 257         r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.timesync1", 0, NULL, NULL);
 258         if (r < 0)
 259                 return log_error_errno(r, "Failed to request name: %m");
 260
 261         r = sd_bus_attach_event(m->bus, m->event, 0);
 262         if (r < 0)
 263                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 264
 265         return 0;
 266 }