HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/networkd-manager.c

45,985 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 291589800f6205441adb914980e6eeb29277ff7d

Lines 1001–1322 of 1,322

        int r;
 
        assert(m);
        assert(m->rtnl);
 
        r = sd_rtnl_message_new_neigh(m->rtnl, &req, RTM_GETNEIGH, 0, AF_UNSPEC);
        if (r < 0)
                return r;
 
        return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_neighbor);
}
 
static int manager_enumerate_routes(Manager *m) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
        int r;
 
        assert(m);
        assert(m->rtnl);
 
        if (!m->manage_foreign_routes)
                return 0;
 
        r = sd_rtnl_message_new_route(m->rtnl, &req, RTM_GETROUTE, 0, 0);
        if (r < 0)
                return r;
 
        return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_route);
}
 
static int manager_enumerate_rules(Manager *m) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
        int r;
 
        assert(m);
        assert(m->rtnl);
 
        if (!m->manage_foreign_rules)
                return 0;
 
        r = sd_rtnl_message_new_routing_policy_rule(m->rtnl, &req, RTM_GETRULE, 0);
        if (r < 0)
                return r;
 
        return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_rule);
}
 
static int manager_enumerate_nexthop(Manager *m) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
        int r;
 
        assert(m);
        assert(m->rtnl);
 
        if (!m->manage_foreign_nexthops)
                return 0;
 
        r = sd_rtnl_message_new_nexthop(m->rtnl, &req, RTM_GETNEXTHOP, 0, 0);
        if (r < 0)
                return r;
 
        return manager_enumerate_internal(m, m->rtnl, req, manager_rtnl_process_nexthop);
}
 
static int manager_enumerate_nl80211_wiphy(Manager *m) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
        int r;
 
        assert(m);
        assert(m->genl);
 
        r = sd_genl_message_new(m->genl, NL80211_GENL_NAME, NL80211_CMD_GET_WIPHY, &req);
        if (r < 0)
                return r;
 
        return manager_enumerate_internal(m, m->genl, req, manager_genl_process_nl80211_wiphy);
}
 
static int manager_enumerate_nl80211_config(Manager *m) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
        int r;
 
        assert(m);
        assert(m->genl);
 
        r = sd_genl_message_new(m->genl, NL80211_GENL_NAME, NL80211_CMD_GET_INTERFACE, &req);
        if (r < 0)
                return r;
 
        return manager_enumerate_internal(m, m->genl, req, manager_genl_process_nl80211_config);
}
 
