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 1–1000 of 1,622

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <net/if_arp.h>
 
#include "alloc-util.h"
#include "extract-word.h"
#include "hostname-util.h"
#include "log.h"
#include "memstream-util.h"
#include "netif-naming-scheme.h"
#include "network-generator.h"
#include "parse-util.h"
#include "proc-cmdline.h"
#include "socket-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "vlan-util.h"
 
/*
  # .network
  ip={dhcp|on|any|dhcp6|auto6|either6|link6|link-local}
  ip=<interface>:{dhcp|on|any|dhcp6|auto6|link6|link-local}[:[<mtu>][:<macaddr>]]
  ip=<client-IP>:[<peer>]:<gateway-IP>:<netmask>:<client_hostname>:<interface>:{none|off|dhcp|on|any|dhcp6|auto6|link6|ibft|link-local}[:[<mtu>][:<macaddr>]]
  ip=<client-IP>:[<peer>]:<gateway-IP>:<netmask>:<client_hostname>:<interface>:{none|off|dhcp|on|any|dhcp6|auto6|link6|ibft|link-local}[:[<dns1>][:[<dns2>][:[<ntp>]]]]
  rd.route=<net>/<netmask>:<gateway>[:<interface>]
  nameserver=<IP> [nameserver=<IP> ...]
  rd.peerdns=0
  BOOTIF=<MAC>
  rd.bootif=0 # Causes BOOTIF= to be ignored.
 
  # .link
  ifname=<interface>:<MAC>
  net.ifname_policy=policy1[,policy2,...][,<MAC>] # This is an original rule, not supported by other tools.
 
  # .netdev
  vlan=<vlanname>:<phydevice>
  bond=<bondname>[:<bondslaves>:[:<options>[:<mtu>]]]
  team=<teammaster>:<teamslaves> # not supported
  bridge=<bridgename>:<ethnames>
 
  # ignored
  bootdev=<interface>
  biosdevname=0
  rd.neednet=1
*/
 
