HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/generator/network-generator.c

50,210 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: d3f77f4efa1aa30e0dd042478b2edc20a2ebcafd

Lines 1001–1622 of 1,622

 
static int parse_cmdline_rd_route(Context *context, const char *key, const char *value) {
        _cleanup_free_ char *buf = NULL;
        union in_addr_union dest, gateway;
        unsigned char prefixlen;
        int family, r;
 
        assert(context);
        assert(key);
 
        /* rd.route=<net>/<netmask>:<gateway>[:<interface>] */
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        const char *p = value;
        r = extract_ip_address_str(AF_UNSPEC, &p, &buf);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse destination address in %s=%s: %m", key, value);
 
        r = in_addr_prefix_from_string_auto(buf, &family, &dest, &prefixlen);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse route destination '%s': %m", buf);
 
        buf = mfree(buf);
        r = extract_ip_address(family, &p, &gateway);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse gateway address in %s=%s: %m", key, value);
 
        return network_set_route(context, strempty(p), family, prefixlen, &dest, &gateway);
}
 
static int parse_cmdline_nameserver(Context *context, const char *key, const char *value) {
        assert(context);
        assert(key);
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        return network_set_dns(context, "", value);
}
 
static int parse_cmdline_rd_peerdns(Context *context, const char *key, const char *value) {
        int r;
 
        assert(context);
        assert(key);
 
        r = value ? parse_boolean(value) : true;
        if (r < 0)
                return log_debug_errno(r, "Invalid boolean value '%s'", value);
 
        return network_set_dhcp_use_dns(context, "", r);
}
 
static int extract_vlan_id(const char *vlan_name, uint16_t *ret) {
        assert(!isempty(vlan_name));
        assert(ret);
 
        /* From dracut.cmdline(7):
         * We support the four styles of vlan names:
         *   VLAN_PLUS_VID (vlan0005),
         *   VLAN_PLUS_VID_NO_PAD (vlan5),
         *   DEV_PLUS_VID (eth0.0005), and
         *   DEV_PLUS_VID_NO_PAD (eth0.5). */
 
        for (const char *p = vlan_name + strlen(vlan_name) - 1; p > vlan_name; p--)
                if (!ascii_isdigit(*p))
                        return parse_vlanid(p+1, ret);
 
        return -EINVAL;
}
 