static int manager_enumerate_nl80211_mlme(Manager *m) {
        Link *link;
        int r;
 
        assert(m);
        assert(m->genl);
 
        HASHMAP_FOREACH(link, m->links_by_index) {
                _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 
                if (link->wlan_iftype != NL80211_IFTYPE_STATION)
                        continue;
 
                r = sd_genl_message_new(m->genl, NL80211_GENL_NAME, NL80211_CMD_GET_STATION, &req);
                if (r < 0)
                        return r;
 
                r = sd_netlink_message_append_u32(req, NL80211_ATTR_IFINDEX, link->ifindex);
                if (r < 0)
                        return r;
 
                r = manager_enumerate_internal(m, m->genl, req, manager_genl_process_nl80211_mlme);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
int manager_enumerate(Manager *m) {
        int r;
 
        log_debug("Enumerating...");
 
        r = manager_enumerate_links(m);
        if (r < 0)
                return log_error_errno(r, "Could not enumerate links: %m");
 
        /* If the kernel is built without CONFIG_NET_SCHED, the below will fail with -EOPNOTSUPP. */
        r = manager_enumerate_qdisc(m);
        if (r == -EOPNOTSUPP)
                log_debug_errno(r, "Could not enumerate QDiscs, ignoring: %m");
        else if (r < 0)
                return log_error_errno(r, "Could not enumerate QDisc: %m");
 
        /* If the kernel is built without CONFIG_NET_CLS, the below will fail with -EOPNOTSUPP. */
        r = manager_enumerate_tclass(m);
        if (r == -EOPNOTSUPP)
                log_debug_errno(r, "Could not enumerate TClasses, ignoring: %m");
        else if (r < 0)
                return log_error_errno(r, "Could not enumerate TClass: %m");
 
        r = manager_enumerate_addresses(m);
        if (r < 0)
                return log_error_errno(r, "Could not enumerate addresses: %m");
 
        r = manager_enumerate_neighbors(m);
        if (r < 0)
                return log_error_errno(r, "Could not enumerate neighbors: %m");
 
        r = manager_enumerate_nexthop(m);
        if (r < 0)
                return log_error_errno(r, "Could not enumerate nexthops: %m");
 
        r = manager_enumerate_routes(m);
        if (r < 0)
                return log_error_errno(r, "Could not enumerate routes: %m");
 
        /* If the kernel is built without CONFIG_FIB_RULES, the below will fail with -EOPNOTSUPP. */
        r = manager_enumerate_rules(m);
        if (r == -EOPNOTSUPP)
                log_debug_errno(r, "Could not enumerate routing policy rules, ignoring: %m");
        else if (r < 0)
                return log_error_errno(r, "Could not enumerate routing policy rules: %m");
 
        /* If the kernel is built without CONFIG_WIRELESS, the below will fail with -EOPNOTSUPP. */
        r = manager_enumerate_nl80211_wiphy(m);
        if (r == -EOPNOTSUPP)
                log_debug_errno(r, "Could not enumerate wireless LAN phy, ignoring: %m");
        else if (r < 0)
                return log_error_errno(r, "Could not enumerate wireless LAN phy: %m");
 
        r = manager_enumerate_nl80211_config(m);
        if (r == -EOPNOTSUPP)
                log_debug_errno(r, "Could not enumerate wireless LAN interfaces, ignoring: %m");
        else if (r < 0)
                return log_error_errno(r, "Could not enumerate wireless LAN interfaces: %m");
 
        r = manager_enumerate_nl80211_mlme(m);
        if (r == -EOPNOTSUPP)
                log_debug_errno(r, "Could not enumerate wireless LAN stations, ignoring: %m");
        else if (r < 0)
                return log_error_errno(r, "Could not enumerate wireless LAN stations: %m");
 
        log_debug("Enumeration completed.");
        return 0;
}
 
static int set_hostname_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
        const sd_bus_error *e;
        int r;
 
        assert(m);
 
        e = sd_bus_message_get_error(m);
        if (e) {
                r = sd_bus_error_get_errno(e);
                log_warning_errno(r, "Could not set hostname: %s", bus_error_message(e, r));
        }
 
        return 1;
}
 
int manager_set_hostname(Manager *m, const char *hostname) {
        int r;
 
        log_debug("Setting transient hostname: '%s'", strna(hostname));
 
        r = free_and_strdup_warn(&m->dynamic_hostname, hostname);
        if (r < 0)
                return r;
 
        if (sd_bus_is_ready(m->bus) <= 0) {
                log_debug("Not connected to system bus, setting system hostname later.");
                return 0;
        }
 
        r = bus_call_method_async(
                        m->bus,
                        NULL,
                        bus_hostname,
                        "SetHostname",
                        set_hostname_handler,
                        m,
                        "sb",
                        hostname,
                        false);
        if (r < 0)
                return log_error_errno(r, "Could not set transient hostname: %m");
 
        return 0;
}
 
static int set_timezone_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
        const sd_bus_error *e;
        int r;
 
        assert(m);
 
        e = sd_bus_message_get_error(m);
        if (e) {
                r = sd_bus_error_get_errno(e);
                log_warning_errno(r, "Could not set timezone: %s", bus_error_message(e, r));
        }
 
        return 1;
}
 
int manager_set_timezone(Manager *m, const char *tz) {
        int r;
 
        assert(m);
        assert(tz);
 
        log_debug("Setting system timezone: '%s'", tz);
        r = free_and_strdup_warn(&m->dynamic_timezone, tz);
        if (r < 0)
                return r;
 
        if (sd_bus_is_ready(m->bus) <= 0) {
                log_debug("Not connected to system bus, setting system timezone later.");
                return 0;
        }
 
        r = bus_call_method_async(
                        m->bus,
                        NULL,
                        bus_timedate,
                        "SetTimezone",
                        set_timezone_handler,
                        m,
                        "sb",
                        tz,
                        false);
        if (r < 0)
                return log_error_errno(r, "Could not set timezone: %m");
 
        return 0;
}
 
int manager_reload(Manager *m, sd_bus_message *message, sd_varlink *varlink, bool reconfigure_links) {
        Link *link;
        int r;
 
        assert(m);
        assert(!message || !varlink); /* D-Bus and Varlink callers are mutually exclusive */
 
        if (m->state != MANAGER_RUNNING)
                return -ESHUTDOWN; /* Refuse reloading if we are stopping or restarting. */
 
        log_debug("Reloading...");
        (void) notify_reloading();
 
        r = netdev_reload(m);
        if (r < 0) {
                log_debug_errno(r, "Failed to reload .netdev files: %m");
                goto finish;
        }
 
        r = network_reload(m);
        if (r < 0) {
                log_debug_errno(r, "Failed to reload .network files: %m");
                goto finish;
        }
 
        if (reconfigure_links)
                HASHMAP_FOREACH(link, m->links_by_index)
                        (void) link_reconfigure_full(
                                        link,
                                        /* flags= */ 0,
                                        message,
                                        varlink,
                                        /* counter= */ (message || varlink) ? &m->reloading : NULL);
 
        log_debug("Reloaded.");
        r = 0;
finish:
        (void) sd_notify(/* unset_environment= */ false, NOTIFY_READY_MESSAGE);
        return r;
}