static const char * const dracut_dhcp_type_table[_DHCP_TYPE_MAX] = {
        [DHCP_TYPE_NONE]       = "none",
        [DHCP_TYPE_OFF]        = "off",
        [DHCP_TYPE_ON]         = "on",
        [DHCP_TYPE_ANY]        = "any",
        [DHCP_TYPE_DHCP]       = "dhcp",
        [DHCP_TYPE_DHCP6]      = "dhcp6",
        [DHCP_TYPE_AUTO6]      = "auto6",
        [DHCP_TYPE_EITHER6]    = "either6",
        [DHCP_TYPE_IBFT]       = "ibft",
        [DHCP_TYPE_LINK6]      = "link6",
        [DHCP_TYPE_LINK_LOCAL] = "link-local",
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(dracut_dhcp_type, DHCPType);
 
static const char * const networkd_dhcp_type_table[_DHCP_TYPE_MAX] = {
        [DHCP_TYPE_NONE]       = "no",
        [DHCP_TYPE_OFF]        = "no",
        [DHCP_TYPE_ON]         = "yes",
        [DHCP_TYPE_ANY]        = "yes",
        [DHCP_TYPE_DHCP]       = "ipv4",
        [DHCP_TYPE_DHCP6]      = "ipv6",
        [DHCP_TYPE_AUTO6]      = "no",   /* TODO: enable other setting? */
        [DHCP_TYPE_EITHER6]    = "ipv6", /* TODO: enable other setting? */
        [DHCP_TYPE_IBFT]       = "no",
        [DHCP_TYPE_LINK6]      = "no",
        [DHCP_TYPE_LINK_LOCAL] = "no",
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(networkd_dhcp_type, DHCPType);
 
static const char * const networkd_ipv6ra_type_table[_DHCP_TYPE_MAX] = {
        [DHCP_TYPE_NONE]       = "no",
        [DHCP_TYPE_OFF]        = "no",
        [DHCP_TYPE_LINK6]      = "no",
        [DHCP_TYPE_LINK_LOCAL] = "no",
        /* We omit the other entries, to leave the default in effect */
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(networkd_ipv6ra_type, DHCPType);
 
static const char * const networkd_link_local_type_table[_DHCP_TYPE_MAX] = {
        [DHCP_TYPE_NONE]       = "no",
        [DHCP_TYPE_OFF]        = "no",
        [DHCP_TYPE_LINK6]      = "ipv6",
        [DHCP_TYPE_LINK_LOCAL] = "yes",
        /* We omit the other entries, to leave the default in effect */
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(networkd_link_local_type, DHCPType);
 
static Address* address_free(Address *address) {
        if (!address)
                return NULL;
 
        if (address->network)
                LIST_REMOVE(addresses, address->network->addresses, address);
 
        return mfree(address);
}
 
static int address_new(
                Network *network,
                int family,
                unsigned char prefixlen,
                union in_addr_union *addr,
                union in_addr_union *peer,
                Address **ret) {
 
        Address *address;
 
        assert(network);
        assert(IN_SET(family, AF_INET, AF_INET6));
        assert(addr);
        POINTER_MAY_BE_NULL(peer);
 
        address = new(Address, 1);
        if (!address)
                return -ENOMEM;
 
        *address = (Address) {
                .family = family,
                .prefixlen = prefixlen,
                .address = *addr,
                .peer = peer ? *peer : IN_ADDR_NULL,
        };
 
        LIST_PREPEND(addresses, network->addresses, address);
 
        address->network = network;
 
        if (ret)
                *ret = address;
        return 0;
}
 
static Route* route_free(Route *route) {
        if (!route)
                return NULL;
 
        if (route->network)
                LIST_REMOVE(routes, route->network->routes, route);
 
        return mfree(route);
}
 
static int route_new(
                Network *network,
                int family,
                unsigned char prefixlen,
                union in_addr_union *dest,
                union in_addr_union *gateway,
                Route **ret) {
 
        Route *route;
 
        assert(network);
        assert(IN_SET(family, AF_INET, AF_INET6));
        assert(dest || gateway);
 
        route = new(Route, 1);
        if (!route)
                return -ENOMEM;
 
        *route = (Route) {
                .family = family,
                .prefixlen = prefixlen,
                .dest = dest ? *dest : IN_ADDR_NULL,
                .gateway = gateway ? *gateway : IN_ADDR_NULL,
        };
 
        LIST_PREPEND(routes, network->routes, route);
 
        route->network = network;
 
        if (ret)
                *ret = route;
        return 0;
}
 
static Network* network_free(Network *network) {
        Address *address;
        Route *route;
 
        if (!network)
                return NULL;
 
        free(network->ifname);
        free(network->hostname);
        strv_free(network->dns);
        strv_free(network->vlan);
        free(network->bridge);
        free(network->bond);
        free(network->ntp);
 
        while ((address = network->addresses))
                address_free(address);
 
        while ((route = network->routes))
                route_free(route);
 
        return mfree(network);
}
 
DEFINE_TRIVIAL_CLEANUP_FUNC(Network*, network_free);
 
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
                network_hash_ops,
                char, string_hash_func, string_compare_func,
                Network, network_free);
 
static int network_new(Context *context, const char *name, Network **ret) {
        _cleanup_(network_freep) Network *network = NULL;
        _cleanup_free_ char *ifname = NULL;
        int r;
 
        assert(context);
        assert(name);
 
        if (!isempty(name) && !ifname_valid(name))
                return -EINVAL;
 
        ifname = strdup(name);
        if (!ifname)
                return -ENOMEM;
 
        network = new(Network, 1);
        if (!network)
                return -ENOMEM;
 
        *network = (Network) {
                .ifname = TAKE_PTR(ifname),
                .dhcp_type = _DHCP_TYPE_INVALID,
                .dhcp_use_dns = -1,
        };
 
        r = hashmap_ensure_put(&context->networks_by_name, &network_hash_ops, network->ifname, network);
        if (r < 0)
                return r;
 
        if (ret)
                *ret = network;
 
        TAKE_PTR(network);
        return 0;
}
 
Network* network_get(Context *context, const char *ifname) {
        assert(context);
        assert(ifname);
        return hashmap_get(context->networks_by_name, ifname);
}
 
static int network_acquire(Context *context, const char *ifname, Network **ret) {
        Network *network;
 
        assert(context);
        assert(ifname);
 
        network = network_get(context, ifname);
        if (!network)
                return network_new(context, ifname, ret);
 
        if (ret)
                *ret = network;
        return 0;
}
 
static NetDev* netdev_free(NetDev *netdev) {
        if (!netdev)
                return NULL;
 
        free(netdev->ifname);
        free(netdev->kind);
        return mfree(netdev);
}
 
DEFINE_TRIVIAL_CLEANUP_FUNC(NetDev*, netdev_free);
 
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
                netdev_hash_ops,
                char, string_hash_func, string_compare_func,
                NetDev, netdev_free);
 
static int netdev_new(Context *context, const char *_kind, const char *_ifname, NetDev **ret) {
        _cleanup_(netdev_freep) NetDev *netdev = NULL;
        _cleanup_free_ char *kind = NULL, *ifname = NULL;
        int r;
 
        assert(context);
        assert(_kind);
        assert(_ifname);
 
        if (!ifname_valid(_ifname))
                return -EINVAL;
 
        kind = strdup(_kind);
        if (!kind)
                return -ENOMEM;
 
        ifname = strdup(_ifname);
        if (!ifname)
                return -ENOMEM;
 
        netdev = new(NetDev, 1);
        if (!netdev)
                return -ENOMEM;
 
        *netdev = (NetDev) {
                .kind = TAKE_PTR(kind),
                .ifname = TAKE_PTR(ifname),
        };
 
        r = hashmap_ensure_put(&context->netdevs_by_name, &netdev_hash_ops, netdev->ifname, netdev);
        if (r < 0)
                return r;
 
        if (ret)
                *ret = netdev;
 
        TAKE_PTR(netdev);
        return 0;
}
 
NetDev* netdev_get(Context *context, const char *ifname) {
        assert(context);
        assert(ifname);
        return hashmap_get(context->netdevs_by_name, ifname);
}
 
static int netdev_acquire(Context *context, const char *kind, const char *name, NetDev **ret) {
        NetDev *netdev;
 
        assert(context);
        assert(kind);
        assert(name);
 
        netdev = netdev_get(context, name);
        if (!netdev)
                return netdev_new(context, kind, name, ret);
 
        if (!streq_ptr(netdev->kind, kind))
                return -EEXIST; /* conflicting netdev already exists. */
 
        if (ret)
                *ret = netdev;
        return 0;
}
 
static Link* link_free(Link *link) {
        if (!link)
                return NULL;
 
        free(link->filename);
        free(link->ifname);
        strv_free(link->policies);
        strv_free(link->alt_policies);
        return mfree(link);
}
 
DEFINE_TRIVIAL_CLEANUP_FUNC(Link*, link_free);
 
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
                link_hash_ops,
                char, string_hash_func, string_compare_func,
                Link, link_free);
 
static int link_new(
                Context *context,
                const char *name,
                const struct hw_addr_data *mac,
                Link **ret) {
 
        _cleanup_(link_freep) Link *link = NULL;
        _cleanup_free_ char *ifname = NULL, *filename = NULL;
        int r;
 
        assert(context);
        assert(mac);
 
        if (name) {
                if (!ifname_valid(name))
                        return -EINVAL;
 
                ifname = strdup(name);
                if (!ifname)
                        return -ENOMEM;
 
                filename = strdup(name);
                if (!filename)
                        return -ENOMEM;
        }
 
        if (!filename) {
                filename = strdup(hw_addr_is_null(mac) ? "default" :
                                  HW_ADDR_TO_STR_FULL(mac, HW_ADDR_TO_STRING_NO_COLON));
                if (!filename)
                        return -ENOMEM;
        }
 
        link = new(Link, 1);
        if (!link)
                return -ENOMEM;
 
        *link = (Link) {
                .filename = TAKE_PTR(filename),
                .ifname = TAKE_PTR(ifname),
                .mac = *mac,
        };
 
        r = hashmap_ensure_put(&context->links_by_filename, &link_hash_ops, link->filename, link);
        if (r < 0)
                return r;
 
        if (ret)
                *ret = link;
 
        TAKE_PTR(link);
        return 0;
}
 
Link* link_get(Context *context, const char *filename) {
        assert(context);
        assert(filename);
        return hashmap_get(context->links_by_filename, filename);
}
 
static int network_set_dhcp_type(Context *context, const char *ifname, const char *dhcp_type) {
        Network *network;
        DHCPType t;
        int r;
 
        assert(context);
        assert(ifname);
        assert(dhcp_type);
 
        t = dracut_dhcp_type_from_string(dhcp_type);
        if (t < 0)
                return log_debug_errno(t, "Invalid DHCP type '%s'", dhcp_type);
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        network->dhcp_type = t;
        return 0;
}
 
static int network_set_hostname(Context *context, const char *ifname, const char *hostname) {
        Network *network;
        int r;
 
        assert(context);
        assert(ifname);
 
        if (isempty(hostname))
                return 0;
 
        if (!hostname_is_valid(hostname, 0))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid hostname '%s'.", hostname);
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        return free_and_strdup(&network->hostname, hostname);
}
 
static int network_set_mtu(Context *context, const char *ifname, const char *mtu) {
        Network *network;
        int r;
 
        assert(context);
        assert(ifname);
 
        if (isempty(mtu))
                return 0;
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        r = parse_mtu(AF_UNSPEC, mtu, &network->mtu);
        if (r < 0)
                return log_debug_errno(r, "Invalid MTU '%s' for '%s': %m", mtu, ifname);
 
        return r;
}
 
static int network_set_mac_address(Context *context, const char *ifname, const char *mac) {
        Network *network;
        int r;
 
        assert(context);
        assert(ifname);
 
        if (isempty(mac))
                return 0;
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        r = parse_ether_addr(mac, &network->mac);
        if (r < 0)
                return log_debug_errno(r, "Invalid MAC address '%s' for '%s'", mac, ifname);
 
        return 0;
}
 
static int network_set_bootif_mac_address(Context *context, const char *mac) {
        int r;
 
        assert(context);
 
        if (isempty(mac))
                return 0;
 
        /* "BOOTIF" is a special placeholder interface name, used to configure the
         * interface referred to by BOOTIF=. I.e., ip=...:BOOTIF:... is valid if and
         * only if BOOTIF= is also set. */
        Network *network;
        r = network_acquire(context, "BOOTIF", &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for BOOTIF: %m");
 
        r = parse_hw_addr(mac, &network->match_mac);
        if (r < 0) {
                /* PXE bootloaders may provide the MAC with a "hardware type prefix", e.g.
                 * 01-12:34:56:78:90:ab, where 01 indicates ethernet. Technically, other
                 * hardware types are possible, but only ethernet is handled here. */
                const char *p = startswith(mac, "01-");
                if (p)
                        r = parse_hw_addr(p, &network->match_mac);
        }
        if (r < 0)
                return log_debug_errno(r, "Invalid MAC address '%s' for BOOTIF", mac);
 
        if (!hw_addr_is_valid(&network->match_mac, ARPHRD_ETHER))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid MAC address '%s' for BOOTIF", mac);
 
        return 0;
}
 
static int network_set_address(
                Context *context,
                const char *ifname,
                int family,
                unsigned char prefixlen,
                union in_addr_union *addr,
                union in_addr_union *peer) {
 
        Network *network;
        int r;
 
        assert(context);
        assert(ifname);
        assert(IN_SET(family, AF_INET, AF_INET6));
        assert(addr);
 
        if (!in_addr_is_set(family, addr))
                return 0;
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        return address_new(network, family, prefixlen, addr, peer, NULL);
}
 
static int network_set_route(
                Context *context,
                const char *ifname,
                int family,
                unsigned char prefixlen,
                union in_addr_union *dest,
                union in_addr_union *gateway) {
 
        Network *network;
        int r;
 
        assert(context);
        assert(ifname);
        assert(IN_SET(family, AF_INET, AF_INET6));
 
        if (!(dest && in_addr_is_set(family, dest)) &&
            !(gateway && in_addr_is_set(family, gateway)))
                return 0;
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        return route_new(network, family, prefixlen, dest, gateway, NULL);
}
 
static int network_set_dns(Context *context, const char *ifname, const char *dns) {
        Network *network;
        int r;
 
        assert(context);
        assert(ifname);
 
        if (isempty(dns))
                return 0;
 
        r = in_addr_from_string_auto(dns, NULL, NULL);
        if (r < 0)
                return log_debug_errno(r, "Invalid DNS address '%s' for '%s'", dns, ifname);
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        return strv_extend(&network->dns, dns);
}
 
static int network_set_dhcp_use_dns(Context *context, const char *ifname, bool value) {
        Network *network;
        int r;
 
        assert(context);
        assert(ifname);
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to create network for '%s': %m", ifname);
 
        network->dhcp_use_dns = value;
 
        return 0;
}
 
static int network_set_vlan(Context *context, const char *ifname, const char *value) {
        Network *network;
        int r;
 
        assert(context);
 
        if (isempty(ifname))
                return 0;
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        return strv_extend(&network->vlan, value);
}
 
static int network_set_bridge(Context *context, const char *ifname, const char *value) {
        Network *network;
        int r;
 
        assert(context);
 
        if (isempty(ifname))
                return 0;
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        return free_and_strdup(&network->bridge, value);
}
 
static int network_set_bond(Context *context, const char *ifname, const char *value) {
        Network *network;
        int r;
 
        assert(context);
 
        if (isempty(ifname))
                return 0;
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        return free_and_strdup(&network->bond, value);
}
 
static int network_set_ntp(Context *context, const char *ifname, const char *value) {
        Network *network;
        int r;
 
        assert(context);
        assert(ifname);
 
        if (isempty(value))
                return 0;
 
        r = in_addr_from_string_auto(value, NULL, NULL);
        if (r < 0)
                return log_debug_errno(r, "Invalid NTP address '%s' for '%s'", value, ifname);
 
        r = network_acquire(context, ifname, &network);
        if (r < 0)
                return log_debug_errno(r, "Failed to acquire network for '%s': %m", ifname);
 
        return free_and_strdup(&network->ntp, value);
}
 
static int parse_cmdline_ip_mtu_mac(Context *context, const char *ifname, const char *value) {
        _cleanup_free_ char *mtu = NULL;
        int r;
 
        assert(context);
        assert(ifname);
 
        /* [<mtu>][:<macaddr>] */
 
        const char *p = value;
        r = extract_first_word(&p, &mtu, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r <= 0)
                return r;
 
        r = network_set_mtu(context, ifname, mtu);
        if (r < 0)
                return r;
 
        return network_set_mac_address(context, ifname, p);
}
 
static int extract_ip_address_str(int family, const char **ptr, char **ret) {
        _cleanup_free_ char *buf = NULL;
        const char *p;
        int r;
 
        assert(IN_SET(family, AF_UNSPEC, AF_INET, AF_INET6));
        assert(ptr);
        assert(ret);
 
        if (isempty(*ptr)) {
                *ptr = NULL;
                *ret = NULL;
                return 0;
        }
 
        if (**ptr != '[')
                return extract_first_word(ptr, ret, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
 
        if (family == AF_INET)
                return -EINVAL;
 
        p = *ptr + 1;
        r = extract_first_word(&p, &buf, "]", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r < 0)
                return r;
        if (r == 0)
                return -EINVAL; /* Missing "]". */
 
        if (!isempty(p)) {
                if (p[0] != ':')
                        return -EINVAL; /* Missing ":" after "]". */
                p++;
        }
 
        *ptr = p;
        *ret = TAKE_PTR(buf);
        return 1;
}
 
static int extract_ip_address(int family, const char **ptr, union in_addr_union *ret) {
        _cleanup_free_ char *buf = NULL;
        const char *p;
        int r, k;
 
        assert(IN_SET(family, AF_INET, AF_INET6));
        assert(ptr);
        assert(ret);
 
        p = *ptr;
        r = extract_ip_address_str(family, &p, &buf);
        if (r < 0)
                return r;
 
        if (isempty(buf)) {
                *ret = IN_ADDR_NULL;
                r = 0;
        } else {
                assert(r > 0);
                k = in_addr_from_string(family, buf, ret);
                if (k < 0)
                        return k;
        }
 
        *ptr = p;
        return r;
}
 
static int extract_netmask_or_prefixlen(int family, const char **ptr, unsigned char *ret) {
        _cleanup_free_ char *buf = NULL;
        const char *p;
        int r;
 
        assert(IN_SET(family, AF_INET, AF_INET6));
        assert(ptr);
        assert(ret);
 
        if (family == AF_INET) {
                union in_addr_union netmask;
 
                p = *ptr;
                r = extract_ip_address(family, &p, &netmask);
                if (r > 0) {
                        *ptr = p;
                        *ret = in4_addr_netmask_to_prefixlen(&netmask.in);
                        return 0;
                }
        }
 
        p = *ptr;
        r = extract_first_word(&p, &buf, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r < 0)
                return r;
        if (isempty(buf))
                *ret = family == AF_INET6 ? 128 : 32;
        else {
                r = safe_atou8(buf, ret);
                if (r < 0)
                        return r;
        }
 
        *ptr = p;
        return 0;
}
 
static int parse_cmdline_ip_address(Context *context, int family, const char *value) {
        union in_addr_union addr, peer = {}, gateway = {};
        unsigned char prefixlen;
        int r;
 
        assert(context);
        assert(IN_SET(family, AF_INET, AF_INET6));
        assert(value);
 
        /* ip=<client-IP>:[<peer>]:<gateway-IP>:<netmask>:<client_hostname>:<interface>:{none|off|dhcp|on|any|dhcp6|auto6|ibft|link6}[:[<mtu>][:<macaddr>]]
         * ip=<client-IP>:[<peer>]:<gateway-IP>:<netmask>:<client_hostname>:<interface>:{none|off|dhcp|on|any|dhcp6|auto6|ibft|link6}[:[<dns1>][:<dns2>]]
         *
         * Here, only DHCP type is mandatory. */
 
        const char *p = value;
        r = extract_ip_address(family, &p, &addr);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse IP address in ip=%s: %m", value);
        r = extract_ip_address(family, &p, &peer);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse peer address in ip=%s: %m", value);
        r = extract_ip_address(family, &p, &gateway);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse gateway address in ip=%s: %m", value);
        r = extract_netmask_or_prefixlen(family, &p, &prefixlen);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse netmask in ip=%s: %m", value);
 
        /* hostname */
        _cleanup_free_ char *hostname = NULL;
        r = extract_first_word(&p, &hostname, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse hostname in ip=%s: %m", value);
 
        /* ifname */
        _cleanup_free_ char *ifname = NULL;
        r = extract_first_word(&p, &ifname, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse interface name in ip=%s: %m", value);
 
        /* dhcp_type */
        _cleanup_free_ char *dhcp_type = NULL;
        r = extract_first_word(&p, &dhcp_type, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse DHCP type name in ip=%s: %m", value);
 
        /* set values */
        r = network_set_address(context, ifname, family, prefixlen, &addr, &peer);
        if (r < 0)
                return r;
 
        r = network_set_route(context, ifname, family, 0, NULL, &gateway);
        if (r < 0)
                return r;
 
        r = network_set_hostname(context, ifname, hostname);
        if (r < 0)
                return r;
 
        r = network_set_dhcp_type(context, ifname, dhcp_type);
        if (r < 0)
                return r;
 
        /* First, try [<mtu>][:<macaddr>] if an interface name is specified. */
        if (!isempty(ifname) && parse_cmdline_ip_mtu_mac(context, ifname, p) >= 0)
                return 0;
 
        /* Next, try [<dns1>][:<dns2>] */
        _cleanup_free_ char *dns = NULL;
        r = extract_ip_address_str(AF_UNSPEC, &p, &dns);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse DNS address in ip=%s: %m", value);
        if (r == 0)
                return 0;
 
        r = network_set_dns(context, ifname, dns);
        if (r < 0)
                return r;
 
        dns = mfree(dns);
        r = extract_ip_address_str(AF_UNSPEC, &p, &dns);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse DNS address in ip=%s: %m", value);
        if (r == 0)
                return 0;
 
        r = network_set_dns(context, ifname, dns);
        if (r < 0)
                return r;
 
        /* Next, try [:<ntp>] */
        _cleanup_free_ char *ntp = NULL;
        r = extract_ip_address_str(AF_UNSPEC, &p, &ntp);
        if (r < 0)
                return log_debug_errno(r, "Failed to parse NTP address in ip=%s: %m", value);
        if (r == 0)
                return 0;
 
        r = network_set_ntp(context, ifname, ntp);
        if (r < 0)
                return r;
 
        /* refuse unexpected trailing strings */
        if (!isempty(p))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unexpected trailing string in 'ip=%s'.", value);
 
        return 0;
}
 
static int parse_cmdline_ip_interface(Context *context, const char *value) {
        _cleanup_free_ char *ifname = NULL, *dhcp_type = NULL;
        int r;
 
        assert(context);
        assert(value);
 
        /* ip=<interface>:{dhcp|on|any|dhcp6|auto6|link6}[:[<mtu>][:<macaddr>]] */
 
        const char *p = value;
        r = extract_first_word(&p, &ifname, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse interface name in ip=%s: %m", value);
 
        if (isempty(ifname))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Missing interface name in ip=%s.", value);
 
        r = extract_first_word(&p, &dhcp_type, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
        if (r <= 0)
                return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse DHCP type in ip=%s: %m", value);
 
        r = network_set_dhcp_type(context, ifname, dhcp_type);
        if (r < 0)
                return r;
 
        return parse_cmdline_ip_mtu_mac(context, ifname, p);
}
 
static int parse_cmdline_ip(Context *context, const char *key, const char *value) {
        const char *p;
        int r;
 
        assert(context);
        assert(key);
 
        if (proc_cmdline_value_missing(key, value))
                return 0;
 
        p = strchr(value, ':');
        if (!p)
                /* ip={dhcp|on|any|dhcp6|auto6|either6|link6} */
                return network_set_dhcp_type(context, "", value);
 
        /* extract_first_word() eats the trailing separator, so check this earlier. */
        if (endswith(value, ":"))
                return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unexpected trailing colon in 'ip=%s'.", value);
 
        if (value[0] == '[')
                return parse_cmdline_ip_address(context, AF_INET6, value);
 
        r = parse_cmdline_ip_address(context, AF_INET, value);
        if (r < 0)
                return parse_cmdline_ip_interface(context, value);
 
        return 0;
}