HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/timesync/timesyncd-manager.c

51,465 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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;
}