HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/timesync/timesyncd-manager.c
Git blob: 4b3978bebc7f40dbc62c944cadee4b6e370e61be
Lines 1001–1420 of 1,420
/* Tell the resolver to reread /etc/resolv.conf, in
* case it changed. */
res_init();
struct addrinfo hints = {
.ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
.ai_socktype = SOCK_DGRAM,
.ai_family = socket_ipv6_is_enabled() ? AF_UNSPEC : AF_INET,
};
r = resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, NULL, m);
if (r < 0)
return log_error_errno(r, "Failed to create resolver: %m");
return 1;
}
r = manager_begin(m);
if (r < 0)
return r;
return 1;
}
void manager_disconnect(Manager *m) {
assert(m);
m->resolve_query = sd_resolve_query_unref(m->resolve_query);
m->resolve_varlink = sd_varlink_close_unref(m->resolve_varlink);
m->event_timer = sd_event_source_unref(m->event_timer);
manager_listen_stop(m);
m->event_clock_watch = sd_event_source_disable_unref(m->event_clock_watch);
m->event_timeout = sd_event_source_unref(m->event_timeout);
(void) sd_notify(false, "STATUS=Idle.");
}
void manager_flush_server_names(Manager *m, ServerType t) {
assert(m);
if (t == SERVER_SYSTEM)
while (m->system_servers)
server_name_free(m->system_servers);
if (t == SERVER_LINK)
while (m->link_servers)
server_name_free(m->link_servers);
if (t == SERVER_FALLBACK)
while (m->fallback_servers)
server_name_free(m->fallback_servers);
if (t == SERVER_RUNTIME)
manager_flush_runtime_servers(m);
}
void manager_flush_runtime_servers(Manager *m) {
assert(m);
while (m->runtime_servers)
server_name_free(m->runtime_servers);
}
Manager* manager_free(Manager *m) {
if (!m)
return NULL;
manager_disconnect(m);
manager_flush_server_names(m, SERVER_SYSTEM);
manager_flush_server_names(m, SERVER_LINK);
manager_flush_server_names(m, SERVER_RUNTIME);
manager_flush_server_names(m, SERVER_FALLBACK);
sd_event_source_unref(m->event_retry);
sd_event_source_unref(m->network_event_source);
sd_network_monitor_unref(m->network_monitor);
sd_event_source_unref(m->event_save_time);
sd_event_source_unref(m->deferred_ntp_server_event_source);
sd_resolve_unref(m->resolve);
sd_event_unref(m->event);
sd_bus_flush_close_unref(m->bus);
hashmap_free(m->polkit_registry);
return mfree(m);
}
static bool manager_network_read_link_servers(Manager *m) {
_cleanup_strv_free_ char **ntp = NULL;
bool changed = false;
int r;
assert(m);
bool existing = m->link_servers;
r = sd_network_get_ntp(&ntp);
if (r < 0) {
if (!IN_SET(r, -ENOENT, -ENODATA))
log_error_errno(r, "Failed to get link NTP servers: %m");
goto clear;
}
LIST_FOREACH(names, n, m->link_servers)
n->marked = true;
STRV_FOREACH(i, ntp) {
bool found = false;
r = dns_name_is_valid_or_address(*i);
if (r < 0) {
log_error_errno(r, "Failed to check validity of NTP server name or address '%s': %m", *i);
goto clear;
} else if (r == 0) {
log_error("Invalid NTP server name or address, ignoring: %s", *i);
continue;
}
LIST_FOREACH(names, n, m->link_servers)
if (streq(n->string, *i)) {
n->marked = false;
found = true;
break;
}
if (!found) {
r = server_name_new(m, NULL, SERVER_LINK, *i);
if (r < 0) {
log_oom();
goto clear;
}
changed = true;
}
}
LIST_FOREACH(names, n, m->link_servers)
if (n->marked) {
server_name_free(n);
changed = true;
}
return changed;
clear:
manager_flush_server_names(m, SERVER_LINK);
return existing; /* return true if there were existing servers. */
}
static bool manager_is_connected(Manager *m) {
assert(m);
/* Return true when the manager is sending a request, resolving a server name, or
* in a poll interval. */
return m->server_socket >= 0 || m->resolve_query || m->resolve_varlink || m->event_timer;
}
static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
bool changed, connected, online;
int r;
sd_network_monitor_flush(m->network_monitor);
changed = manager_network_read_link_servers(m);
/* check if the machine is online */
online = network_is_online();
/* check if the client is currently connected */
connected = manager_is_connected(m);
if (connected && !online) {
/* When m->talking is false, we have not received any responses from the server,
* and it is not necessary to log about disconnection. */
log_full(m->talking ? LOG_INFO : LOG_DEBUG,
"No network connectivity, watching for changes.");
manager_disconnect(m);
} else if ((!connected || changed) && online) {
log_full(connected ? LOG_DEBUG : LOG_INFO,
"Network configuration changed, trying to establish connection.");
if (m->current_server_address)
r = manager_begin(m);
else
r = manager_connect(m);
if (r < 0)
return r;
}
return 0;
}
static int manager_network_monitor_listen(Manager *m) {
int r, fd, events;
assert(m);
r = sd_network_monitor_new(&m->network_monitor, NULL);
if (r == -ENOENT) {
log_info("systemd does not appear to be running, not listening for systemd-networkd events.");
return 0;
}
if (r < 0)
return r;
fd = sd_network_monitor_get_fd(m->network_monitor);
if (fd < 0)
return fd;
events = sd_network_monitor_get_events(m->network_monitor);
if (events < 0)
return events;
r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
if (r < 0)
return r;
return 0;
}
int manager_new(Manager **ret) {
_cleanup_(manager_freep) Manager *m = NULL;
int r;
assert(ret);
m = new(Manager, 1);
if (!m)
return -ENOMEM;
*m = (Manager) {
.root_distance_max_usec = NTP_ROOT_DISTANCE_MAX_USEC,
.poll_interval_min_usec = NTP_POLL_INTERVAL_MIN_USEC,
.poll_interval_max_usec = NTP_POLL_INTERVAL_MAX_USEC,
.connection_retry_usec = DEFAULT_CONNECTION_RETRY_USEC,
.server_socket = -EBADF,
.ratelimit = (const RateLimit) {
RATELIMIT_INTERVAL_USEC,
RATELIMIT_BURST
},
.save_time_interval_usec = DEFAULT_SAVE_TIME_INTERVAL_USEC,
};
r = sd_event_default(&m->event);
if (r < 0)
return r;
r = sd_event_set_signal_exit(m->event, true);
if (r < 0)
return r;
r = sd_event_add_signal(m->event, /* ret= */ NULL, (SIGRTMIN+18)|SD_EVENT_SIGNAL_PROCMASK, sigrtmin18_handler, /* userdata= */ NULL);
if (r < 0)
log_debug_errno(r, "Failed to install SIGRTMIN+18 signal handler, ignoring: %m");
r = sd_event_add_memory_pressure(m->event, NULL, NULL, NULL);
if (r < 0)
log_debug_errno(r, "Failed to allocate memory pressure event source, ignoring: %m");
r = sd_event_set_watchdog(m->event, true);
if (r < 0)
log_debug_errno(r, "Failed to enable watchdog handling, ignoring: %m");
/* Load previous synchronization state */
r = access("/run/systemd/timesync/synchronized", F_OK);
if (r < 0 && errno != ENOENT)
log_debug_errno(errno, "Failed to determine whether /run/systemd/timesync/synchronized exists, ignoring: %m");
m->synchronized = r >= 0;
r = sd_resolve_default(&m->resolve);
if (r < 0)
return r;
r = sd_resolve_attach_event(m->resolve, m->event, 0);
if (r < 0)
return r;
r = manager_network_monitor_listen(m);
if (r < 0)
return r;
(void) manager_network_read_link_servers(m);
*ret = TAKE_PTR(m);
return 0;
}
static int manager_save_time_handler(sd_event_source *s, uint64_t usec, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
(void) manager_save_time_and_rearm(m, USEC_INFINITY);
return 0;
}
int manager_setup_save_time_event(Manager *m) {
int r;
assert(m);
if (m->save_time_interval_usec == USEC_INFINITY)
return 0;
/* NB: we'll accumulate scheduling latencies here, but this doesn't matter */
r = event_reset_time_relative(
m->event,
&m->event_save_time,
CLOCK_BOOTTIME,
m->save_time_interval_usec,
10 * USEC_PER_SEC,
manager_save_time_handler,
m,
SD_EVENT_PRIORITY_NORMAL,
"save-time",
/* force_reset= */ false);
if (r < 0)
return log_error_errno(r, "Failed to reset event source for saving time: %m");
return 0;
}
static int manager_save_time_and_rearm(Manager *m, usec_t t) {
int r;
assert(m);
/* Updates the timestamp file to the specified time. If 't' is USEC_INFINITY uses the current system
* clock, but otherwise uses the specified timestamp. Note that whenever we acquire an NTP sync the
* specified timestamp value might be more accurate than the system clock, since the latter is
* subject to slow adjustments. */
r = touch_file(TIMESYNCD_CLOCK_FILE, /* parents= */ false, t, UID_INVALID, GID_INVALID, MODE_INVALID);
if (r < 0)
log_debug_errno(r, "Failed to update "TIMESYNCD_CLOCK_FILE", ignoring: %m");
return manager_setup_save_time_event(m);
}
static const char* ntp_server_property_name[_SERVER_TYPE_MAX] = {
[SERVER_SYSTEM] = "SystemNTPServers",
[SERVER_FALLBACK] = "FallbackNTPServers",
[SERVER_LINK] = "LinkNTPServers",
[SERVER_RUNTIME] = "RuntimeNTPServers",
};
static int ntp_server_emit_changed_strv(Manager *manager, char **properties) {
assert(manager);
assert(properties);
if (sd_bus_is_ready(manager->bus) <= 0)
return 0;
return sd_bus_emit_properties_changed_strv(
manager->bus,
"/org/freedesktop/timesync1",
"org.freedesktop.timesync1.Manager",
properties);
}
static int on_deferred_ntp_server(sd_event_source *s, void *userdata) {
int r;
_cleanup_strv_free_ char **p = NULL;
Manager *m = ASSERT_PTR(userdata);
m->deferred_ntp_server_event_source = sd_event_source_disable_unref(m->deferred_ntp_server_event_source);
for (int type = SERVER_SYSTEM; type < _SERVER_TYPE_MAX; type++)
if (m->ntp_server_change_mask & (1U << type))
if (strv_extend(&p, ntp_server_property_name[type]) < 0)
log_oom();
m->ntp_server_change_mask = 0;
if (strv_isempty(p))
return log_error_errno(SYNTHETIC_ERRNO(ENOMEM), "Failed to build ntp server event strv!");
r = ntp_server_emit_changed_strv(m, p);
if (r < 0)
log_warning_errno(r, "Could not emit ntp server changed properties, ignoring: %m");
return 0;
}
int bus_manager_emit_ntp_server_changed(Manager *m) {
int r;
assert(m);
if (m->deferred_ntp_server_event_source)
return 0;
if (!m->event)
return 0;
if (IN_SET(sd_event_get_state(m->event), SD_EVENT_FINISHED, SD_EVENT_EXITING))
return 0;
r = sd_event_add_defer(m->event, &m->deferred_ntp_server_event_source, on_deferred_ntp_server, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate ntp server event source: %m");
(void) sd_event_source_set_description(m->deferred_ntp_server_event_source, "deferred-ntp-server");
return 1;
}