static int parse_cmdline_vlan(Context *context, const char *key, const char *value) {
        _cleanup_free_ char *name = NULL;
        NetDev *netdev;
        int r;
 
        assert(context);
        assert(key);
 
        /* vlan=<vlanname>:<phydevice> */
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        const char *p = value;
        r = extract_first_word(&p, &name, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s=%s: %m", key, value);
 
        r = netdev_acquire(context, "vlan", name, &netdev);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire VLAN device for '%s': %m", name);
 
        r = extract_vlan_id(name, &netdev->vlan_id);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse VLAN ID from VLAN device name '%s': %m", name);
 
        return network_set_vlan(context, p, name);
}
 
static int parse_cmdline_bridge(Context *context, const char *key, const char *value) {
        _cleanup_free_ char *name = NULL;
        NetDev *netdev;
        int r;
 
        assert(context);
        assert(key);
 
        /* bridge=<bridgename>:<ethnames> */
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        const char *p = value;
        r = extract_first_word(&p, &name, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s=%s: %m", key, value);
 
        r = netdev_acquire(context, "bridge", name, &netdev);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire bridge device for '%s': %m", name);
 
        for (;;) {
                _cleanup_free_ char *word = NULL;
 
                r = extract_first_word(&p, &word, ",", 0);
                if (r < 0)
                        return log_debug_errno(r, "Failed to parse slave interfaces for bridge '%s'", name);
                if (r == 0)
                        return 0;
 
                r = network_set_bridge(context, word, name);
                if (r < 0)
                        return r;
        }
}
 
static int parse_cmdline_bond(Context *context, const char *key, const char *value) {
        _cleanup_free_ char *name = NULL, *slaves = NULL, *options = NULL;
        NetDev *netdev;
        int r;
 
        assert(context);
        assert(key);
 
        /* bond=<bondname>[:<bondslaves>:[:<options>[:<mtu>]]] */
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        const char *p = value;
        r = extract_first_word(&p, &name, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s=%s: %m", key, value);
 
        r = netdev_acquire(context, "bond", name, &netdev);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire bond device for '%s': %m", name);
 
        r = extract_first_word(&p, &slaves, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse %s=%s: %m", key, value);
 
        for (const char *q = slaves; ; ) {
                _cleanup_free_ char *word = NULL;
 
                r = extract_first_word(&q, &word, ",", 0);
                if (r == 0)
                        break;
                if (r < 0)
                        return log_debug_errno(r, "Failed to parse slave interfaces for bond '%s'", name);
 
                r = network_set_bond(context, word, name);
                if (r < 0)
                        return r;
        }
 
        r = extract_first_word(&p, &options, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse %s=%s: %m", key, value);
 
        /* TODO: set bonding options */
 
        if (!isempty(p)) {
                r = parse_mtu(AF_UNSPEC, p, &netdev->mtu);
                if (r < 0)
                        return log_debug_errno(r, "Invalid MTU '%s' for '%s': %m", p, name);
        }
 
        return 0;
}
 
static int parse_cmdline_ifname(Context *context, const char *key, const char *value) {
        _cleanup_free_ char *name = NULL;
        struct hw_addr_data mac;
        int r;
 
        assert(context);
        assert(key);
 
        /* ifname=<interface>:<MAC> */
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        const char *p = value;
        r = extract_first_word(&p, &name, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s=%s: %m", key, value);
 
        if (isempty(p))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Missing MAC address for '%s'", name);
 
        r = parse_hw_addr(p, &mac);
        if (r < 0)
                return log_debug_errno(r, "Invalid MAC address '%s' for '%s'", p, name);
 
        r = link_new(context, name, &mac, NULL);
        if (r < 0)
                return log_debug_errno(r, "Failed to create link for '%s': %m", name);
 
        return 0;
}
 
static int parse_cmdline_ifname_policy(Context *context, const char *key, const char *value) {
        _cleanup_strv_free_ char **policies = NULL, **alt_policies = NULL;
        struct hw_addr_data mac = HW_ADDR_NULL;
        Link *link;
        int r;
 
        assert(context);
        assert(key);
 
        /* net.ifname_policy=policy1[,policy2,...][,<MAC>] */
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        for (const char *q = value; ; ) {
                _cleanup_free_ char *word = NULL;
                NamePolicy p;
 
                r = extract_first_word(&q, &word, ",", 0);
                if (r == 0)
                        break;
                if (r < 0)
                        return log_debug_errno(r, "Failed to parse ifname policy '%s'", value);
 
                p = name_policy_from_string(word);
                if (p < 0) {
                        r = parse_hw_addr(word, &mac);
                        if (r < 0)
                                return log_debug_errno(r, "Invalid MAC address '%s'", word);
 
                        if (hw_addr_is_null(&mac))
                                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "MAC address is not set");
 
                        if (!isempty(q))
                                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unexpected trailing string '%s' in ifname policy '%s'", q, value);
 
                        break;
                }
 
                if (alternative_names_policy_from_string(word) >= 0) {
                        r = strv_extend(&alt_policies, word);
                        if (r < 0)
                                return log_oom_debug();
                }
 
                r = strv_consume(&policies, TAKE_PTR(word));
                if (r < 0)
                        return log_oom_debug();
        }
 
        if (strv_isempty(policies))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "No ifname policy specified");
 
        r = link_new(context, NULL, &mac, &link);
        if (r < 0)
                return log_debug_errno(r, "Failed to create link: %m");
 
        link->policies = TAKE_PTR(policies);
        link->alt_policies = TAKE_PTR(alt_policies);
        return 0;
}
 
static int parse_cmdline_rd_bootif(Context *context, const char *key, const char *value) {
        int r;
 
        assert(context);
        assert(key);
 
        /* rd.bootif=<bool> */
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        r = value ? parse_boolean(value) : true;
        if (r < 0)
                return log_debug_errno(r, "Invalid boolean value '%s'", value);
 
        /* rd.bootif=0 => skip BOOTIF= parsing */
        context->skip_bootif = !r;
        return 0;
}
 
static int parse_cmdline_bootif_mac(Context *context, const char *key, const char *value) {
        assert(context);
        assert(key);
 
        /* BOOTIF=<MAC> */
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        return network_set_bootif_mac_address(context, value);
}
 
int parse_cmdline_item(const char *key, const char *value, void *data) {
        Context *context = ASSERT_PTR(data);
 
        assert(key);
 
        if (proc_cmdline_key_streq(key, "ip"))
                return parse_cmdline_ip(context, key, value);
        if (proc_cmdline_key_streq(key, "rd.route"))
                return parse_cmdline_rd_route(context, key, value);
        if (proc_cmdline_key_streq(key, "nameserver"))
                return parse_cmdline_nameserver(context, key, value);
        if (proc_cmdline_key_streq(key, "rd.peerdns"))
                return parse_cmdline_rd_peerdns(context, key, value);
        if (proc_cmdline_key_streq(key, "vlan"))
                return parse_cmdline_vlan(context, key, value);
        if (proc_cmdline_key_streq(key, "bridge"))
                return parse_cmdline_bridge(context, key, value);
        if (proc_cmdline_key_streq(key, "bond"))
                return parse_cmdline_bond(context, key, value);
        if (proc_cmdline_key_streq(key, "ifname"))
                return parse_cmdline_ifname(context, key, value);
        if (proc_cmdline_key_streq(key, "net.ifname_policy"))
                return parse_cmdline_ifname_policy(context, key, value);
        if (proc_cmdline_key_streq(key, "rd.bootif"))
                return parse_cmdline_rd_bootif(context, key, value);
        if (proc_cmdline_key_streq(key, "BOOTIF"))
                return parse_cmdline_bootif_mac(context, key, value);
 
        return 0;
}
 
void context_finalize_bootif(Context *context) {
        assert(context);
 
        Network *network = hashmap_get(context->networks_by_name, "BOOTIF");
        if (!network)
                return;
 
        /* rd.bootif=0 disables BOOTIF= handling */
        if (context->skip_bootif) {
                network_free(hashmap_remove_value(context->networks_by_name, "BOOTIF", network));
                return;
        }
 
        if (hw_addr_is_null(&network->match_mac)) {
                log_debug("Expected MAC address for BOOTIF, but BOOTIF= is unset.");
                network_free(hashmap_remove_value(context->networks_by_name, "BOOTIF", network));
                return;
        }
}
 
int context_merge_networks(Context *context) {
        Network *all, *network;
        int r;
 
        assert(context);
 
        /* Copy settings about the following options
           rd.route=<net>/<netmask>:<gateway>[:<interface>]
           nameserver=<IP> [nameserver=<IP> ...]
           rd.peerdns=0 */
 
        all = network_get(context, "");
        if (!all)
                return 0;
 
        if (hashmap_size(context->networks_by_name) <= 1)
                return 0;
 
        HASHMAP_FOREACH(network, context->networks_by_name) {
                if (network == all)
                        continue;
 
                network->dhcp_use_dns = all->dhcp_use_dns;
 
                r = strv_extend_strv(&network->dns, all->dns, false);
                if (r < 0)
                        return log_oom_debug();
 
                LIST_FOREACH(routes, route, all->routes) {
                        r = route_new(network, route->family, route->prefixlen, &route->dest, &route->gateway, NULL);
                        if (r < 0)
                                return log_debug_errno(r, "Failed to copy route: %m");
                }
        }
 
        assert_se(hashmap_remove(context->networks_by_name, "") == all);
        network_free(all);
        return 0;
}
 
void context_clear(Context *context) {
        if (!context)
                return;
 
        free(context->network_dir);
        free(context->networkd_conf_dropin_dir);
 
        hashmap_free(context->networks_by_name);
        hashmap_free(context->netdevs_by_name);
        hashmap_free(context->links_by_filename);
}
 
static int address_dump(Address *address, FILE *f) {
        assert(address);
        assert(f);
 
        fprintf(f,
                "\n[Address]\n"
                "Address=%s\n",
                IN_ADDR_PREFIX_TO_STRING(address->family, &address->address, address->prefixlen));
        if (in_addr_is_set(address->family, &address->peer))
                fprintf(f, "Peer=%s\n",
                        IN_ADDR_TO_STRING(address->family, &address->peer));
        return 0;
}
 
static int route_dump(Route *route, FILE *f) {
        assert(route);
        assert(f);
 
        fputs("\n[Route]\n", f);
        if (in_addr_is_set(route->family, &route->dest))
                fprintf(f, "Destination=%s\n",
                        IN_ADDR_PREFIX_TO_STRING(route->family, &route->dest, route->prefixlen));
        if (in_addr_is_set(route->family, &route->gateway))
                fprintf(f, "Gateway=%s\n",
                        IN_ADDR_TO_STRING(route->family, &route->gateway));
 
        return 0;
}
 
void network_dump(Network *network, FILE *f) {
        const char *dhcp;
 
        assert(network);
        assert(f);
 
        fputs("[Match]\n", f);
 
        if (isempty(network->ifname))
                /* If the interface name is not specified, then let's make the .network file match the all
                 * physical interfaces. */
                fputs("Kind=!*\n"
                      "Type=!loopback\n", f);
        else if (streq(network->ifname, "BOOTIF"))
                fprintf(f, "MACAddress=%s\n", HW_ADDR_TO_STR(&network->match_mac));
        else
                fprintf(f, "Name=%s\n", network->ifname);
 
        fputs("\n[Link]\n", f);
 
        if (!ether_addr_is_null(&network->mac))
                fprintf(f, "MACAddress=%s\n", ETHER_ADDR_TO_STR(&network->mac));
        if (network->mtu > 0)
                fprintf(f, "MTUBytes=%" PRIu32 "\n", network->mtu);
 
        fputs("\n[Network]\n", f);
 
        dhcp = networkd_dhcp_type_to_string(network->dhcp_type);
        if (dhcp)
                fprintf(f, "DHCP=%s\n", dhcp);
 
        const char *ll;
        ll = networkd_link_local_type_to_string(network->dhcp_type);
        if (ll)
                fprintf(f, "LinkLocalAddressing=%s\n", ll);
 
        const char *ra;
        ra = networkd_ipv6ra_type_to_string(network->dhcp_type);
        if (ra)
                fprintf(f, "IPv6AcceptRA=%s\n", ra);
 
        if (!strv_isempty(network->dns))
                STRV_FOREACH(dns, network->dns)
                        fprintf(f, "DNS=%s\n", *dns);
 
        STRV_FOREACH(v, network->vlan)
                fprintf(f, "VLAN=%s\n", *v);
 
        if (network->bridge)
                fprintf(f, "Bridge=%s\n", network->bridge);
 
        if (network->bond)
                fprintf(f, "Bond=%s\n", network->bond);
 
        if (network->ntp)
                fprintf(f, "NTP=%s\n", network->ntp);
 
        fputs("\n[DHCP]\n", f);
 
        if (!isempty(network->hostname))
                fprintf(f, "Hostname=%s\n", network->hostname);
 
        if (network->dhcp_use_dns >= 0)
                fprintf(f, "UseDNS=%s\n", yes_no(network->dhcp_use_dns));
 
        LIST_FOREACH(addresses, address, network->addresses)
                (void) address_dump(address, f);
 
        LIST_FOREACH(routes, route, network->routes)
                (void) route_dump(route, f);
}
 
void netdev_dump(NetDev *netdev, FILE *f) {
        assert(netdev);
        assert(f);
 
        fprintf(f,
                "[NetDev]\n"
                "Kind=%s\n"
                "Name=%s\n",
                netdev->kind,
                netdev->ifname);
 
        if (netdev->mtu > 0)
                fprintf(f, "MTUBytes=%" PRIu32 "\n", netdev->mtu);
 
        if (streq(netdev->kind, "vlan"))
                fprintf(f,
                        "\n[VLAN]\n"
                        "Id=%u\n",
                        netdev->vlan_id);
}
 
void link_dump(Link *link, FILE *f) {
        assert(link);
        assert(f);
 
        fputs("[Match]\n", f);
 
        if (!hw_addr_is_null(&link->mac))
                fprintf(f, "MACAddress=%s\n", HW_ADDR_TO_STR(&link->mac));
        else
                fputs("OriginalName=*\n", f);
 
        fputs("\n[Link]\n", f);
 
        if (!isempty(link->ifname))
                fprintf(f, "Name=%s\n", link->ifname);
 
        if (!strv_isempty(link->policies)) {
                fputs("NamePolicy=", f);
                fputstrv(f, link->policies, " ", NULL);
                fputc('\n', f);
        }
 
        if (!strv_isempty(link->alt_policies)) {
                fputs("AlternativeNamesPolicy=", f);
                fputstrv(f, link->alt_policies, " ", NULL);
                fputc('\n', f);
        }
}
 
int network_format(Network *network, char **ret) {
        _cleanup_(memstream_done) MemStream m = {};
        FILE *f;
 
        assert(network);
        assert(ret);
 
        f = memstream_init(&m);
        if (!f)
                return log_oom_debug();
 
        network_dump(network, f);
 
        return memstream_finalize(&m, ret, NULL);
}
 
int netdev_format(NetDev *netdev, char **ret) {
        _cleanup_(memstream_done) MemStream m = {};
        FILE *f;
 
        assert(netdev);
        assert(ret);
 
        f = memstream_init(&m);
        if (!f)
                return log_oom_debug();
 
        netdev_dump(netdev, f);
 
        return memstream_finalize(&m, ret, NULL);
}
 
int link_format(Link *link, char **ret) {
        _cleanup_(memstream_done) MemStream m = {};
        FILE *f;
 
        assert(link);
        assert(ret);
 
        f = memstream_init(&m);
        if (!f)
                return log_oom_debug();
 
        link_dump(link, f);
 
        return memstream_finalize(&m, ret, NULL);
}