repo
stringlengths 1
152
⌀ | file
stringlengths 14
221
| code
stringlengths 501
25k
| file_length
int64 501
25k
| avg_line_length
float64 20
99.5
| max_line_length
int64 21
134
| extension_type
stringclasses 2
values |
|---|---|---|---|---|---|---|
null |
systemd-main/src/network/networkd-sriov.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include "device-enumerator-private.h"
#include "device-util.h"
#include "fd-util.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-queue.h"
#include "networkd-sriov.h"
static int sr_iov_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, SRIOV *sr_iov) {
int r;
assert(m);
assert(link);
r = sd_netlink_message_get_errno(m);
if (r < 0 && r != -EEXIST) {
log_link_message_error_errno(link, m, r, "Could not set up SR-IOV");
link_enter_failed(link);
return 1;
}
if (link->sr_iov_messages == 0) {
log_link_debug(link, "SR-IOV configured");
link->sr_iov_configured = true;
link_check_ready(link);
}
return 1;
}
static int sr_iov_configure(SRIOV *sr_iov, Link *link, Request *req) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(sr_iov);
assert(link);
assert(link->manager);
assert(link->manager->rtnl);
assert(link->ifindex > 0);
assert(req);
log_link_debug(link, "Setting SR-IOV virtual function %"PRIu32".", sr_iov->vf);
r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_SETLINK, link->ifindex);
if (r < 0)
return r;
r = sr_iov_set_netlink_message(sr_iov, m);
if (r < 0)
return r;
return request_call_netlink_async(link->manager->rtnl, m, req);
}
static int sr_iov_process_request(Request *req, Link *link, SRIOV *sr_iov) {
int r;
assert(req);
assert(link);
assert(sr_iov);
if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
return 0;
r = sr_iov_configure(sr_iov, link, req);
if (r < 0)
return log_link_warning_errno(link, r,
"Failed to configure SR-IOV virtual function %"PRIu32": %m",
sr_iov->vf);
return 1;
}
int link_request_sr_iov_vfs(Link *link) {
SRIOV *sr_iov;
int r;
assert(link);
assert(link->network);
link->sr_iov_configured = false;
ORDERED_HASHMAP_FOREACH(sr_iov, link->network->sr_iov_by_section) {
r = link_queue_request_safe(link, REQUEST_TYPE_SRIOV,
sr_iov, NULL,
sr_iov_hash_func,
sr_iov_compare_func,
sr_iov_process_request,
&link->sr_iov_messages,
sr_iov_handler,
NULL);
if (r < 0)
return log_link_warning_errno(link, r,
"Failed to request SR-IOV virtual function %"PRIu32": %m",
sr_iov->vf);
}
if (link->sr_iov_messages == 0) {
link->sr_iov_configured = true;
link_check_ready(link);
} else
log_link_debug(link, "Configuring SR-IOV");
return 0;
}
static int find_ifindex_from_pci_dev_port(sd_device *pci_dev, const char *dev_port) {
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
sd_device *dev;
int ifindex, r;
assert(pci_dev);
assert(dev_port);
r = sd_device_enumerator_new(&e);
if (r < 0)
return r;
r = sd_device_enumerator_allow_uninitialized(e);
if (r < 0)
return r;
r = sd_device_enumerator_add_match_parent(e, pci_dev);
if (r < 0)
return r;
r = sd_device_enumerator_add_match_subsystem(e, "net", true);
if (r < 0)
return r;
r = sd_device_enumerator_add_match_sysattr(e, "dev_port", dev_port, true);
if (r < 0)
return r;
dev = sd_device_enumerator_get_device_first(e);
if (!dev)
return -ENODEV; /* no device found */
if (sd_device_enumerator_get_device_next(e))
return -ENXIO; /* multiple devices found */
r = sd_device_get_ifindex(dev, &ifindex);
if (r < 0)
return r;
assert(ifindex > 0);
return ifindex;
}
static int manager_update_sr_iov_ifindices(Manager *manager, int phys_port_ifindex, int virt_port_ifindex) {
Link *phys_link = NULL, *virt_link = NULL;
int r;
assert(manager);
assert(phys_port_ifindex > 0);
assert(virt_port_ifindex > 0);
/* This sets ifindices only when both interfaces are already managed by us. */
r = link_get_by_index(manager, phys_port_ifindex, &phys_link);
if (r < 0)
return r;
r = link_get_by_index(manager, virt_port_ifindex, &virt_link);
if (r < 0)
return r;
/* update VF ifindex in PF */
r = set_ensure_put(&phys_link->sr_iov_virt_port_ifindices, NULL, INT_TO_PTR(virt_port_ifindex));
if (r < 0)
return r;
log_link_debug(phys_link,
"Found SR-IOV VF port %s(%i).",
virt_link ? virt_link->ifname : "n/a", virt_port_ifindex);
/* update PF ifindex in VF */
if (virt_link->sr_iov_phys_port_ifindex > 0 && virt_link->sr_iov_phys_port_ifindex != phys_port_ifindex) {
Link *old_phys_link;
if (link_get_by_index(manager, virt_link->sr_iov_phys_port_ifindex, &old_phys_link) >= 0)
set_remove(old_phys_link->sr_iov_virt_port_ifindices, INT_TO_PTR(virt_port_ifindex));
}
virt_link->sr_iov_phys_port_ifindex = phys_port_ifindex;
log_link_debug(virt_link,
"Found SR-IOV PF port %s(%i).",
phys_link ? phys_link->ifname : "n/a", phys_port_ifindex);
return 0;
}
static int link_set_sr_iov_phys_port(Link *link) {
_cleanup_(sd_device_unrefp) sd_device *pci_physfn_dev = NULL;
const char *dev_port;
sd_device *pci_dev;
int r;
assert(link);
assert(link->manager);
if (link->sr_iov_phys_port_ifindex > 0)
return 0;
if (!link->dev)
return -ENODEV;
r = sd_device_get_sysattr_value(link->dev, "dev_port", &dev_port);
if (r < 0)
return r;
r = sd_device_get_parent_with_subsystem_devtype(link->dev, "pci", NULL, &pci_dev);
if (r < 0)
return r;
r = sd_device_new_child(&pci_physfn_dev, pci_dev, "physfn");
if (r < 0)
return r;
r = find_ifindex_from_pci_dev_port(pci_physfn_dev, dev_port);
if (r < 0)
return r;
return manager_update_sr_iov_ifindices(link->manager, r, link->ifindex);
}
static int link_set_sr_iov_virt_ports(Link *link) {
const char *dev_port, *name;
sd_device *pci_dev;
int r;
assert(link);
assert(link->manager);
set_clear(link->sr_iov_virt_port_ifindices);
if (!link->dev)
return -ENODEV;
r = sd_device_get_sysattr_value(link->dev, "dev_port", &dev_port);
if (r < 0)
return r;
r = sd_device_get_parent_with_subsystem_devtype(link->dev, "pci", NULL, &pci_dev);
if (r < 0)
return r;
FOREACH_DEVICE_CHILD_WITH_SUFFIX(pci_dev, child, name) {
const char *n;
/* Accept name prefixed with "virtfn", but refuse "virtfn" itself. */
n = startswith(name, "virtfn");
if (isempty(n) || !in_charset(n, DIGITS))
continue;
r = find_ifindex_from_pci_dev_port(child, dev_port);
if (r < 0)
continue;
if (manager_update_sr_iov_ifindices(link->manager, link->ifindex, r) < 0)
continue;
}
return 0;
}
int link_set_sr_iov_ifindices(Link *link) {
int r;
assert(link);
r = link_set_sr_iov_phys_port(link);
if (r < 0 && !ERRNO_IS_DEVICE_ABSENT(r))
return r;
r = link_set_sr_iov_virt_ports(link);
if (r < 0 && !ERRNO_IS_DEVICE_ABSENT(r))
return r;
return 0;
}
void link_clear_sr_iov_ifindices(Link *link) {
void *v;
assert(link);
assert(link->manager);
if (link->sr_iov_phys_port_ifindex > 0) {
Link *phys_link;
if (link_get_by_index(link->manager, link->sr_iov_phys_port_ifindex, &phys_link) >= 0)
set_remove(phys_link->sr_iov_virt_port_ifindices, INT_TO_PTR(link->ifindex));
link->sr_iov_phys_port_ifindex = 0;
}
while ((v = set_steal_first(link->sr_iov_virt_port_ifindices))) {
Link *virt_link;
if (link_get_by_index(link->manager, PTR_TO_INT(v), &virt_link) >= 0)
virt_link->sr_iov_phys_port_ifindex = 0;
}
}
bool check_ready_for_all_sr_iov_ports(
Link *link,
bool allow_unmanaged, /* for the main target */
bool (check_one)(Link *link, bool allow_unmanaged)) {
Link *phys_link;
void *v;
assert(link);
assert(link->manager);
assert(check_one);
/* Some drivers make VF ports become down when their PF port becomes down, and may fail to configure
* VF ports. Also, when a VF port becomes up/down, its PF port and other VF ports may become down.
* See issue #23315. */
/* First, check the main target. */
if (!check_one(link, allow_unmanaged))
return false;
/* If this is a VF port, then also check the PF port. */
if (link->sr_iov_phys_port_ifindex > 0) {
if (link_get_by_index(link->manager, link->sr_iov_phys_port_ifindex, &phys_link) < 0 ||
!check_one(phys_link, /* allow_unmanaged = */ true))
return false;
} else
phys_link = link;
/* Also check all VF ports. */
SET_FOREACH(v, phys_link->sr_iov_virt_port_ifindices) {
int ifindex = PTR_TO_INT(v);
Link *virt_link;
if (ifindex == link->ifindex)
continue; /* The main target link is a VF port, and its state is already checked. */
if (link_get_by_index(link->manager, ifindex, &virt_link) < 0)
return false;
if (!check_one(virt_link, /* allow_unmanaged = */ true))
return false;
}
return true;
}
| 11,226 | 30.625352 | 114 |
c
|
null |
systemd-main/src/network/networkd-sysctl.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <netinet/in.h>
#include <linux/if.h>
#include "missing_network.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-network.h"
#include "networkd-sysctl.h"
#include "socket-util.h"
#include "string-table.h"
#include "sysctl-util.h"
static int link_update_ipv6_sysctl(Link *link) {
assert(link);
if (link->flags & IFF_LOOPBACK)
return 0;
if (!link_ipv6_enabled(link))
return 0;
return sysctl_write_ip_property_boolean(AF_INET6, link->ifname, "disable_ipv6", false);
}
static int link_set_proxy_arp(Link *link) {
assert(link);
if (link->flags & IFF_LOOPBACK)
return 0;
if (!link->network)
return 0;
if (link->network->proxy_arp < 0)
return 0;
return sysctl_write_ip_property_boolean(AF_INET, link->ifname, "proxy_arp", link->network->proxy_arp > 0);
}
static bool link_ip_forward_enabled(Link *link, int family) {
assert(link);
assert(IN_SET(family, AF_INET, AF_INET6));
if (family == AF_INET6 && !socket_ipv6_is_supported())
return false;
if (link->flags & IFF_LOOPBACK)
return false;
if (!link->network)
return false;
return link->network->ip_forward & (family == AF_INET ? ADDRESS_FAMILY_IPV4 : ADDRESS_FAMILY_IPV6);
}
static int link_set_ipv4_forward(Link *link) {
assert(link);
if (!link_ip_forward_enabled(link, AF_INET))
return 0;
/* We propagate the forwarding flag from one interface to the
* global setting one way. This means: as long as at least one
* interface was configured at any time that had IP forwarding
* enabled the setting will stay on for good. We do this
* primarily to keep IPv4 and IPv6 packet forwarding behaviour
* somewhat in sync (see below). */
return sysctl_write_ip_property(AF_INET, NULL, "ip_forward", "1");
}
static int link_set_ipv6_forward(Link *link) {
assert(link);
if (!link_ip_forward_enabled(link, AF_INET6))
return 0;
/* On Linux, the IPv6 stack does not know a per-interface
* packet forwarding setting: either packet forwarding is on
* for all, or off for all. We hence don't bother with a
* per-interface setting, but simply propagate the interface
* flag, if it is set, to the global flag, one-way. Note that
* while IPv4 would allow a per-interface flag, we expose the
* same behaviour there and also propagate the setting from
* one to all, to keep things simple (see above). */
return sysctl_write_ip_property(AF_INET6, "all", "forwarding", "1");
}
static int link_set_ipv6_privacy_extensions(Link *link) {
IPv6PrivacyExtensions val;
assert(link);
assert(link->manager);
if (!socket_ipv6_is_supported())
return 0;
if (link->flags & IFF_LOOPBACK)
return 0;
if (!link->network)
return 0;
val = link->network->ipv6_privacy_extensions;
if (val < 0) /* If not specified, then use the global setting. */
val = link->manager->ipv6_privacy_extensions;
/* When "kernel", do not update the setting. */
if (val == IPV6_PRIVACY_EXTENSIONS_KERNEL)
return 0;
return sysctl_write_ip_property_int(AF_INET6, link->ifname, "use_tempaddr", (int) val);
}
static int link_set_ipv6_accept_ra(Link *link) {
assert(link);
/* Make this a NOP if IPv6 is not available */
if (!socket_ipv6_is_supported())
return 0;
if (link->flags & IFF_LOOPBACK)
return 0;
if (!link->network)
return 0;
return sysctl_write_ip_property(AF_INET6, link->ifname, "accept_ra", "0");
}
static int link_set_ipv6_dad_transmits(Link *link) {
assert(link);
/* Make this a NOP if IPv6 is not available */
if (!socket_ipv6_is_supported())
return 0;
if (link->flags & IFF_LOOPBACK)
return 0;
if (!link->network)
return 0;
if (link->network->ipv6_dad_transmits < 0)
return 0;
return sysctl_write_ip_property_int(AF_INET6, link->ifname, "dad_transmits", link->network->ipv6_dad_transmits);
}
static int link_set_ipv6_hop_limit(Link *link) {
assert(link);
/* Make this a NOP if IPv6 is not available */
if (!socket_ipv6_is_supported())
return 0;
if (link->flags & IFF_LOOPBACK)
return 0;
if (!link->network)
return 0;
if (link->network->ipv6_hop_limit < 0)
return 0;
return sysctl_write_ip_property_int(AF_INET6, link->ifname, "hop_limit", link->network->ipv6_hop_limit);
}
static int link_set_ipv6_proxy_ndp(Link *link) {
bool v;
assert(link);
if (!socket_ipv6_is_supported())
return 0;
if (link->flags & IFF_LOOPBACK)
return 0;
if (!link->network)
return 0;
if (link->network->ipv6_proxy_ndp >= 0)
v = link->network->ipv6_proxy_ndp;
else
v = !set_isempty(link->network->ipv6_proxy_ndp_addresses);
return sysctl_write_ip_property_boolean(AF_INET6, link->ifname, "proxy_ndp", v);
}
int link_set_ipv6_mtu(Link *link) {
uint32_t mtu;
assert(link);
/* Make this a NOP if IPv6 is not available */
if (!socket_ipv6_is_supported())
return 0;
if (link->flags & IFF_LOOPBACK)
return 0;
if (!link->network)
return 0;
if (link->network->ipv6_mtu == 0)
return 0;
mtu = link->network->ipv6_mtu;
if (mtu > link->max_mtu) {
log_link_warning(link, "Reducing requested IPv6 MTU %"PRIu32" to the interface's maximum MTU %"PRIu32".",
mtu, link->max_mtu);
mtu = link->max_mtu;
}
return sysctl_write_ip_property_uint32(AF_INET6, link->ifname, "mtu", mtu);
}
static int link_set_ipv4_accept_local(Link *link) {
assert(link);
if (link->flags & IFF_LOOPBACK)
return 0;
if (link->network->ipv4_accept_local < 0)
return 0;
return sysctl_write_ip_property_boolean(AF_INET, link->ifname, "accept_local", link->network->ipv4_accept_local > 0);
}
static int link_set_ipv4_route_localnet(Link *link) {
assert(link);
if (link->flags & IFF_LOOPBACK)
return 0;
if (link->network->ipv4_route_localnet < 0)
return 0;
return sysctl_write_ip_property_boolean(AF_INET, link->ifname, "route_localnet", link->network->ipv4_route_localnet > 0);
}
int link_set_sysctl(Link *link) {
int r;
assert(link);
/* If IPv6 configured that is static IPv6 address and IPv6LL autoconfiguration is enabled
* for this interface, then enable IPv6 */
r = link_update_ipv6_sysctl(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot enable IPv6, ignoring: %m");
r = link_set_proxy_arp(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot configure proxy ARP for interface, ignoring: %m");
r = link_set_ipv4_forward(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot turn on IPv4 packet forwarding, ignoring: %m");
r = link_set_ipv6_forward(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot configure IPv6 packet forwarding, ignoring: %m");
r = link_set_ipv6_privacy_extensions(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot configure IPv6 privacy extensions for interface, ignoring: %m");
r = link_set_ipv6_accept_ra(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot disable kernel IPv6 accept_ra for interface, ignoring: %m");
r = link_set_ipv6_dad_transmits(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot set IPv6 dad transmits for interface, ignoring: %m");
r = link_set_ipv6_hop_limit(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot set IPv6 hop limit for interface, ignoring: %m");
r = link_set_ipv6_proxy_ndp(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot set IPv6 proxy NDP, ignoring: %m");
r = link_set_ipv6_mtu(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot set IPv6 MTU, ignoring: %m");
r = link_set_ipv6ll_stable_secret(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot set stable secret address for IPv6 link-local address: %m");
r = link_set_ipv4_accept_local(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot set IPv4 accept_local flag for interface, ignoring: %m");
r = link_set_ipv4_route_localnet(link);
if (r < 0)
log_link_warning_errno(link, r, "Cannot set IPv4 route_localnet flag for interface, ignoring: %m");
/* If promote_secondaries is not set, DHCP will work only as long as the IP address does not
* changes between leases. The kernel will remove all secondary IP addresses of an interface
* otherwise. The way systemd-networkd works is that the new IP of a lease is added as a
* secondary IP and when the primary one expires it relies on the kernel to promote the
* secondary IP. See also https://github.com/systemd/systemd/issues/7163 */
r = sysctl_write_ip_property_boolean(AF_INET, link->ifname, "promote_secondaries", true);
if (r < 0)
log_link_warning_errno(link, r, "Cannot enable promote_secondaries for interface, ignoring: %m");
return 0;
}
static const char* const ipv6_privacy_extensions_table[_IPV6_PRIVACY_EXTENSIONS_MAX] = {
[IPV6_PRIVACY_EXTENSIONS_NO] = "no",
[IPV6_PRIVACY_EXTENSIONS_PREFER_PUBLIC] = "prefer-public",
[IPV6_PRIVACY_EXTENSIONS_YES] = "yes",
[IPV6_PRIVACY_EXTENSIONS_KERNEL] = "kernel",
};
DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(ipv6_privacy_extensions, IPv6PrivacyExtensions,
IPV6_PRIVACY_EXTENSIONS_YES);
DEFINE_CONFIG_PARSE_ENUM(config_parse_ipv6_privacy_extensions, ipv6_privacy_extensions, IPv6PrivacyExtensions,
"Failed to parse IPv6 privacy extensions option");
| 10,942 | 32.362805 | 129 |
c
|
null |
systemd-main/src/network/networkd-sysctl.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include "conf-parser.h"
typedef struct Link Link;
typedef enum IPv6PrivacyExtensions {
/* The values map to the kernel's /proc/sys/net/ipv6/conf/xxx/use_tempaddr values */
IPV6_PRIVACY_EXTENSIONS_NO,
IPV6_PRIVACY_EXTENSIONS_PREFER_PUBLIC,
IPV6_PRIVACY_EXTENSIONS_YES, /* aka prefer-temporary */
IPV6_PRIVACY_EXTENSIONS_KERNEL, /* keep the kernel's default value */
_IPV6_PRIVACY_EXTENSIONS_MAX,
_IPV6_PRIVACY_EXTENSIONS_INVALID = -EINVAL,
} IPv6PrivacyExtensions;
int link_set_sysctl(Link *link);
int link_set_ipv6_mtu(Link *link);
const char* ipv6_privacy_extensions_to_string(IPv6PrivacyExtensions i) _const_;
IPv6PrivacyExtensions ipv6_privacy_extensions_from_string(const char *s) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_ipv6_privacy_extensions);
| 906 | 32.592593 | 92 |
h
|
null |
systemd-main/src/network/networkd-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "condition.h"
#include "conf-parser.h"
#include "escape.h"
#include "logarithm.h"
#include "networkd-link.h"
#include "networkd-util.h"
#include "parse-util.h"
#include "string-table.h"
#include "string-util.h"
#include "web-util.h"
/* This is used in log messages, and never used in parsing settings. So, upper cases are OK. */
static const char * const network_config_source_table[_NETWORK_CONFIG_SOURCE_MAX] = {
[NETWORK_CONFIG_SOURCE_FOREIGN] = "foreign",
[NETWORK_CONFIG_SOURCE_STATIC] = "static",
[NETWORK_CONFIG_SOURCE_IPV4LL] = "IPv4LL",
[NETWORK_CONFIG_SOURCE_DHCP4] = "DHCPv4",
[NETWORK_CONFIG_SOURCE_DHCP6] = "DHCPv6",
[NETWORK_CONFIG_SOURCE_DHCP_PD] = "DHCP-PD",
[NETWORK_CONFIG_SOURCE_NDISC] = "NDisc",
[NETWORK_CONFIG_SOURCE_RUNTIME] = "runtime",
};
DEFINE_STRING_TABLE_LOOKUP_TO_STRING(network_config_source, NetworkConfigSource);
int network_config_state_to_string_alloc(NetworkConfigState s, char **ret) {
static const char* states[] = {
[LOG2U(NETWORK_CONFIG_STATE_REQUESTING)] = "requesting",
[LOG2U(NETWORK_CONFIG_STATE_CONFIGURING)] = "configuring",
[LOG2U(NETWORK_CONFIG_STATE_CONFIGURED)] = "configured",
[LOG2U(NETWORK_CONFIG_STATE_MARKED)] = "marked",
[LOG2U(NETWORK_CONFIG_STATE_REMOVING)] = "removing",
};
_cleanup_free_ char *buf = NULL;
assert(ret);
for (size_t i = 0; i < ELEMENTSOF(states); i++)
if (FLAGS_SET(s, 1 << i)) {
assert(states[i]);
if (!strextend_with_separator(&buf, ",", states[i]))
return -ENOMEM;
}
*ret = TAKE_PTR(buf);
return 0;
}
static const char * const address_family_table[_ADDRESS_FAMILY_MAX] = {
[ADDRESS_FAMILY_NO] = "no",
[ADDRESS_FAMILY_YES] = "yes",
[ADDRESS_FAMILY_IPV4] = "ipv4",
[ADDRESS_FAMILY_IPV6] = "ipv6",
};
static const char * const routing_policy_rule_address_family_table[_ADDRESS_FAMILY_MAX] = {
[ADDRESS_FAMILY_YES] = "both",
[ADDRESS_FAMILY_IPV4] = "ipv4",
[ADDRESS_FAMILY_IPV6] = "ipv6",
};
static const char * const nexthop_address_family_table[_ADDRESS_FAMILY_MAX] = {
[ADDRESS_FAMILY_IPV4] = "ipv4",
[ADDRESS_FAMILY_IPV6] = "ipv6",
};
static const char * const duplicate_address_detection_address_family_table[_ADDRESS_FAMILY_MAX] = {
[ADDRESS_FAMILY_NO] = "none",
[ADDRESS_FAMILY_YES] = "both",
[ADDRESS_FAMILY_IPV4] = "ipv4",
[ADDRESS_FAMILY_IPV6] = "ipv6",
};
static const char * const dhcp_deprecated_address_family_table[_ADDRESS_FAMILY_MAX] = {
[ADDRESS_FAMILY_NO] = "none",
[ADDRESS_FAMILY_YES] = "both",
[ADDRESS_FAMILY_IPV4] = "v4",
[ADDRESS_FAMILY_IPV6] = "v6",
};
static const char * const ip_masquerade_address_family_table[_ADDRESS_FAMILY_MAX] = {
[ADDRESS_FAMILY_NO] = "no",
[ADDRESS_FAMILY_YES] = "both",
[ADDRESS_FAMILY_IPV4] = "ipv4",
[ADDRESS_FAMILY_IPV6] = "ipv6",
};
static const char * const dhcp_lease_server_type_table[_SD_DHCP_LEASE_SERVER_TYPE_MAX] = {
[SD_DHCP_LEASE_DNS] = "DNS servers",
[SD_DHCP_LEASE_NTP] = "NTP servers",
[SD_DHCP_LEASE_SIP] = "SIP servers",
[SD_DHCP_LEASE_POP3] = "POP3 servers",
[SD_DHCP_LEASE_SMTP] = "SMTP servers",
[SD_DHCP_LEASE_LPR] = "LPR servers",
};
DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(address_family, AddressFamily, ADDRESS_FAMILY_YES);
AddressFamily link_local_address_family_from_string(const char *s) {
if (streq_ptr(s, "fallback")) /* compat name */
return ADDRESS_FAMILY_YES;
if (streq_ptr(s, "fallback-ipv4")) /* compat name */
return ADDRESS_FAMILY_IPV4;
return address_family_from_string(s);
}
DEFINE_STRING_TABLE_LOOKUP(routing_policy_rule_address_family, AddressFamily);
DEFINE_STRING_TABLE_LOOKUP(nexthop_address_family, AddressFamily);
DEFINE_STRING_TABLE_LOOKUP(duplicate_address_detection_address_family, AddressFamily);
DEFINE_CONFIG_PARSE_ENUM(config_parse_link_local_address_family, link_local_address_family,
AddressFamily, "Failed to parse option");
DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(dhcp_deprecated_address_family, AddressFamily);
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(ip_masquerade_address_family, AddressFamily);
DEFINE_STRING_TABLE_LOOKUP(dhcp_lease_server_type, sd_dhcp_lease_server_type_t);
int config_parse_address_family_with_kernel(
const char* unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
AddressFamily *fwd = data, s;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
/* This function is mostly obsolete now. It simply redirects
* "kernel" to "no". In older networkd versions we used to
* distinguish IPForward=off from IPForward=kernel, where the
* former would explicitly turn off forwarding while the
* latter would simply not touch the setting. But that logic
* is gone, hence silently accept the old setting, but turn it
* to "no". */
s = address_family_from_string(rvalue);
if (s < 0) {
if (streq(rvalue, "kernel"))
s = ADDRESS_FAMILY_NO;
else {
log_syntax(unit, LOG_WARNING, filename, line, 0, "Failed to parse IPForward= option, ignoring: %s", rvalue);
return 0;
}
}
*fwd = s;
return 0;
}
int config_parse_ip_masquerade(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
AddressFamily a, *ret = data;
int r;
if (isempty(rvalue)) {
*ret = ADDRESS_FAMILY_NO;
return 0;
}
r = parse_boolean(rvalue);
if (r >= 0) {
if (r)
log_syntax(unit, LOG_WARNING, filename, line, 0,
"IPMasquerade=%s is deprecated, and it is handled as \"ipv4\" instead of \"both\". "
"Please use \"ipv4\" or \"both\".",
rvalue);
*ret = r ? ADDRESS_FAMILY_IPV4 : ADDRESS_FAMILY_NO;
return 0;
}
a = ip_masquerade_address_family_from_string(rvalue);
if (a < 0) {
log_syntax(unit, LOG_WARNING, filename, line, a,
"Failed to parse IPMasquerade= setting, ignoring assignment: %s", rvalue);
return 0;
}
*ret = a;
return 0;
}
int config_parse_mud_url(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_free_ char *unescaped = NULL;
char **url = ASSERT_PTR(data);
ssize_t l;
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*url = mfree(*url);
return 0;
}
l = cunescape(rvalue, 0, &unescaped);
if (l < 0) {
log_syntax(unit, LOG_WARNING, filename, line, l,
"Failed to unescape MUD URL, ignoring: %s", rvalue);
return 0;
}
if (l > UINT8_MAX || !http_url_is_valid(unescaped)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid MUD URL, ignoring: %s", rvalue);
return 0;
}
return free_and_replace(*url, unescaped);
}
int log_link_message_full_errno(Link *link, sd_netlink_message *m, int level, int err, const char *msg) {
const char *err_msg = NULL;
/* link may be NULL. */
(void) sd_netlink_message_read_string(m, NLMSGERR_ATTR_MSG, &err_msg);
return log_link_full_errno(link, level, err,
"%s: %s%s%s%m",
msg,
strempty(err_msg),
err_msg && !endswith(err_msg, ".") ? "." : "",
err_msg ? " " : "");
}
| 9,216 | 34.724806 | 132 |
c
|
null |
systemd-main/src/network/networkd-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-dhcp-lease.h"
#include "sd-netlink.h"
#include "conf-parser.h"
#include "hashmap.h"
#include "log.h"
#include "macro.h"
#include "network-util.h"
#include "string-util.h"
typedef struct Link Link;
typedef enum NetworkConfigSource {
NETWORK_CONFIG_SOURCE_FOREIGN, /* configured by kernel */
NETWORK_CONFIG_SOURCE_STATIC,
NETWORK_CONFIG_SOURCE_IPV4LL,
NETWORK_CONFIG_SOURCE_DHCP4,
NETWORK_CONFIG_SOURCE_DHCP6,
NETWORK_CONFIG_SOURCE_DHCP_PD,
NETWORK_CONFIG_SOURCE_NDISC,
NETWORK_CONFIG_SOURCE_RUNTIME, /* through D-Bus method */
_NETWORK_CONFIG_SOURCE_MAX,
_NETWORK_CONFIG_SOURCE_INVALID = -EINVAL,
} NetworkConfigSource;
typedef enum NetworkConfigState {
NETWORK_CONFIG_STATE_REQUESTING = 1 << 0, /* request is queued */
NETWORK_CONFIG_STATE_CONFIGURING = 1 << 1, /* e.g. address_configure() is called, but no response is received yet */
NETWORK_CONFIG_STATE_CONFIGURED = 1 << 2, /* e.g. address_configure() is called and received a response from kernel.
* Note that address may not be ready yet, so please use address_is_ready()
* to check whether the address can be usable or not. */
NETWORK_CONFIG_STATE_MARKED = 1 << 3, /* used GC'ing the old config */
NETWORK_CONFIG_STATE_REMOVING = 1 << 4, /* e.g. address_remove() is called, but no response is received yet */
} NetworkConfigState;
static inline usec_t sec_to_usec(uint32_t sec, usec_t timestamp_usec) {
return
sec == 0 ? 0 :
sec == UINT32_MAX ? USEC_INFINITY :
usec_add(timestamp_usec, sec * USEC_PER_SEC);
}
static inline usec_t sec16_to_usec(uint16_t sec, usec_t timestamp_usec) {
return sec_to_usec(sec == UINT16_MAX ? UINT32_MAX : (uint32_t) sec, timestamp_usec);
}
static inline uint32_t usec_to_sec(usec_t usec, usec_t now_usec) {
return MIN(DIV_ROUND_UP(usec_sub_unsigned(usec, now_usec), USEC_PER_SEC), UINT32_MAX);
}
CONFIG_PARSER_PROTOTYPE(config_parse_link_local_address_family);
CONFIG_PARSER_PROTOTYPE(config_parse_address_family_with_kernel);
CONFIG_PARSER_PROTOTYPE(config_parse_ip_masquerade);
CONFIG_PARSER_PROTOTYPE(config_parse_mud_url);
const char *network_config_source_to_string(NetworkConfigSource s) _const_;
int network_config_state_to_string_alloc(NetworkConfigState s, char **ret);
#define DEFINE_NETWORK_CONFIG_STATE_FUNCTIONS(type, name) \
static inline void name##_update_state( \
type *t, \
NetworkConfigState mask, \
NetworkConfigState value) { \
\
assert(t); \
\
t->state = (t->state & ~mask) | (value & mask); \
} \
static inline bool name##_exists(const type *t) { \
assert(t); \
\
if ((t->state & (NETWORK_CONFIG_STATE_CONFIGURING | \
NETWORK_CONFIG_STATE_CONFIGURED)) == 0) \
return false; /* Not assigned yet. */ \
if (FLAGS_SET(t->state, NETWORK_CONFIG_STATE_REMOVING)) \
return false; /* Already removing. */ \
return true; \
} \
static inline void name##_enter_requesting(type *t) { \
name##_update_state(t, \
NETWORK_CONFIG_STATE_REQUESTING, \
NETWORK_CONFIG_STATE_REQUESTING); \
} \
static inline void name##_cancel_requesting(type *t) { \
name##_update_state(t, \
NETWORK_CONFIG_STATE_REQUESTING, \
0); \
} \
static inline bool name##_is_requesting(const type *t) { \
assert(t); \
return FLAGS_SET(t->state, NETWORK_CONFIG_STATE_REQUESTING); \
} \
static inline void name##_enter_configuring(type *t) { \
name##_update_state(t, \
NETWORK_CONFIG_STATE_REQUESTING | \
NETWORK_CONFIG_STATE_CONFIGURING | \
NETWORK_CONFIG_STATE_REMOVING, \
NETWORK_CONFIG_STATE_CONFIGURING); \
} \
static inline void name##_enter_configured(type *t) { \
name##_update_state(t, \
NETWORK_CONFIG_STATE_CONFIGURING | \
NETWORK_CONFIG_STATE_CONFIGURED, \
NETWORK_CONFIG_STATE_CONFIGURED); \
} \
static inline void name##_mark(type *t) { \
name##_update_state(t, \
NETWORK_CONFIG_STATE_MARKED, \
NETWORK_CONFIG_STATE_MARKED); \
} \
static inline void name##_unmark(type *t) { \
name##_update_state(t, NETWORK_CONFIG_STATE_MARKED, 0); \
} \
static inline bool name##_is_marked(const type *t) { \
assert(t); \
return FLAGS_SET(t->state, NETWORK_CONFIG_STATE_MARKED); \
} \
static inline void name##_enter_removing(type *t) { \
name##_update_state(t, \
NETWORK_CONFIG_STATE_MARKED | \
NETWORK_CONFIG_STATE_REMOVING, \
NETWORK_CONFIG_STATE_REMOVING); \
} \
static inline bool name##_is_removing(const type *t) { \
assert(t); \
return FLAGS_SET(t->state, NETWORK_CONFIG_STATE_REMOVING); \
} \
static inline void name##_enter_removed(type *t) { \
name##_update_state(t, \
NETWORK_CONFIG_STATE_CONFIGURED | \
NETWORK_CONFIG_STATE_REMOVING, \
0); \
}
const char *address_family_to_string(AddressFamily b) _const_;
AddressFamily address_family_from_string(const char *s) _pure_;
AddressFamily link_local_address_family_from_string(const char *s) _pure_;
const char *routing_policy_rule_address_family_to_string(AddressFamily b) _const_;
AddressFamily routing_policy_rule_address_family_from_string(const char *s) _pure_;
const char *nexthop_address_family_to_string(AddressFamily b) _const_;
AddressFamily nexthop_address_family_from_string(const char *s) _pure_;
const char *duplicate_address_detection_address_family_to_string(AddressFamily b) _const_;
AddressFamily duplicate_address_detection_address_family_from_string(const char *s) _pure_;
AddressFamily dhcp_deprecated_address_family_from_string(const char *s) _pure_;
const char *dhcp_lease_server_type_to_string(sd_dhcp_lease_server_type_t t) _const_;
sd_dhcp_lease_server_type_t dhcp_lease_server_type_from_string(const char *s) _pure_;
int log_link_message_full_errno(Link *link, sd_netlink_message *m, int level, int err, const char *msg);
#define log_link_message_error_errno(link, m, err, msg) log_link_message_full_errno(link, m, LOG_ERR, err, msg)
#define log_link_message_warning_errno(link, m, err, msg) log_link_message_full_errno(link, m, LOG_WARNING, err, msg)
#define log_link_message_notice_errno(link, m, err, msg) log_link_message_full_errno(link, m, LOG_NOTICE, err, msg)
#define log_link_message_info_errno(link, m, err, msg) log_link_message_full_errno(link, m, LOG_INFO, err, msg)
#define log_link_message_debug_errno(link, m, err, msg) log_link_message_full_errno(link, m, LOG_DEBUG, err, msg)
#define log_message_full_errno(m, level, err, msg) log_link_message_full_errno(NULL, m, level, err, msg)
#define log_message_error_errno(m, err, msg) log_message_full_errno(m, LOG_ERR, err, msg)
#define log_message_warning_errno(m, err, msg) log_message_full_errno(m, LOG_WARNING, err, msg)
#define log_message_notice_errno(m, err, msg) log_message_full_errno(m, LOG_NOTICE, err, msg)
#define log_message_info_errno(m, err, msg) log_message_full_errno(m, LOG_INFO, err, msg)
#define log_message_debug_errno(m, err, msg) log_message_full_errno(m, LOG_DEBUG, err, msg)
| 10,331 | 59.776471 | 126 |
h
|
null |
systemd-main/src/network/networkd-wifi.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/ethernet.h>
#include <linux/nl80211.h>
#include "ether-addr-util.h"
#include "netlink-util.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-wifi.h"
#include "networkd-wiphy.h"
#include "string-util.h"
#include "wifi-util.h"
int link_get_wlan_interface(Link *link) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
int r;
assert(link);
r = sd_genl_message_new(link->manager->genl, NL80211_GENL_NAME, NL80211_CMD_GET_INTERFACE, &req);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to create generic netlink message: %m");
r = sd_netlink_message_append_u32(req, NL80211_ATTR_IFINDEX, link->ifindex);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append NL80211_ATTR_IFINDEX attribute: %m");
r = sd_netlink_call(link->manager->genl, req, 0, &reply);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to request information about wlan interface: %m");
if (!reply) {
log_link_debug(link, "No reply received to request for information about wifi interface, ignoring.");
return 0;
}
return manager_genl_process_nl80211_config(link->manager->genl, reply, link->manager);
}
int manager_genl_process_nl80211_config(sd_netlink *genl, sd_netlink_message *message, Manager *manager) {
_cleanup_free_ char *ssid = NULL;
uint32_t ifindex, wlan_iftype;
const char *family, *ifname;
uint8_t cmd;
size_t len;
Link *link;
int r;
assert(genl);
assert(message);
assert(manager);
if (sd_netlink_message_is_error(message)) {
r = sd_netlink_message_get_errno(message);
if (r < 0)
log_message_warning_errno(message, r, "nl80211: received error message, ignoring");
return 0;
}
r = sd_genl_message_get_family_name(genl, message, &family);
if (r < 0) {
log_debug_errno(r, "nl80211: failed to determine genl family, ignoring: %m");
return 0;
}
if (!streq(family, NL80211_GENL_NAME)) {
log_debug("nl80211: received message of unexpected genl family '%s', ignoring.", family);
return 0;
}
r = sd_genl_message_get_command(genl, message, &cmd);
if (r < 0) {
log_debug_errno(r, "nl80211: failed to determine genl message command, ignoring: %m");
return 0;
}
if (IN_SET(cmd, NL80211_CMD_NEW_WIPHY, NL80211_CMD_DEL_WIPHY))
return manager_genl_process_nl80211_wiphy(genl, message, manager);
if (!IN_SET(cmd, NL80211_CMD_SET_INTERFACE, NL80211_CMD_NEW_INTERFACE, NL80211_CMD_DEL_INTERFACE)) {
log_debug("nl80211: ignoring nl80211 %s(%u) message.",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
r = sd_netlink_message_read_u32(message, NL80211_ATTR_IFINDEX, &ifindex);
if (r < 0) {
log_debug_errno(r, "nl80211: received %s(%u) message without valid ifindex, ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
r = link_get_by_index(manager, ifindex, &link);
if (r < 0) {
log_debug_errno(r, "nl80211: received %s(%u) message for link '%"PRIu32"' we don't know about, ignoring.",
strna(nl80211_cmd_to_string(cmd)), cmd, ifindex);
/* The NL80211_CMD_NEW_INTERFACE message might arrive before RTM_NEWLINK, in which case a
* link will not have been created yet. Store the interface index such that the wireless
* properties of the link (such as wireless interface type) are queried again after the link
* is created.
*/
if (cmd == NL80211_CMD_NEW_INTERFACE) {
r = set_ensure_put(&manager->new_wlan_ifindices, NULL, INT_TO_PTR(ifindex));
if (r < 0)
log_warning_errno(r, "Failed to add new wireless interface index to set, ignoring: %m");
} else if (cmd == NL80211_CMD_DEL_INTERFACE)
set_remove(manager->new_wlan_ifindices, INT_TO_PTR(ifindex));
return 0;
}
r = sd_netlink_message_read_string(message, NL80211_ATTR_IFNAME, &ifname);
if (r < 0) {
log_link_debug_errno(link, r, "nl80211: received %s(%u) message without valid interface name, ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
if (!streq(ifname, link->ifname)) {
log_link_debug_errno(link, r, "nl80211: received %s(%u) message with invalid interface name '%s', ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd, ifname);
return 0;
}
r = sd_netlink_message_read_u32(message, NL80211_ATTR_IFTYPE, &wlan_iftype);
if (r < 0) {
log_link_debug_errno(link, r, "nl80211: received %s(%u) message without valid wlan interface type, ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
r = sd_netlink_message_read_data_suffix0(message, NL80211_ATTR_SSID, &len, (void**) &ssid);
if (r < 0 && r != -ENODATA) {
log_link_debug_errno(link, r, "nl80211: received %s(%u) message without valid SSID, ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
if (r >= 0) {
if (len == 0) {
log_link_debug(link, "nl80211: received SSID has zero length, ignoring it: %m");
ssid = mfree(ssid);
} else if (strlen_ptr(ssid) != len) {
log_link_debug(link, "nl80211: received SSID contains NUL characters, ignoring it.");
ssid = mfree(ssid);
}
}
log_link_debug(link, "nl80211: received %s(%u) message: iftype=%s, ssid=%s",
strna(nl80211_cmd_to_string(cmd)), cmd,
strna(nl80211_iftype_to_string(wlan_iftype)), strna(ssid));
switch (cmd) {
case NL80211_CMD_SET_INTERFACE:
case NL80211_CMD_NEW_INTERFACE:
link->wlan_iftype = wlan_iftype;
free_and_replace(link->ssid, ssid);
break;
case NL80211_CMD_DEL_INTERFACE:
link->wlan_iftype = NL80211_IFTYPE_UNSPECIFIED;
link->ssid = mfree(link->ssid);
break;
default:
assert_not_reached();
}
return 0;
}
int manager_genl_process_nl80211_mlme(sd_netlink *genl, sd_netlink_message *message, Manager *manager) {
const char *family;
uint32_t ifindex;
uint8_t cmd;
Link *link;
int r;
assert(genl);
assert(message);
assert(manager);
if (sd_netlink_message_is_error(message)) {
r = sd_netlink_message_get_errno(message);
if (r < 0)
log_message_warning_errno(message, r, "nl80211: received error message, ignoring");
return 0;
}
r = sd_genl_message_get_family_name(genl, message, &family);
if (r < 0) {
log_debug_errno(r, "nl80211: failed to determine genl family, ignoring: %m");
return 0;
}
if (!streq(family, NL80211_GENL_NAME)) {
log_debug("nl80211: Received message of unexpected genl family '%s', ignoring.", family);
return 0;
}
r = sd_genl_message_get_command(genl, message, &cmd);
if (r < 0) {
log_debug_errno(r, "nl80211: failed to determine genl message command, ignoring: %m");
return 0;
}
r = sd_netlink_message_read_u32(message, NL80211_ATTR_IFINDEX, &ifindex);
if (r < 0) {
log_debug_errno(r, "nl80211: received %s(%u) message without valid ifindex, ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
r = link_get_by_index(manager, ifindex, &link);
if (r < 0) {
log_debug_errno(r, "nl80211: received %s(%u) message for link '%"PRIu32"' we don't know about, ignoring.",
strna(nl80211_cmd_to_string(cmd)), cmd, ifindex);
return 0;
}
switch (cmd) {
case NL80211_CMD_NEW_STATION:
case NL80211_CMD_DEL_STATION: {
struct ether_addr bssid;
r = sd_netlink_message_read_ether_addr(message, NL80211_ATTR_MAC, &bssid);
if (r < 0) {
log_link_debug_errno(link, r, "nl80211: received %s(%u) message without valid BSSID, ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
log_link_debug(link, "nl80211: received %s(%u) message: bssid=%s",
strna(nl80211_cmd_to_string(cmd)), cmd, ETHER_ADDR_TO_STR(&bssid));
if (cmd == NL80211_CMD_DEL_STATION) {
link->bssid = ETHER_ADDR_NULL;
return 0;
}
link->bssid = bssid;
if (manager->enumerating &&
link->wlan_iftype == NL80211_IFTYPE_STATION && link->ssid)
log_link_info(link, "Connected WiFi access point: %s (%s)",
link->ssid, ETHER_ADDR_TO_STR(&link->bssid));
break;
}
case NL80211_CMD_CONNECT: {
struct ether_addr bssid;
uint16_t status_code;
r = sd_netlink_message_read_ether_addr(message, NL80211_ATTR_MAC, &bssid);
if (r < 0 && r != -ENODATA) {
log_link_debug_errno(link, r, "nl80211: received %s(%u) message without valid BSSID, ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
r = sd_netlink_message_read_u16(message, NL80211_ATTR_STATUS_CODE, &status_code);
if (r < 0) {
log_link_debug_errno(link, r, "nl80211: received %s(%u) message without valid status code, ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
log_link_debug(link, "nl80211: received %s(%u) message: status=%u, bssid=%s",
strna(nl80211_cmd_to_string(cmd)), cmd, status_code, ETHER_ADDR_TO_STR(&bssid));
if (status_code != 0)
return 0;
link->bssid = bssid;
if (!manager->enumerating) {
r = link_get_wlan_interface(link);
if (r < 0) {
log_link_warning_errno(link, r, "Failed to update wireless LAN interface: %m");
link_enter_failed(link);
return 0;
}
}
if (link->wlan_iftype == NL80211_IFTYPE_STATION && link->ssid)
log_link_info(link, "Connected WiFi access point: %s (%s)",
link->ssid, ETHER_ADDR_TO_STR(&link->bssid));
/* Sometimes, RTM_NEWLINK message with carrier is received earlier than NL80211_CMD_CONNECT.
* To make SSID= or other WiFi related settings in [Match] section work, let's try to
* reconfigure the interface. */
if (link->ssid && link_has_carrier(link)) {
r = link_reconfigure_impl(link, /* force = */ false);
if (r < 0) {
log_link_warning_errno(link, r, "Failed to reconfigure interface: %m");
link_enter_failed(link);
return 0;
}
}
break;
}
case NL80211_CMD_DISCONNECT:
log_link_debug(link, "nl80211: received %s(%u) message.",
strna(nl80211_cmd_to_string(cmd)), cmd);
link->bssid = ETHER_ADDR_NULL;
free_and_replace(link->previous_ssid, link->ssid);
break;
case NL80211_CMD_START_AP: {
log_link_debug(link, "nl80211: received %s(%u) message.",
strna(nl80211_cmd_to_string(cmd)), cmd);
/* No need to reconfigure during enumeration */
if (manager->enumerating)
break;
/* If there is no carrier, let the link get configured on
* carrier gain instead */
if (!link_has_carrier(link))
break;
/* AP start event may indicate different properties (e.g. SSID) */
r = link_get_wlan_interface(link);
if (r < 0) {
log_link_warning_errno(link, r, "Failed to update wireless LAN interface: %m");
link_enter_failed(link);
return 0;
}
/* If necessary, reconfigure based on those new properties */
r = link_reconfigure_impl(link, /* force = */ false);
if (r < 0) {
log_link_warning_errno(link, r, "Failed to reconfigure interface: %m");
link_enter_failed(link);
return 0;
}
break;
}
default:
log_link_debug(link, "nl80211: received %s(%u) message.",
strna(nl80211_cmd_to_string(cmd)), cmd);
}
return 0;
}
| 14,612 | 41.234104 | 129 |
c
|
null |
systemd-main/src/network/networkd-wiphy.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if_arp.h>
#include <linux/nl80211.h>
#include "device-private.h"
#include "device-util.h"
#include "networkd-manager.h"
#include "networkd-wiphy.h"
#include "parse-util.h"
#include "path-util.h"
#include "udev-util.h"
#include "wifi-util.h"
Wiphy *wiphy_free(Wiphy *w) {
if (!w)
return NULL;
if (w->manager) {
hashmap_remove_value(w->manager->wiphy_by_index, UINT32_TO_PTR(w->index), w);
if (w->name)
hashmap_remove_value(w->manager->wiphy_by_name, w->name, w);
}
sd_device_unref(w->dev);
sd_device_unref(w->rfkill);
free(w->name);
return mfree(w);
}
static int wiphy_new(Manager *manager, sd_netlink_message *message, Wiphy **ret) {
_cleanup_(wiphy_freep) Wiphy *w = NULL;
_cleanup_free_ char *name = NULL;
uint32_t index;
int r;
assert(manager);
assert(message);
r = sd_netlink_message_read_u32(message, NL80211_ATTR_WIPHY, &index);
if (r < 0)
return r;
r = sd_netlink_message_read_string_strdup(message, NL80211_ATTR_WIPHY_NAME, &name);
if (r < 0)
return r;
w = new(Wiphy, 1);
if (!w)
return -ENOMEM;
*w = (Wiphy) {
.manager = manager,
.index = index,
.name = TAKE_PTR(name),
};
r = hashmap_ensure_put(&manager->wiphy_by_index, NULL, UINT32_TO_PTR(w->index), w);
if (r < 0)
return r;
r = hashmap_ensure_put(&w->manager->wiphy_by_name, &string_hash_ops, w->name, w);
if (r < 0)
return r;
log_wiphy_debug(w, "Saved new wiphy: index=%"PRIu32, w->index);
if (ret)
*ret = w;
TAKE_PTR(w);
return 0;
}
int wiphy_get_by_index(Manager *manager, uint32_t index, Wiphy **ret) {
Wiphy *w;
assert(manager);
w = hashmap_get(manager->wiphy_by_index, UINT32_TO_PTR(index));
if (!w)
return -ENODEV;
if (ret)
*ret = w;
return 0;
}
int wiphy_get_by_name(Manager *manager, const char *name, Wiphy **ret) {
Wiphy *w;
assert(manager);
assert(name);
w = hashmap_get(manager->wiphy_by_name, name);
if (!w)
return -ENODEV;
if (ret)
*ret = w;
return 0;
}
static int link_get_wiphy(Link *link, Wiphy **ret) {
_cleanup_(sd_device_unrefp) sd_device *phy = NULL;
const char *s;
int r;
assert(link);
assert(link->manager);
if (link->iftype != ARPHRD_ETHER)
return -EOPNOTSUPP;
if (!link->dev)
return -ENODEV;
r = sd_device_get_devtype(link->dev, &s);
if (r < 0)
return r;
if (!streq_ptr(s, "wlan"))
return -EOPNOTSUPP;
r = sd_device_new_child(&phy, link->dev, "phy80211");
if (r < 0)
return r;
r = sd_device_get_sysname(phy, &s);
if (r < 0)
return r;
/* TODO:
* Maybe, it is better to cache the found Wiphy object in the Link object.
* To support that, we need to investigate what happens when the _phy_ is renamed. */
return wiphy_get_by_name(link->manager, s, ret);
}
static int rfkill_get_state(sd_device *dev) {
int r;
assert(dev);
/* The previous values may be outdated. Let's clear cache and re-read the values. */
device_clear_sysattr_cache(dev);
r = device_get_sysattr_bool(dev, "soft");
if (r < 0 && r != -ENOENT)
return r;
if (r > 0)
return RFKILL_SOFT;
r = device_get_sysattr_bool(dev, "hard");
if (r < 0 && r != -ENOENT)
return r;
if (r > 0)
return RFKILL_HARD;
return RFKILL_UNBLOCKED;
}
static int wiphy_rfkilled(Wiphy *w) {
int r;
assert(w);
if (!udev_available()) {
if (w->rfkill_state != RFKILL_UNBLOCKED) {
log_wiphy_debug(w, "Running in container, assuming the radio transmitter is unblocked.");
w->rfkill_state = RFKILL_UNBLOCKED; /* To suppress the above log message, cache the state. */
}
return false;
}
if (!w->rfkill) {
if (w->rfkill_state != RFKILL_UNBLOCKED) {
log_wiphy_debug(w, "No rfkill device found, assuming the radio transmitter is unblocked.");
w->rfkill_state = RFKILL_UNBLOCKED; /* To suppress the above log message, cache the state. */
}
return false;
}
r = rfkill_get_state(w->rfkill);
if (r < 0)
return log_wiphy_debug_errno(w, r, "Could not get rfkill state: %m");
if (w->rfkill_state != r)
switch (r) {
case RFKILL_UNBLOCKED:
log_wiphy_debug(w, "The radio transmitter is unblocked.");
break;
case RFKILL_SOFT:
log_wiphy_debug(w, "The radio transmitter is turned off by software.");
break;
case RFKILL_HARD:
log_wiphy_debug(w, "The radio transmitter is forced off by something outside of the driver's control.");
break;
default:
assert_not_reached();
}
w->rfkill_state = r; /* Cache the state to suppress the above log messages. */
return r != RFKILL_UNBLOCKED;
}
int link_rfkilled(Link *link) {
Wiphy *w;
int r;
assert(link);
r = link_get_wiphy(link, &w);
if (r < 0) {
if (ERRNO_IS_NOT_SUPPORTED(r) || ERRNO_IS_DEVICE_ABSENT(r))
return false; /* Typically, non-wifi interface or running in container */
return log_link_debug_errno(link, r, "Could not get phy: %m");
}
return wiphy_rfkilled(w);
}
static int wiphy_update_name(Wiphy *w, sd_netlink_message *message) {
const char *name;
int r;
assert(w);
assert(w->manager);
assert(message);
r = sd_netlink_message_read_string(message, NL80211_ATTR_WIPHY_NAME, &name);
if (r == -ENODATA)
return 0;
if (r < 0)
return r;
if (streq(w->name, name))
return 0;
log_wiphy_debug(w, "Wiphy name change detected, renamed to %s.", name);
hashmap_remove_value(w->manager->wiphy_by_name, w->name, w);
r = free_and_strdup(&w->name, name);
if (r < 0)
return r;
r = hashmap_ensure_put(&w->manager->wiphy_by_name, &string_hash_ops, w->name, w);
if (r < 0)
return r;
return 1; /* updated */
}
static int wiphy_update_device(Wiphy *w) {
_cleanup_(sd_device_unrefp) sd_device *dev = NULL;
int r;
assert(w);
assert(w->name);
if (!udev_available())
return 0;
w->dev = sd_device_unref(w->dev);
r = sd_device_new_from_subsystem_sysname(&dev, "ieee80211", w->name);
if (r < 0)
return r;
if (DEBUG_LOGGING) {
const char *s = NULL;
(void) sd_device_get_syspath(dev, &s);
log_wiphy_debug(w, "Found device: %s", strna(s));
}
w->dev = TAKE_PTR(dev);
return 0;
}
static int wiphy_update_rfkill(Wiphy *w) {
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
sd_device *rfkill;
int r;
assert(w);
if (!udev_available())
return 0;
w->rfkill = sd_device_unref(w->rfkill);
if (!w->dev)
return 0;
r = sd_device_enumerator_new(&e);
if (r < 0)
return r;
r = sd_device_enumerator_allow_uninitialized(e);
if (r < 0)
return r;
r = sd_device_enumerator_add_match_subsystem(e, "rfkill", true);
if (r < 0)
return r;
r = sd_device_enumerator_add_match_parent(e, w->dev);
if (r < 0)
return r;
rfkill = sd_device_enumerator_get_device_first(e);
if (!rfkill)
/* rfkill device may not detected by the kernel yet, and may appear later. */
return -ENODEV;
if (sd_device_enumerator_get_device_next(e))
return -ENXIO; /* multiple devices found */
w->rfkill = sd_device_ref(rfkill);
if (DEBUG_LOGGING) {
const char *s = NULL;
(void) sd_device_get_syspath(rfkill, &s);
log_wiphy_debug(w, "Found rfkill device: %s", strna(s));
}
return 0;
}
static int wiphy_update(Wiphy *w) {
int r;
assert(w);
r = wiphy_update_device(w);
if (r < 0) {
if (ERRNO_IS_DEVICE_ABSENT(r))
log_wiphy_debug_errno(w, r, "Failed to update wiphy device, ignoring: %m");
else
return log_wiphy_warning_errno(w, r, "Failed to update wiphy device: %m");
}
r = wiphy_update_rfkill(w);
if (r < 0) {
if (ERRNO_IS_DEVICE_ABSENT(r))
log_wiphy_debug_errno(w, r, "Failed to update rfkill device, ignoring: %m");
else
return log_wiphy_warning_errno(w, r, "Failed to update rfkill device: %m");
}
return 0;
}
int manager_genl_process_nl80211_wiphy(sd_netlink *genl, sd_netlink_message *message, Manager *manager) {
const char *family;
uint32_t index;
uint8_t cmd;
Wiphy *w = NULL;
int r;
assert(genl);
assert(message);
assert(manager);
if (sd_netlink_message_is_error(message)) {
r = sd_netlink_message_get_errno(message);
if (r < 0)
log_message_warning_errno(message, r, "nl80211: received error message, ignoring");
return 0;
}
r = sd_genl_message_get_family_name(genl, message, &family);
if (r < 0) {
log_debug_errno(r, "nl80211: failed to determine genl family, ignoring: %m");
return 0;
}
if (!streq(family, NL80211_GENL_NAME)) {
log_debug("nl80211: Received message of unexpected genl family '%s', ignoring.", family);
return 0;
}
r = sd_genl_message_get_command(genl, message, &cmd);
if (r < 0) {
log_debug_errno(r, "nl80211: failed to determine genl message command, ignoring: %m");
return 0;
}
r = sd_netlink_message_read_u32(message, NL80211_ATTR_WIPHY, &index);
if (r < 0) {
log_debug_errno(r, "nl80211: received %s(%u) message without valid index, ignoring: %m",
strna(nl80211_cmd_to_string(cmd)), cmd);
return 0;
}
(void) wiphy_get_by_index(manager, index, &w);
switch (cmd) {
case NL80211_CMD_NEW_WIPHY: {
if (!w) {
r = wiphy_new(manager, message, &w);
if (r < 0) {
log_warning_errno(r, "Failed to save new wiphy, ignoring: %m");
return 0;
}
} else {
r = wiphy_update_name(w, message);
if (r < 0) {
log_wiphy_warning_errno(w, r, "Failed to update wiphy name, ignoring: %m");
return 0;
}
if (r == 0)
return 0;
}
r = wiphy_update(w);
if (r < 0)
log_wiphy_warning_errno(w, r, "Failed to update wiphy, ignoring: %m");
break;
}
case NL80211_CMD_DEL_WIPHY:
if (!w) {
log_debug("The kernel removes wiphy we do not know, ignoring: %m");
return 0;
}
log_wiphy_debug(w, "Removed.");
wiphy_free(w);
break;
default:
log_wiphy_debug(w, "nl80211: received %s(%u) message.",
strna(nl80211_cmd_to_string(cmd)), cmd);
}
return 0;
}
int manager_udev_process_wiphy(Manager *m, sd_device *device, sd_device_action_t action) {
const char *name;
Wiphy *w;
int r;
assert(m);
assert(device);
r = sd_device_get_sysname(device, &name);
if (r < 0)
return log_device_debug_errno(device, r, "Failed to get sysname: %m");
r = wiphy_get_by_name(m, name, &w);
if (r < 0) {
/* This error is not critical, as the corresponding genl message may be received later. */
log_device_debug_errno(device, r, "Failed to get Wiphy object, ignoring: %m");
return 0;
}
return device_unref_and_replace(w->dev, action == SD_DEVICE_REMOVE ? NULL : device);
}
int manager_udev_process_rfkill(Manager *m, sd_device *device, sd_device_action_t action) {
_cleanup_free_ char *parent_path = NULL, *parent_name = NULL;
const char *s;
Wiphy *w;
int r;
assert(m);
assert(device);
r = sd_device_get_syspath(device, &s);
if (r < 0)
return log_device_debug_errno(device, r, "Failed to get syspath: %m");
/* Do not use sd_device_get_parent() here, as this might be a 'remove' uevent. */
r = path_extract_directory(s, &parent_path);
if (r < 0)
return log_device_debug_errno(device, r, "Failed to get parent syspath: %m");
r = path_extract_filename(parent_path, &parent_name);
if (r < 0)
return log_device_debug_errno(device, r, "Failed to get parent name: %m");
r = wiphy_get_by_name(m, parent_name, &w);
if (r < 0) {
/* This error is not critical, as the corresponding genl message may be received later. */
log_device_debug_errno(device, r, "Failed to get Wiphy object: %m");
return 0;
}
return device_unref_and_replace(w->rfkill, action == SD_DEVICE_REMOVE ? NULL : device);
}
| 14,935 | 28.812375 | 128 |
c
|
null |
systemd-main/src/network/networkd-wiphy.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include "sd-device.h"
#include "macro.h"
typedef struct Link Link;
typedef struct Manager Manager;
/* The following values are different from the ones defined in linux/rfkill.h. */
typedef enum RFKillState {
RFKILL_UNKNOWN,
RFKILL_UNBLOCKED,
RFKILL_SOFT,
RFKILL_HARD,
_RFKILL_STATE_MAX,
_RFKILL_STATE_INVALID = -EINVAL,
} RFKillState;
typedef struct Wiphy {
Manager *manager;
uint32_t index;
char *name;
sd_device *dev;
sd_device *rfkill;
RFKillState rfkill_state;
} Wiphy;
Wiphy *wiphy_free(Wiphy *w);
DEFINE_TRIVIAL_CLEANUP_FUNC(Wiphy*, wiphy_free);
int wiphy_get_by_index(Manager *manager, uint32_t index, Wiphy **ret);
int wiphy_get_by_name(Manager *manager, const char *name, Wiphy **ret);
int link_rfkilled(Link *link);
int manager_genl_process_nl80211_wiphy(sd_netlink *genl, sd_netlink_message *message, Manager *manager);
int manager_udev_process_wiphy(Manager *m, sd_device *device, sd_device_action_t action);
int manager_udev_process_rfkill(Manager *m, sd_device *device, sd_device_action_t action);
#define log_wiphy_full_errno_zerook(w, level, error, ...) \
({ \
const Wiphy *_w = (w); \
log_interface_full_errno_zerook(_w ? _w->name : NULL, level, error, __VA_ARGS__); \
})
#define log_wiphy_full_errno(w, level, error, ...) \
({ \
int _error = (error); \
ASSERT_NON_ZERO(_error); \
log_wiphy_full_errno_zerook(w, level, _error, __VA_ARGS__); \
})
#define log_wiphy_full(w, level, ...) (void) log_wiphy_full_errno_zerook(w, level, 0, __VA_ARGS__)
#define log_wiphy_debug(w, ...) log_wiphy_full(w, LOG_DEBUG, __VA_ARGS__)
#define log_wiphy_info(w, ...) log_wiphy_full(w, LOG_INFO, __VA_ARGS__)
#define log_wiphy_notice(w, ...) log_wiphy_full(w, LOG_NOTICE, __VA_ARGS__)
#define log_wiphy_warning(w, ...) log_wiphy_full(w, LOG_WARNING, __VA_ARGS__)
#define log_wiphy_error(w, ...) log_wiphy_full(w, LOG_ERR, __VA_ARGS__)
#define log_wiphy_debug_errno(w, error, ...) log_wiphy_full_errno(w, LOG_DEBUG, error, __VA_ARGS__)
#define log_wiphy_info_errno(w, error, ...) log_wiphy_full_errno(w, LOG_INFO, error, __VA_ARGS__)
#define log_wiphy_notice_errno(w, error, ...) log_wiphy_full_errno(w, LOG_NOTICE, error, __VA_ARGS__)
#define log_wiphy_warning_errno(w, error, ...) log_wiphy_full_errno(w, LOG_WARNING, error, __VA_ARGS__)
#define log_wiphy_error_errno(w, error, ...) log_wiphy_full_errno(w, LOG_ERR, error, __VA_ARGS__)
| 2,917 | 39.527778 | 104 |
h
|
null |
systemd-main/src/network/networkd.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <netinet/in.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "sd-daemon.h"
#include "sd-event.h"
#include "bus-log-control-api.h"
#include "capability-util.h"
#include "daemon-util.h"
#include "firewall-util.h"
#include "main-func.h"
#include "mkdir-label.h"
#include "networkd-conf.h"
#include "networkd-manager-bus.h"
#include "networkd-manager.h"
#include "service-util.h"
#include "signal-util.h"
#include "user-util.h"
static int run(int argc, char *argv[]) {
_cleanup_(manager_freep) Manager *m = NULL;
_unused_ _cleanup_(notify_on_cleanup) const char *notify_message = NULL;
int r;
log_setup();
r = service_parse_argv("systemd-networkd.service",
"Manage and configure network devices, create virtual network devices",
BUS_IMPLEMENTATIONS(&manager_object, &log_control_object),
argc, argv);
if (r <= 0)
return r;
umask(0022);
if (argc != 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "This program takes no arguments.");
/* Drop privileges, but only if we have been started as root. If we are not running as root we assume all
* privileges are already dropped and we can't create our runtime directory. */
if (geteuid() == 0) {
const char *user = "systemd-network";
uid_t uid;
gid_t gid;
r = get_user_creds(&user, &uid, &gid, NULL, NULL, 0);
if (r < 0)
return log_error_errno(r, "Cannot resolve user name %s: %m", user);
/* Create runtime directory. This is not necessary when networkd is
* started with "RuntimeDirectory=systemd/netif", or after
* systemd-tmpfiles-setup.service. */
r = mkdir_safe_label("/run/systemd/netif", 0755, uid, gid, MKDIR_WARN_MODE);
if (r < 0)
log_warning_errno(r, "Could not create runtime directory: %m");
r = drop_privileges(uid, gid,
(1ULL << CAP_NET_ADMIN) |
(1ULL << CAP_NET_BIND_SERVICE) |
(1ULL << CAP_NET_BROADCAST) |
(1ULL << CAP_NET_RAW));
if (r < 0)
return log_error_errno(r, "Failed to drop privileges: %m");
}
/* Always create the directories people can create inotify watches in.
* It is necessary to create the following subdirectories after drop_privileges()
* to support old kernels not supporting AmbientCapabilities=. */
r = mkdir_safe_label("/run/systemd/netif/links", 0755, UID_INVALID, GID_INVALID, MKDIR_WARN_MODE);
if (r < 0)
log_warning_errno(r, "Could not create runtime directory 'links': %m");
r = mkdir_safe_label("/run/systemd/netif/leases", 0755, UID_INVALID, GID_INVALID, MKDIR_WARN_MODE);
if (r < 0)
log_warning_errno(r, "Could not create runtime directory 'leases': %m");
r = mkdir_safe_label("/run/systemd/netif/lldp", 0755, UID_INVALID, GID_INVALID, MKDIR_WARN_MODE);
if (r < 0)
log_warning_errno(r, "Could not create runtime directory 'lldp': %m");
r = manager_new(&m, /* test_mode = */ false);
if (r < 0)
return log_error_errno(r, "Could not create manager: %m");
r = manager_setup(m);
if (r < 0)
return log_error_errno(r, "Could not setup manager: %m");
r = manager_parse_config_file(m);
if (r < 0)
log_warning_errno(r, "Failed to parse configuration file: %m");
r = manager_load_config(m);
if (r < 0)
return log_error_errno(r, "Could not load configuration files: %m");
r = manager_enumerate(m);
if (r < 0)
return r;
r = manager_start(m);
if (r < 0)
return log_error_errno(r, "Could not start manager: %m");
log_info("Enumeration completed");
notify_message = notify_start(NOTIFY_READY, NOTIFY_STOPPING);
r = sd_event_loop(m->event);
if (r < 0)
return log_error_errno(r, "Event loop failed: %m");
return 0;
}
DEFINE_MAIN_FUNCTION(run);
| 4,510 | 36.591667 | 113 |
c
|
null |
systemd-main/src/network/test-network-tables.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "bond.h"
#include "dhcp6-internal.h"
#include "dhcp6-protocol.h"
#include "ethtool-util.h"
#include "ipvlan.h"
#include "lldp-rx-internal.h"
#include "macvlan.h"
#include "ndisc-internal.h"
#include "networkd-link.h"
#include "networkd-network.h"
#include "networkd-util.h"
#include "test-tables.h"
#include "tunnel.h"
int main(int argc, char **argv) {
test_table(bond_ad_select, NETDEV_BOND_AD_SELECT);
test_table(bond_arp_all_targets, NETDEV_BOND_ARP_ALL_TARGETS);
test_table(bond_arp_validate, NETDEV_BOND_ARP_VALIDATE);
test_table(bond_fail_over_mac, NETDEV_BOND_FAIL_OVER_MAC);
test_table(bond_lacp_rate, NETDEV_BOND_LACP_RATE);
test_table(bond_mode, NETDEV_BOND_MODE);
test_table(bond_primary_reselect, NETDEV_BOND_PRIMARY_RESELECT);
test_table(bond_xmit_hash_policy, NETDEV_BOND_XMIT_HASH_POLICY);
test_table(dhcp6_message_status, DHCP6_STATUS);
test_table_sparse(dhcp6_message_type, DHCP6_MESSAGE_TYPE); /* enum starts from 1 */
test_table(dhcp_use_domains, DHCP_USE_DOMAINS);
test_table(duplex, DUP);
test_table(ip6tnl_mode, NETDEV_IP6_TNL_MODE);
test_table(ipv6_privacy_extensions, IPV6_PRIVACY_EXTENSIONS);
test_table(ipvlan_flags, NETDEV_IPVLAN_FLAGS);
test_table(link_operstate, LINK_OPERSTATE);
/* test_table(link_state, LINK_STATE); — not a reversible mapping */
test_table(lldp_mode, LLDP_MODE);
test_table(netdev_kind, NETDEV_KIND);
test_table(radv_prefix_delegation, RADV_PREFIX_DELEGATION);
test_table(lldp_rx_event, SD_LLDP_RX_EVENT);
test_table(ndisc_event, SD_NDISC_EVENT);
test_table(dhcp_lease_server_type, SD_DHCP_LEASE_SERVER_TYPE);
test_table_sparse(ipvlan_mode, NETDEV_IPVLAN_MODE);
test_table_sparse(macvlan_mode, NETDEV_MACVLAN_MODE);
test_table_sparse(address_family, ADDRESS_FAMILY);
assert_cc(sizeof(sd_lldp_rx_event_t) == sizeof(int64_t));
assert_cc(sizeof(sd_ndisc_event_t) == sizeof(int64_t));
assert_cc(sizeof(sd_dhcp_lease_server_type_t) == sizeof(int64_t));
return EXIT_SUCCESS;
}
| 2,224 | 41.788462 | 91 |
c
|
null |
systemd-main/src/network/test-networkd-address.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "networkd-address.h"
#include "tests.h"
#include "time-util.h"
static void test_FORMAT_LIFETIME_one(usec_t lifetime, const char *expected) {
const char *t = FORMAT_LIFETIME(lifetime);
log_debug(USEC_FMT " → \"%s\" (expected \"%s\")", lifetime, t, expected);
assert_se(streq(t, expected));
}
TEST(FORMAT_LIFETIME) {
usec_t now_usec;
now_usec = now(CLOCK_BOOTTIME);
test_FORMAT_LIFETIME_one(now_usec, "for 0");
test_FORMAT_LIFETIME_one(usec_add(now_usec, 2 * USEC_PER_SEC - 1), "for 1s");
test_FORMAT_LIFETIME_one(usec_add(now_usec, 3 * USEC_PER_WEEK + USEC_PER_SEC - 1), "for 3w");
test_FORMAT_LIFETIME_one(USEC_INFINITY, "forever");
}
DEFINE_TEST_MAIN(LOG_DEBUG);
| 801 | 29.846154 | 101 |
c
|
null |
systemd-main/src/network/test-networkd-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "networkd-util.h"
#include "tests.h"
TEST(network_config_state_to_string_alloc) {
for (unsigned i = 1; i <= NETWORK_CONFIG_STATE_REMOVING; i <<= 1) {
_cleanup_free_ char *x;
assert_se(network_config_state_to_string_alloc(i, &x) == 0);
log_debug("%u → %s", i, x);
}
_cleanup_free_ char *x;
assert_se(network_config_state_to_string_alloc(~0u, &x) == 0);
log_debug("%u → %s", ~0u, x);
};
DEFINE_TEST_MAIN(LOG_DEBUG);
| 565 | 27.3 | 76 |
c
|
null |
systemd-main/src/network/generator/main.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <getopt.h>
#include "build.h"
#include "fd-util.h"
#include "fs-util.h"
#include "generator.h"
#include "macro.h"
#include "main-func.h"
#include "mkdir.h"
#include "network-generator.h"
#include "path-util.h"
#include "proc-cmdline.h"
#define NETWORKD_UNIT_DIRECTORY "/run/systemd/network"
static const char *arg_root = NULL;
static int network_save(Network *network, const char *dest_dir) {
_cleanup_(unlink_and_freep) char *temp_path = NULL;
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *p = NULL;
int r;
assert(network);
r = generator_open_unit_file_full(dest_dir, NULL, NULL, &f, &temp_path);
if (r < 0)
return r;
network_dump(network, f);
if (asprintf(&p, "%s/%s-%s.network",
dest_dir,
isempty(network->ifname) ? "91" : "90",
isempty(network->ifname) ? "default" : network->ifname) < 0)
return log_oom();
r = conservative_rename(temp_path, p);
if (r < 0)
return r;
temp_path = mfree(temp_path);
return 0;
}
static int netdev_save(NetDev *netdev, const char *dest_dir) {
_cleanup_(unlink_and_freep) char *temp_path = NULL;
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *p = NULL;
int r;
assert(netdev);
r = generator_open_unit_file_full(dest_dir, NULL, NULL, &f, &temp_path);
if (r < 0)
return r;
netdev_dump(netdev, f);
if (asprintf(&p, "%s/90-%s.netdev", dest_dir, netdev->ifname) < 0)
return log_oom();
r = conservative_rename(temp_path, p);
if (r < 0)
return r;
temp_path = mfree(temp_path);
return 0;
}
static int link_save(Link *link, const char *dest_dir) {
_cleanup_(unlink_and_freep) char *temp_path = NULL;
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *p = NULL;
int r;
assert(link);
r = generator_open_unit_file_full(dest_dir, NULL, NULL, &f, &temp_path);
if (r < 0)
return r;
link_dump(link, f);
if (asprintf(&p, "%s/%s-%s.link",
dest_dir,
!isempty(link->ifname) ? "90" : !hw_addr_is_null(&link->mac) ? "91" : "92",
link->filename) < 0)
return log_oom();
r = conservative_rename(temp_path, p);
if (r < 0)
return r;
temp_path = mfree(temp_path);
return 0;
}
static int context_save(Context *context) {
Network *network;
NetDev *netdev;
Link *link;
int k, r;
const char *p;
p = prefix_roota(arg_root, NETWORKD_UNIT_DIRECTORY);
r = mkdir_p(p, 0755);
if (r < 0)
return log_error_errno(r, "Failed to create directory " NETWORKD_UNIT_DIRECTORY ": %m");
HASHMAP_FOREACH(network, context->networks_by_name) {
k = network_save(network, p);
if (k < 0 && r >= 0)
r = k;
}
HASHMAP_FOREACH(netdev, context->netdevs_by_name) {
k = netdev_save(netdev, p);
if (k < 0 && r >= 0)
r = k;
}
HASHMAP_FOREACH(link, context->links_by_filename) {
k = link_save(link, p);
if (k < 0 && r >= 0)
r = k;
}
return r;
}
static int help(void) {
printf("%s [OPTIONS...] [-- KERNEL_CMDLINE]\n"
" -h --help Show this help\n"
" --version Show package version\n"
" --root=PATH Operate on an alternate filesystem root\n",
program_invocation_short_name);
return 0;
}
static int parse_argv(int argc, char *argv[]) {
enum {
ARG_VERSION = 0x100,
ARG_ROOT,
};
static const struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, ARG_VERSION },
{ "root", required_argument, NULL, ARG_ROOT },
{},
};
int c;
assert(argc >= 0);
assert(argv);
while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
switch (c) {
case 'h':
return help();
case ARG_VERSION:
return version();
case ARG_ROOT:
arg_root = optarg;
break;
case '?':
return -EINVAL;
default:
assert_not_reached();
}
return 1;
}
static int run(int argc, char *argv[]) {
_cleanup_(context_clear) Context context = {};
int r;
log_setup();
umask(0022);
r = parse_argv(argc, argv);
if (r <= 0)
return r;
if (optind >= argc) {
r = proc_cmdline_parse(parse_cmdline_item, &context, 0);
if (r < 0)
return log_warning_errno(r, "Failed to parse kernel command line: %m");
} else {
for (int i = optind; i < argc; i++) {
_cleanup_free_ char *word = NULL;
char *value;
word = strdup(argv[i]);
if (!word)
return log_oom();
value = strchr(word, '=');
if (value)
*(value++) = 0;
r = parse_cmdline_item(word, value, &context);
if (r < 0)
return log_warning_errno(r, "Failed to parse command line \"%s%s%s\": %m",
word, value ? "=" : "", strempty(value));
}
}
r = context_merge_networks(&context);
if (r < 0)
return log_warning_errno(r, "Failed to merge multiple command line options: %m");
return context_save(&context);
}
DEFINE_MAIN_FUNCTION(run);
| 6,550 | 27.606987 | 106 |
c
|
null |
systemd-main/src/network/generator/network-generator.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdio.h>
#include "ether-addr-util.h"
#include "hashmap.h"
#include "in-addr-util.h"
#include "list.h"
typedef enum DHCPType {
DHCP_TYPE_NONE,
DHCP_TYPE_OFF,
DHCP_TYPE_ON,
DHCP_TYPE_ANY,
DHCP_TYPE_DHCP4,
DHCP_TYPE_DHCP6,
DHCP_TYPE_AUTO6,
DHCP_TYPE_EITHER6,
DHCP_TYPE_IBFT,
DHCP_TYPE_LINK6,
_DHCP_TYPE_MAX,
_DHCP_TYPE_INVALID = -EINVAL,
} DHCPType;
typedef struct Address Address;
typedef struct Link Link;
typedef struct NetDev NetDev;
typedef struct Network Network;
typedef struct Route Route;
typedef struct Context Context;
struct Address {
Network *network;
union in_addr_union address, peer;
unsigned char prefixlen;
int family;
LIST_FIELDS(Address, addresses);
};
struct Route {
Network *network;
union in_addr_union dest, gateway;
unsigned char prefixlen;
int family;
LIST_FIELDS(Route, routes);
};
struct Network {
/* [Match] */
char *ifname;
/* [Link] */
struct ether_addr mac;
uint32_t mtu;
/* [Network] */
DHCPType dhcp_type;
char **dns;
char *vlan;
char *bridge;
char *bond;
/* [DHCP] */
char *hostname;
int dhcp_use_dns;
LIST_HEAD(Address, addresses);
LIST_HEAD(Route, routes);
};
struct NetDev {
/* [NetDev] */
char *ifname;
char *kind;
uint32_t mtu;
};
struct Link {
char *filename;
/* [Match] */
struct hw_addr_data mac;
/* [Link] */
char *ifname;
char **policies;
char **alt_policies;
};
typedef struct Context {
Hashmap *networks_by_name;
Hashmap *netdevs_by_name;
Hashmap *links_by_filename;
} Context;
int parse_cmdline_item(const char *key, const char *value, void *data);
int context_merge_networks(Context *context);
void context_clear(Context *context);
Network *network_get(Context *context, const char *ifname);
void network_dump(Network *network, FILE *f);
int network_format(Network *network, char **ret);
NetDev *netdev_get(Context *context, const char *ifname);
void netdev_dump(NetDev *netdev, FILE *f);
int netdev_format(NetDev *netdev, char **ret);
Link *link_get(Context *context, const char *filename);
void link_dump(Link *link, FILE *f);
int link_format(Link *link, char **ret);
| 2,529 | 20.810345 | 71 |
h
|
null |
systemd-main/src/network/generator/test-network-generator.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "macro.h"
#include "network-generator.h"
#include "string-util.h"
static void test_network_one(const char *ifname, const char *key, const char *value, const char *expected) {
_cleanup_(context_clear) Context context = {};
_cleanup_free_ char *output = NULL;
Network *network;
printf("# %s=%s\n", key, value);
assert_se(parse_cmdline_item(key, value, &context) >= 0);
assert_se(network = network_get(&context, ifname));
assert_se(network_format(network, &output) >= 0);
puts(output);
assert_se(streq(output, expected));
}
static void test_network_two(const char *ifname,
const char *key1, const char *value1,
const char *key2, const char *value2,
const char *expected) {
_cleanup_(context_clear) Context context = {};
_cleanup_free_ char *output = NULL;
Network *network;
printf("# %s=%s\n", key1, value1);
printf("# %s=%s\n", key2, value2);
assert_se(parse_cmdline_item(key1, value1, &context) >= 0);
assert_se(parse_cmdline_item(key2, value2, &context) >= 0);
assert_se(context_merge_networks(&context) >= 0);
assert_se(network = network_get(&context, ifname));
assert_se(network_format(network, &output) >= 0);
puts(output);
assert_se(streq(output, expected));
}
static void test_netdev_one(const char *ifname, const char *key, const char *value, const char *expected) {
_cleanup_(context_clear) Context context = {};
_cleanup_free_ char *output = NULL;
NetDev *netdev;
printf("# %s=%s\n", key, value);
assert_se(parse_cmdline_item(key, value, &context) >= 0);
assert_se(netdev = netdev_get(&context, ifname));
assert_se(netdev_format(netdev, &output) >= 0);
puts(output);
assert_se(streq(output, expected));
}
static void test_link_one(const char *filename, const char *key, const char *value, const char *expected) {
_cleanup_(context_clear) Context context = {};
_cleanup_free_ char *output = NULL;
Link *link;
printf("# %s=%s\n", key, value);
assert_se(parse_cmdline_item(key, value, &context) >= 0);
assert_se(link = link_get(&context, filename));
assert_se(link_format(link, &output) >= 0);
puts(output);
assert_se(streq(output, expected));
}
int main(int argc, char *argv[]) {
test_network_one("", "ip", "dhcp6",
"[Match]\n"
"Name=*\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=ipv6\n"
"\n[DHCP]\n"
);
test_network_one("eth0", "ip", "eth0:dhcp",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=ipv4\n"
"\n[DHCP]\n"
);
test_network_one("eth0", "ip", "eth0:dhcp:1530",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"MTUBytes=1530\n"
"\n[Network]\n"
"DHCP=ipv4\n"
"\n[DHCP]\n"
);
test_network_one("eth0", "ip", "eth0:dhcp:1530:00:11:22:33:44:55",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"MACAddress=00:11:22:33:44:55\n"
"MTUBytes=1530\n"
"\n[Network]\n"
"DHCP=ipv4\n"
"\n[DHCP]\n"
);
test_network_one("eth0", "ip", "192.168.0.10::192.168.0.1:255.255.255.0:hogehoge:eth0:on",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_one("eth0", "ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_one("eth0", "ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on:1530",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"MTUBytes=1530\n"
"\n[Network]\n"
"DHCP=yes\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_one("eth0", "ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on:1530:00:11:22:33:44:55",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"MACAddress=00:11:22:33:44:55\n"
"MTUBytes=1530\n"
"\n[Network]\n"
"DHCP=yes\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_one("eth0", "ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on:10.10.10.10",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"DNS=10.10.10.10\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_one("eth0", "ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on:10.10.10.10:10.10.10.11",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"DNS=10.10.10.10\n"
"DNS=10.10.10.11\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_one("eth0", "ip", "[2001:1234:56:8f63::10]::[2001:1234:56:8f63::1]:64:hogehoge:eth0:on",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=2001:1234:56:8f63::10/64\n"
"\n[Route]\n"
"Gateway=2001:1234:56:8f63::1\n"
);
test_network_one("eth0", "ip", "[2001:1234:56:8f63::10]:[2001:1234:56:8f63::2]:[2001:1234:56:8f63::1]:64:hogehoge:eth0:on",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=2001:1234:56:8f63::10/64\n"
"Peer=2001:1234:56:8f63::2\n"
"\n[Route]\n"
"Gateway=2001:1234:56:8f63::1\n"
);
test_network_one("", "rd.route", "10.1.2.3/16:10.0.2.3",
"[Match]\n"
"Name=*\n"
"\n[Link]\n"
"\n[Network]\n"
"\n[DHCP]\n"
"\n[Route]\n"
"Destination=10.1.2.3/16\n"
"Gateway=10.0.2.3\n"
);
test_network_one("eth0", "rd.route", "10.1.2.3/16:10.0.2.3:eth0",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"\n[DHCP]\n"
"\n[Route]\n"
"Destination=10.1.2.3/16\n"
"Gateway=10.0.2.3\n"
);
test_network_one("", "nameserver", "10.1.2.3",
"[Match]\n"
"Name=*\n"
"\n[Link]\n"
"\n[Network]\n"
"DNS=10.1.2.3\n"
"\n[DHCP]\n"
);
test_network_one("", "rd.peerdns", "0",
"[Match]\n"
"Name=*\n"
"\n[Link]\n"
"\n[Network]\n"
"\n[DHCP]\n"
"UseDNS=no\n"
);
test_network_one("", "rd.peerdns", "1",
"[Match]\n"
"Name=*\n"
"\n[Link]\n"
"\n[Network]\n"
"\n[DHCP]\n"
"UseDNS=yes\n"
);
test_network_one("eth0", "vlan", "vlan99:eth0",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"VLAN=vlan99\n"
"\n[DHCP]\n"
);
test_network_one("eth0", "bridge", "bridge99:eth0,eth1",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"Bridge=bridge99\n"
"\n[DHCP]\n"
);
test_network_one("eth1", "bridge", "bridge99:eth0,eth1",
"[Match]\n"
"Name=eth1\n"
"\n[Link]\n"
"\n[Network]\n"
"Bridge=bridge99\n"
"\n[DHCP]\n"
);
test_network_one("eth0", "bond", "bond99:eth0,eth1",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"Bond=bond99\n"
"\n[DHCP]\n"
);
test_network_one("eth1", "bond", "bond99:eth0,eth1::1530",
"[Match]\n"
"Name=eth1\n"
"\n[Link]\n"
"\n[Network]\n"
"Bond=bond99\n"
"\n[DHCP]\n"
);
test_netdev_one("bond99", "bond", "bond99:eth0,eth1::1530",
"[NetDev]\n"
"Kind=bond\n"
"Name=bond99\n"
"MTUBytes=1530\n"
);
test_link_one("hogehoge", "ifname", "hogehoge:00:11:22:33:44:55",
"[Match]\n"
"MACAddress=00:11:22:33:44:55\n"
"\n[Link]\n"
"Name=hogehoge\n"
);
test_link_one("001122334455", "net.ifname-policy", "keep,kernel,database,onboard,slot,path,mac,00:11:22:33:44:55",
"[Match]\n"
"MACAddress=00:11:22:33:44:55\n"
"\n[Link]\n"
"NamePolicy=keep kernel database onboard slot path mac\n"
"AlternativeNamesPolicy=database onboard slot path mac\n"
);
test_link_one("default", "net.ifname-policy", "keep,kernel,database,onboard,slot,path,mac",
"[Match]\n"
"OriginalName=*\n"
"\n[Link]\n"
"NamePolicy=keep kernel database onboard slot path mac\n"
"AlternativeNamesPolicy=database onboard slot path mac\n"
);
test_network_two("eth0",
"ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on:10.10.10.10:10.10.10.11",
"rd.route", "10.1.2.3/16:10.0.2.3",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"DNS=10.10.10.10\n"
"DNS=10.10.10.11\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Destination=10.1.2.3/16\n"
"Gateway=10.0.2.3\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_two("eth0",
"ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on",
"nameserver", "10.1.2.3",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"DNS=10.1.2.3\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_two("eth0",
"ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on:10.10.10.10:10.10.10.11",
"nameserver", "10.1.2.3",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"DNS=10.10.10.10\n"
"DNS=10.10.10.11\n"
"DNS=10.1.2.3\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_two("eth0",
"ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on:10.10.10.10:10.10.10.11",
"rd.peerdns", "1",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"DNS=10.10.10.10\n"
"DNS=10.10.10.11\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"UseDNS=yes\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
test_network_two("eth0",
"ip", "192.168.0.10:192.168.0.2:192.168.0.1:255.255.255.0:hogehoge:eth0:on:10.10.10.10:10.10.10.11",
"bridge", "bridge99:eth0,eth1",
"[Match]\n"
"Name=eth0\n"
"\n[Link]\n"
"\n[Network]\n"
"DHCP=yes\n"
"DNS=10.10.10.10\n"
"DNS=10.10.10.11\n"
"Bridge=bridge99\n"
"\n[DHCP]\n"
"Hostname=hogehoge\n"
"\n[Address]\n"
"Address=192.168.0.10/24\n"
"Peer=192.168.0.2\n"
"\n[Route]\n"
"Gateway=192.168.0.1\n"
);
return 0;
}
| 18,598 | 39.876923 | 133 |
c
|
null |
systemd-main/src/network/netdev/bareudp.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <netinet/in.h>
#include <linux/if_arp.h>
#include "bareudp.h"
#include "netlink-util.h"
#include "networkd-manager.h"
#include "string-table.h"
static const char* const bare_udp_protocol_table[_BARE_UDP_PROTOCOL_MAX] = {
[BARE_UDP_PROTOCOL_IPV4] = "ipv4",
[BARE_UDP_PROTOCOL_IPV6] = "ipv6",
[BARE_UDP_PROTOCOL_MPLS_UC] = "mpls-uc",
[BARE_UDP_PROTOCOL_MPLS_MC] = "mpls-mc",
};
DEFINE_STRING_TABLE_LOOKUP(bare_udp_protocol, BareUDPProtocol);
DEFINE_CONFIG_PARSE_ENUM(config_parse_bare_udp_iftype, bare_udp_protocol, BareUDPProtocol,
"Failed to parse EtherType=");
static int netdev_bare_udp_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
BareUDP *u;
int r;
assert(netdev);
assert(m);
u = BAREUDP(netdev);
assert(u);
r = sd_netlink_message_append_u16(m, IFLA_BAREUDP_ETHERTYPE, htobe16(u->iftype));
if (r < 0)
return r;
r = sd_netlink_message_append_u16(m, IFLA_BAREUDP_PORT, htobe16(u->dest_port));
if (r < 0)
return r;
return 0;
}
static int netdev_bare_udp_verify(NetDev *netdev, const char *filename) {
BareUDP *u;
assert(netdev);
assert(filename);
u = BAREUDP(netdev);
assert(u);
if (u->dest_port == 0)
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"%s: BareUDP DesinationPort= is not set. Ignoring.", filename);
if (u->iftype == _BARE_UDP_PROTOCOL_INVALID)
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"%s: BareUDP EtherType= is not set. Ignoring.", filename);
return 0;
}
static void bare_udp_init(NetDev *netdev) {
BareUDP *u;
assert(netdev);
u = BAREUDP(netdev);
assert(u);
u->iftype = _BARE_UDP_PROTOCOL_INVALID;
}
const NetDevVTable bare_udp_vtable = {
.object_size = sizeof(BareUDP),
.sections = NETDEV_COMMON_SECTIONS "BareUDP\0",
.init = bare_udp_init,
.config_verify = netdev_bare_udp_verify,
.fill_message_create = netdev_bare_udp_fill_message_create,
.create_type = NETDEV_CREATE_INDEPENDENT,
.iftype = ARPHRD_NONE,
};
| 2,484 | 27.563218 | 111 |
c
|
null |
systemd-main/src/network/netdev/bareudp.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#pragma once
typedef struct BareUDP BareUDP;
#include <linux/if_ether.h>
#include "conf-parser.h"
#include "netdev.h"
typedef enum BareUDPProtocol {
BARE_UDP_PROTOCOL_IPV4 = ETH_P_IP,
BARE_UDP_PROTOCOL_IPV6 = ETH_P_IPV6,
BARE_UDP_PROTOCOL_MPLS_UC = ETH_P_MPLS_UC,
BARE_UDP_PROTOCOL_MPLS_MC = ETH_P_MPLS_MC,
_BARE_UDP_PROTOCOL_MAX,
_BARE_UDP_PROTOCOL_INVALID = -EINVAL,
} BareUDPProtocol;
struct BareUDP {
NetDev meta;
BareUDPProtocol iftype;
uint16_t dest_port;
};
DEFINE_NETDEV_CAST(BAREUDP, BareUDP);
extern const NetDevVTable bare_udp_vtable;
const char *bare_udp_protocol_to_string(BareUDPProtocol d) _const_;
BareUDPProtocol bare_udp_protocol_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_bare_udp_iftype);
| 907 | 24.942857 | 68 |
h
|
null |
systemd-main/src/network/netdev/batadv.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <linux/batman_adv.h>
#include "conf-parser.h"
#include "netdev.h"
#define BATADV_GENL_NAME "batadv"
typedef enum BatadvGatewayModes {
BATADV_GATEWAY_MODE_OFF = BATADV_GW_MODE_OFF,
BATADV_GATEWAY_MODE_CLIENT = BATADV_GW_MODE_CLIENT,
BATADV_GATEWAY_MODE_SERVER = BATADV_GW_MODE_SERVER,
_BATADV_GATEWAY_MODE_MAX,
_BATADV_GATEWAY_MODE_INVALID = -EINVAL,
} BatadvGatewayModes;
typedef enum BatadvRoutingAlgorithm {
BATADV_ROUTING_ALGORITHM_BATMAN_V,
BATADV_ROUTING_ALGORITHM_BATMAN_IV,
_BATADV_ROUTING_ALGORITHM_MAX,
_BATADV_ROUTING_ALGORITHM_INVALID = -EINVAL,
} BatadvRoutingAlgorithm;
typedef struct Batadv {
NetDev meta;
BatadvGatewayModes gateway_mode;
uint32_t gateway_bandwidth_down;
uint32_t gateway_bandwidth_up;
uint8_t hop_penalty;
BatadvRoutingAlgorithm routing_algorithm;
usec_t originator_interval;
bool aggregation;
bool bridge_loop_avoidance;
bool distributed_arp_table;
bool fragmentation;
} BatmanAdvanced;
DEFINE_NETDEV_CAST(BATADV, BatmanAdvanced);
extern const NetDevVTable batadv_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_batadv_gateway_mode);
CONFIG_PARSER_PROTOTYPE(config_parse_batadv_routing_algorithm);
CONFIG_PARSER_PROTOTYPE(config_parse_badadv_bandwidth);
| 1,425 | 28.708333 | 63 |
h
|
null |
systemd-main/src/network/netdev/bond.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <netinet/in.h>
#include <linux/if_bonding.h>
#include "bond-util.h"
#include "macro.h"
#include "netdev.h"
#include "ordered-set.h"
typedef struct Bond {
NetDev meta;
BondMode mode;
BondXmitHashPolicy xmit_hash_policy;
BondLacpRate lacp_rate;
BondAdSelect ad_select;
BondFailOverMac fail_over_mac;
BondArpValidate arp_validate;
BondArpAllTargets arp_all_targets;
BondPrimaryReselect primary_reselect;
int tlb_dynamic_lb;
bool all_slaves_active;
unsigned resend_igmp;
unsigned packets_per_slave;
unsigned num_grat_arp;
unsigned min_links;
uint16_t ad_actor_sys_prio;
uint16_t ad_user_port_key;
struct ether_addr ad_actor_system;
usec_t miimon;
usec_t updelay;
usec_t downdelay;
usec_t arp_interval;
usec_t lp_interval;
OrderedSet *arp_ip_targets;
} Bond;
DEFINE_NETDEV_CAST(BOND, Bond);
extern const NetDevVTable bond_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_bond_mode);
CONFIG_PARSER_PROTOTYPE(config_parse_bond_xmit_hash_policy);
CONFIG_PARSER_PROTOTYPE(config_parse_bond_lacp_rate);
CONFIG_PARSER_PROTOTYPE(config_parse_bond_ad_select);
CONFIG_PARSER_PROTOTYPE(config_parse_bond_fail_over_mac);
CONFIG_PARSER_PROTOTYPE(config_parse_bond_arp_validate);
CONFIG_PARSER_PROTOTYPE(config_parse_bond_arp_all_targets);
CONFIG_PARSER_PROTOTYPE(config_parse_bond_primary_reselect);
CONFIG_PARSER_PROTOTYPE(config_parse_arp_ip_target_address);
CONFIG_PARSER_PROTOTYPE(config_parse_ad_actor_sys_prio);
CONFIG_PARSER_PROTOTYPE(config_parse_ad_user_port_key);
CONFIG_PARSER_PROTOTYPE(config_parse_ad_actor_system);
| 1,783 | 28.245902 | 60 |
h
|
null |
systemd-main/src/network/netdev/bridge.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
#include <netinet/in.h>
#include <linux/if_arp.h>
#include <linux/if_bridge.h>
#include "bridge.h"
#include "netlink-util.h"
#include "networkd-manager.h"
#include "string-table.h"
#include "vlan-util.h"
assert_cc((int) MULTICAST_ROUTER_NONE == (int) MDB_RTR_TYPE_DISABLED);
assert_cc((int) MULTICAST_ROUTER_TEMPORARY_QUERY == (int) MDB_RTR_TYPE_TEMP_QUERY);
assert_cc((int) MULTICAST_ROUTER_PERMANENT == (int) MDB_RTR_TYPE_PERM);
assert_cc((int) MULTICAST_ROUTER_TEMPORARY == (int) MDB_RTR_TYPE_TEMP);
static const char* const multicast_router_table[_MULTICAST_ROUTER_MAX] = {
[MULTICAST_ROUTER_NONE] = "no",
[MULTICAST_ROUTER_TEMPORARY_QUERY] = "query",
[MULTICAST_ROUTER_PERMANENT] = "permanent",
[MULTICAST_ROUTER_TEMPORARY] = "temporary",
};
DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(multicast_router, MulticastRouter, _MULTICAST_ROUTER_INVALID);
DEFINE_CONFIG_PARSE_ENUM(config_parse_multicast_router, multicast_router, MulticastRouter,
"Failed to parse bridge multicast router setting");
/* callback for bridge netdev's parameter set */
static int netdev_bridge_set_handler(sd_netlink *rtnl, sd_netlink_message *m, NetDev *netdev) {
int r;
assert(netdev);
assert(m);
r = sd_netlink_message_get_errno(m);
if (r < 0) {
log_netdev_warning_errno(netdev, r, "Bridge parameters could not be set: %m");
return 1;
}
log_netdev_debug(netdev, "Bridge parameters set success");
return 1;
}
static int netdev_bridge_post_create_message(NetDev *netdev, sd_netlink_message *req) {
Bridge *b;
int r;
assert_se(b = BRIDGE(netdev));
r = sd_netlink_message_open_container(req, IFLA_LINKINFO);
if (r < 0)
return r;
r = sd_netlink_message_open_container_union(req, IFLA_INFO_DATA, netdev_kind_to_string(netdev->kind));
if (r < 0)
return r;
/* convert to jiffes */
if (b->forward_delay != USEC_INFINITY) {
r = sd_netlink_message_append_u32(req, IFLA_BR_FORWARD_DELAY, usec_to_jiffies(b->forward_delay));
if (r < 0)
return r;
}
if (b->hello_time > 0) {
r = sd_netlink_message_append_u32(req, IFLA_BR_HELLO_TIME, usec_to_jiffies(b->hello_time));
if (r < 0)
return r;
}
if (b->max_age > 0) {
r = sd_netlink_message_append_u32(req, IFLA_BR_MAX_AGE, usec_to_jiffies(b->max_age));
if (r < 0)
return r;
}
if (b->ageing_time != USEC_INFINITY) {
r = sd_netlink_message_append_u32(req, IFLA_BR_AGEING_TIME, usec_to_jiffies(b->ageing_time));
if (r < 0)
return r;
}
if (b->priority > 0) {
r = sd_netlink_message_append_u16(req, IFLA_BR_PRIORITY, b->priority);
if (r < 0)
return r;
}
if (b->group_fwd_mask > 0) {
r = sd_netlink_message_append_u16(req, IFLA_BR_GROUP_FWD_MASK, b->group_fwd_mask);
if (r < 0)
return r;
}
if (b->default_pvid != VLANID_INVALID) {
r = sd_netlink_message_append_u16(req, IFLA_BR_VLAN_DEFAULT_PVID, b->default_pvid);
if (r < 0)
return r;
}
if (b->mcast_querier >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BR_MCAST_QUERIER, b->mcast_querier);
if (r < 0)
return r;
}
if (b->mcast_snooping >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BR_MCAST_SNOOPING, b->mcast_snooping);
if (r < 0)
return r;
}
if (b->vlan_filtering >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BR_VLAN_FILTERING, b->vlan_filtering);
if (r < 0)
return r;
}
if (b->vlan_protocol >= 0) {
r = sd_netlink_message_append_u16(req, IFLA_BR_VLAN_PROTOCOL, htobe16(b->vlan_protocol));
if (r < 0)
return r;
}
if (b->stp >= 0) {
r = sd_netlink_message_append_u32(req, IFLA_BR_STP_STATE, b->stp);
if (r < 0)
return r;
}
if (b->igmp_version > 0) {
r = sd_netlink_message_append_u8(req, IFLA_BR_MCAST_IGMP_VERSION, b->igmp_version);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
static int netdev_bridge_post_create(NetDev *netdev, Link *link) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
int r;
assert(netdev);
r = sd_rtnl_message_new_link(netdev->manager->rtnl, &req, RTM_NEWLINK, netdev->ifindex);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not allocate netlink message: %m");
r = sd_netlink_message_set_flags(req, NLM_F_REQUEST | NLM_F_ACK);
if (r < 0)
return log_link_error_errno(link, r, "Could not set netlink message flags: %m");
r = netdev_bridge_post_create_message(netdev, req);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not create netlink message: %m");
r = netlink_call_async(netdev->manager->rtnl, NULL, req, netdev_bridge_set_handler,
netdev_destroy_callback, netdev);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not send netlink message: %m");
netdev_ref(netdev);
return r;
}
int config_parse_bridge_igmp_version(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
Bridge *b = userdata;
uint8_t u;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
if (isempty(rvalue)) {
b->igmp_version = 0; /* 0 means unset. */
return 0;
}
r = safe_atou8(rvalue, &u);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse bridge's multicast IGMP version number '%s', ignoring assignment: %m",
rvalue);
return 0;
}
if (!IN_SET(u, 2, 3)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid bridge's multicast IGMP version number '%s', ignoring assignment.", rvalue);
return 0;
}
b->igmp_version = u;
return 0;
}
int config_parse_bridge_port_priority(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
uint16_t i;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
/* This is used in networkd-network-gperf.gperf. */
r = safe_atou16(rvalue, &i);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse bridge port priority, ignoring: %s", rvalue);
return 0;
}
if (i > LINK_BRIDGE_PORT_PRIORITY_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Bridge port priority is larger than maximum %u, ignoring: %s",
LINK_BRIDGE_PORT_PRIORITY_MAX, rvalue);
return 0;
}
*((uint16_t *)data) = i;
return 0;
}
static void bridge_init(NetDev *n) {
Bridge *b;
b = BRIDGE(n);
assert(b);
b->mcast_querier = -1;
b->mcast_snooping = -1;
b->vlan_filtering = -1;
b->vlan_protocol = -1;
b->stp = -1;
b->default_pvid = VLANID_INVALID;
b->forward_delay = USEC_INFINITY;
b->ageing_time = USEC_INFINITY;
}
const NetDevVTable bridge_vtable = {
.object_size = sizeof(Bridge),
.init = bridge_init,
.sections = NETDEV_COMMON_SECTIONS "Bridge\0",
.post_create = netdev_bridge_post_create,
.create_type = NETDEV_CREATE_INDEPENDENT,
.iftype = ARPHRD_ETHER,
.generate_mac = true,
};
| 9,328 | 31.058419 | 114 |
c
|
null |
systemd-main/src/network/netdev/bridge.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "conf-parser.h"
#include "netdev.h"
#define LINK_BRIDGE_PORT_PRIORITY_INVALID 128U
#define LINK_BRIDGE_PORT_PRIORITY_MAX 63U
typedef struct Bridge {
NetDev meta;
int mcast_querier;
int mcast_snooping;
int vlan_filtering;
int vlan_protocol;
int stp;
uint16_t priority;
uint16_t group_fwd_mask;
uint16_t default_pvid;
uint8_t igmp_version;
usec_t forward_delay;
usec_t hello_time;
usec_t max_age;
usec_t ageing_time;
} Bridge;
typedef enum MulticastRouter {
MULTICAST_ROUTER_NONE,
MULTICAST_ROUTER_TEMPORARY_QUERY,
MULTICAST_ROUTER_PERMANENT,
MULTICAST_ROUTER_TEMPORARY,
_MULTICAST_ROUTER_MAX,
_MULTICAST_ROUTER_INVALID = -EINVAL,
} MulticastRouter;
DEFINE_NETDEV_CAST(BRIDGE, Bridge);
extern const NetDevVTable bridge_vtable;
const char* multicast_router_to_string(MulticastRouter i) _const_;
MulticastRouter multicast_router_from_string(const char *s) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_multicast_router);
CONFIG_PARSER_PROTOTYPE(config_parse_bridge_igmp_version);
CONFIG_PARSER_PROTOTYPE(config_parse_bridge_port_priority);
| 1,275 | 26.148936 | 67 |
h
|
null |
systemd-main/src/network/netdev/fou-tunnel.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <netinet/in.h>
#include <linux/fou.h>
#include "in-addr-util.h"
#include "netdev.h"
typedef enum FooOverUDPEncapType {
NETDEV_FOO_OVER_UDP_ENCAP_UNSPEC = FOU_ENCAP_UNSPEC,
NETDEV_FOO_OVER_UDP_ENCAP_DIRECT = FOU_ENCAP_DIRECT,
NETDEV_FOO_OVER_UDP_ENCAP_GUE = FOU_ENCAP_GUE,
_NETDEV_FOO_OVER_UDP_ENCAP_MAX,
_NETDEV_FOO_OVER_UDP_ENCAP_INVALID = -EINVAL,
} FooOverUDPEncapType;
typedef struct FouTunnel {
NetDev meta;
uint8_t fou_protocol;
uint16_t port;
uint16_t peer_port;
int local_family;
int peer_family;
FooOverUDPEncapType fou_encap_type;
union in_addr_union local;
union in_addr_union peer;
} FouTunnel;
DEFINE_NETDEV_CAST(FOU, FouTunnel);
extern const NetDevVTable foutnl_vtable;
const char *fou_encap_type_to_string(FooOverUDPEncapType d) _const_;
FooOverUDPEncapType fou_encap_type_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_fou_encap_type);
CONFIG_PARSER_PROTOTYPE(config_parse_ip_protocol);
CONFIG_PARSER_PROTOTYPE(config_parse_fou_tunnel_address);
| 1,180 | 26.465116 | 69 |
h
|
null |
systemd-main/src/network/netdev/geneve.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct Geneve Geneve;
#include "in-addr-util.h"
#include "netdev.h"
#include "networkd-network.h"
#define GENEVE_VID_MAX (1u << 24) - 1
typedef enum GeneveDF {
NETDEV_GENEVE_DF_NO = GENEVE_DF_UNSET,
NETDEV_GENEVE_DF_YES = GENEVE_DF_SET,
NETDEV_GENEVE_DF_INHERIT = GENEVE_DF_INHERIT,
_NETDEV_GENEVE_DF_MAX,
_NETDEV_GENEVE_DF_INVALID = -EINVAL,
} GeneveDF;
struct Geneve {
NetDev meta;
uint32_t id;
uint32_t flow_label;
int remote_family;
uint8_t tos;
uint8_t ttl;
uint16_t dest_port;
bool udpcsum;
bool udp6zerocsumtx;
bool udp6zerocsumrx;
bool inherit;
GeneveDF geneve_df;
union in_addr_union remote;
bool inherit_inner_protocol;
};
DEFINE_NETDEV_CAST(GENEVE, Geneve);
extern const NetDevVTable geneve_vtable;
const char *geneve_df_to_string(GeneveDF d) _const_;
GeneveDF geneve_df_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_geneve_vni);
CONFIG_PARSER_PROTOTYPE(config_parse_geneve_address);
CONFIG_PARSER_PROTOTYPE(config_parse_geneve_flow_label);
CONFIG_PARSER_PROTOTYPE(config_parse_geneve_df);
CONFIG_PARSER_PROTOTYPE(config_parse_geneve_ttl);
| 1,314 | 22.909091 | 56 |
h
|
null |
systemd-main/src/network/netdev/ipoib.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/if_arp.h>
#include <linux/if_link.h>
#include "ipoib.h"
#include "networkd-network.h"
#include "parse-util.h"
#include "string-table.h"
assert_cc((int) IP_OVER_INFINIBAND_MODE_DATAGRAM == (int) IPOIB_MODE_DATAGRAM);
assert_cc((int) IP_OVER_INFINIBAND_MODE_CONNECTED == (int) IPOIB_MODE_CONNECTED);
static void netdev_ipoib_init(NetDev *netdev) {
IPoIB *ipoib;
assert(netdev);
ipoib = IPOIB(netdev);
assert(ipoib);
ipoib->mode = _IP_OVER_INFINIBAND_MODE_INVALID;
ipoib->umcast = -1;
}
static int netdev_ipoib_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
IPoIB *ipoib;
int r;
assert(netdev);
assert(link);
assert(m);
ipoib = IPOIB(netdev);
assert(ipoib);
if (ipoib->pkey > 0) {
r = sd_netlink_message_append_u16(m, IFLA_IPOIB_PKEY, ipoib->pkey);
if (r < 0)
return r;
}
if (ipoib->mode >= 0) {
r = sd_netlink_message_append_u16(m, IFLA_IPOIB_MODE, ipoib->mode);
if (r < 0)
return r;
}
if (ipoib->umcast >= 0) {
r = sd_netlink_message_append_u16(m, IFLA_IPOIB_UMCAST, ipoib->umcast);
if (r < 0)
return r;
}
return 0;
}
int ipoib_set_netlink_message(Link *link, sd_netlink_message *m) {
int r;
assert(link);
assert(link->network);
assert(m);
r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK);
if (r < 0)
return r;
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
if (r < 0)
return r;
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind);
if (r < 0)
return r;
if (link->network->ipoib_mode >= 0) {
r = sd_netlink_message_append_u16(m, IFLA_IPOIB_MODE, link->network->ipoib_mode);
if (r < 0)
return r;
}
if (link->network->ipoib_umcast >= 0) {
r = sd_netlink_message_append_u16(m, IFLA_IPOIB_UMCAST, link->network->ipoib_umcast);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return r;
r = sd_netlink_message_close_container(m);
if (r < 0)
return r;
return 0;
}
static const char * const ipoib_mode_table[_IP_OVER_INFINIBAND_MODE_MAX] = {
[IP_OVER_INFINIBAND_MODE_DATAGRAM] = "datagram",
[IP_OVER_INFINIBAND_MODE_CONNECTED] = "connected",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(ipoib_mode, IPoIBMode);
DEFINE_CONFIG_PARSE_ENUM(config_parse_ipoib_mode, ipoib_mode, IPoIBMode, "Failed to parse IPoIB mode");
int config_parse_ipoib_pkey(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
uint16_t u, *pkey = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*pkey = 0; /* 0 means unset. */
return 0;
}
r = safe_atou16(rvalue, &u);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse IPoIB pkey '%s', ignoring assignment: %m",
rvalue);
return 0;
}
if (IN_SET(u, 0, 0x8000)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"IPoIB pkey cannot be 0 nor 0x8000, ignoring assignment: %s",
rvalue);
return 0;
}
*pkey = u;
return 0;
}
const NetDevVTable ipoib_vtable = {
.object_size = sizeof(IPoIB),
.sections = NETDEV_COMMON_SECTIONS "IPoIB\0",
.init = netdev_ipoib_init,
.fill_message_create = netdev_ipoib_fill_message_create,
.create_type = NETDEV_CREATE_STACKED,
.iftype = ARPHRD_INFINIBAND,
.generate_mac = true,
};
| 4,549 | 27.08642 | 103 |
c
|
null |
systemd-main/src/network/netdev/ipoib.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <errno.h>
#include "conf-parser.h"
#include "netdev.h"
typedef enum IPoIBMode {
IP_OVER_INFINIBAND_MODE_DATAGRAM,
IP_OVER_INFINIBAND_MODE_CONNECTED,
_IP_OVER_INFINIBAND_MODE_MAX,
_IP_OVER_INFINIBAND_MODE_INVALID = -EINVAL,
} IPoIBMode;
typedef struct IPoIB {
NetDev meta;
uint16_t pkey;
IPoIBMode mode;
int umcast;
} IPoIB;
DEFINE_NETDEV_CAST(IPOIB, IPoIB);
extern const NetDevVTable ipoib_vtable;
int ipoib_set_netlink_message(Link *link, sd_netlink_message *m);
CONFIG_PARSER_PROTOTYPE(config_parse_ipoib_pkey);
CONFIG_PARSER_PROTOTYPE(config_parse_ipoib_mode);
| 707 | 21.83871 | 65 |
h
|
null |
systemd-main/src/network/netdev/ipvlan.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
#include <netinet/in.h>
#include <linux/if_arp.h>
#include "conf-parser.h"
#include "ipvlan.h"
#include "ipvlan-util.h"
#include "networkd-link.h"
#include "string-util.h"
DEFINE_CONFIG_PARSE_ENUM(config_parse_ipvlan_mode, ipvlan_mode, IPVlanMode, "Failed to parse ipvlan mode");
DEFINE_CONFIG_PARSE_ENUM(config_parse_ipvlan_flags, ipvlan_flags, IPVlanFlags, "Failed to parse ipvlan flags");
static int netdev_ipvlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *req) {
IPVlan *m;
int r;
assert(netdev);
assert(link);
assert(netdev->ifname);
if (netdev->kind == NETDEV_KIND_IPVLAN)
m = IPVLAN(netdev);
else
m = IPVTAP(netdev);
assert(m);
if (m->mode != _NETDEV_IPVLAN_MODE_INVALID) {
r = sd_netlink_message_append_u16(req, IFLA_IPVLAN_MODE, m->mode);
if (r < 0)
return r;
}
if (m->flags != _NETDEV_IPVLAN_FLAGS_INVALID) {
r = sd_netlink_message_append_u16(req, IFLA_IPVLAN_FLAGS, m->flags);
if (r < 0)
return r;
}
return 0;
}
static void ipvlan_init(NetDev *n) {
IPVlan *m;
assert(n);
if (n->kind == NETDEV_KIND_IPVLAN)
m = IPVLAN(n);
else
m = IPVTAP(n);
assert(m);
m->mode = _NETDEV_IPVLAN_MODE_INVALID;
m->flags = _NETDEV_IPVLAN_FLAGS_INVALID;
}
const NetDevVTable ipvlan_vtable = {
.object_size = sizeof(IPVlan),
.init = ipvlan_init,
.sections = NETDEV_COMMON_SECTIONS "IPVLAN\0",
.fill_message_create = netdev_ipvlan_fill_message_create,
.create_type = NETDEV_CREATE_STACKED,
.iftype = ARPHRD_ETHER,
.generate_mac = true,
};
const NetDevVTable ipvtap_vtable = {
.object_size = sizeof(IPVlan),
.init = ipvlan_init,
.sections = NETDEV_COMMON_SECTIONS "IPVTAP\0",
.fill_message_create = netdev_ipvlan_fill_message_create,
.create_type = NETDEV_CREATE_STACKED,
.iftype = ARPHRD_ETHER,
.generate_mac = true,
};
IPVlanMode link_get_ipvlan_mode(Link *link) {
IPVlan *ipvlan;
assert(link);
ipvlan = IPVLAN(link->netdev);
if (!ipvlan)
return _NETDEV_IPVLAN_MODE_INVALID;
return ipvlan->mode;
}
| 2,505 | 25.946237 | 111 |
c
|
null |
systemd-main/src/network/netdev/ipvlan.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <netinet/in.h>
#include <linux/if_link.h>
#include "ipvlan-util.h"
#include "netdev.h"
typedef struct IPVlan {
NetDev meta;
IPVlanMode mode;
IPVlanFlags flags;
} IPVlan;
DEFINE_NETDEV_CAST(IPVLAN, IPVlan);
DEFINE_NETDEV_CAST(IPVTAP, IPVlan);
extern const NetDevVTable ipvlan_vtable;
extern const NetDevVTable ipvtap_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_ipvlan_mode);
CONFIG_PARSER_PROTOTYPE(config_parse_ipvlan_flags);
IPVlanMode link_get_ipvlan_mode(Link *link);
| 574 | 21.115385 | 51 |
h
|
null |
systemd-main/src/network/netdev/l2tp-tunnel.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <netinet/in.h>
#include <linux/l2tp.h>
#include "in-addr-util.h"
#include "netdev.h"
#include "networkd-util.h"
typedef enum L2tpL2specType {
NETDEV_L2TP_L2SPECTYPE_NONE = L2TP_L2SPECTYPE_NONE,
NETDEV_L2TP_L2SPECTYPE_DEFAULT = L2TP_L2SPECTYPE_DEFAULT,
_NETDEV_L2TP_L2SPECTYPE_MAX,
_NETDEV_L2TP_L2SPECTYPE_INVALID = -EINVAL,
} L2tpL2specType;
typedef enum L2tpEncapType {
NETDEV_L2TP_ENCAPTYPE_UDP = L2TP_ENCAPTYPE_UDP,
NETDEV_L2TP_ENCAPTYPE_IP = L2TP_ENCAPTYPE_IP,
_NETDEV_L2TP_ENCAPTYPE_MAX,
_NETDEV_L2TP_ENCAPTYPE_INVALID = -EINVAL,
} L2tpEncapType;
typedef enum L2tpLocalAddressType {
NETDEV_L2TP_LOCAL_ADDRESS_AUTO,
NETDEV_L2TP_LOCAL_ADDRESS_STATIC,
NETDEV_L2TP_LOCAL_ADDRESS_DYNAMIC,
_NETDEV_L2TP_LOCAL_ADDRESS_MAX,
_NETDEV_L2TP_LOCAL_ADDRESS_INVALID = -EINVAL,
} L2tpLocalAddressType;
typedef struct L2tpTunnel L2tpTunnel;
typedef struct L2tpSession {
L2tpTunnel *tunnel;
ConfigSection *section;
char *name;
uint32_t session_id;
uint32_t peer_session_id;
L2tpL2specType l2tp_l2spec_type;
} L2tpSession;
struct L2tpTunnel {
NetDev meta;
uint16_t l2tp_udp_sport;
uint16_t l2tp_udp_dport;
uint32_t tunnel_id;
uint32_t peer_tunnel_id;
int family;
bool udp_csum;
bool udp6_csum_rx;
bool udp6_csum_tx;
char *local_ifname;
L2tpLocalAddressType local_address_type;
union in_addr_union local;
union in_addr_union remote;
L2tpEncapType l2tp_encap_type;
OrderedHashmap *sessions_by_section;
};
DEFINE_NETDEV_CAST(L2TP, L2tpTunnel);
extern const NetDevVTable l2tptnl_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_l2tp_tunnel_local_address);
CONFIG_PARSER_PROTOTYPE(config_parse_l2tp_tunnel_remote_address);
CONFIG_PARSER_PROTOTYPE(config_parse_l2tp_tunnel_id);
CONFIG_PARSER_PROTOTYPE(config_parse_l2tp_encap_type);
CONFIG_PARSER_PROTOTYPE(config_parse_l2tp_session_l2spec);
CONFIG_PARSER_PROTOTYPE(config_parse_l2tp_session_id);
CONFIG_PARSER_PROTOTYPE(config_parse_l2tp_session_name);
| 2,242 | 26.691358 | 65 |
h
|
null |
systemd-main/src/network/netdev/macsec.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <netinet/in.h>
#include <linux/if_macsec.h>
#include "ether-addr-util.h"
#include "in-addr-util.h"
#include "netdev.h"
#include "networkd-util.h"
#include "sparse-endian.h"
/* See the definition of MACSEC_NUM_AN in kernel's drivers/net/macsec.c */
#define MACSEC_MAX_ASSOCIATION_NUMBER 4
typedef struct MACsec MACsec;
typedef union MACsecSCI {
uint64_t as_uint64;
struct {
struct ether_addr mac;
be16_t port;
} _packed_;
} MACsecSCI;
assert_cc(sizeof(MACsecSCI) == sizeof(uint64_t));
typedef struct SecurityAssociation {
uint8_t association_number;
uint32_t packet_number;
uint8_t key_id[MACSEC_KEYID_LEN];
uint8_t *key;
uint32_t key_len;
char *key_file;
int activate;
int use_for_encoding;
} SecurityAssociation;
typedef struct TransmitAssociation {
MACsec *macsec;
ConfigSection *section;
SecurityAssociation sa;
} TransmitAssociation;
typedef struct ReceiveAssociation {
MACsec *macsec;
ConfigSection *section;
MACsecSCI sci;
SecurityAssociation sa;
} ReceiveAssociation;
typedef struct ReceiveChannel {
MACsec *macsec;
ConfigSection *section;
MACsecSCI sci;
ReceiveAssociation *rxsa[MACSEC_MAX_ASSOCIATION_NUMBER];
unsigned n_rxsa;
} ReceiveChannel;
struct MACsec {
NetDev meta;
uint16_t port;
int encrypt;
uint8_t encoding_an;
OrderedHashmap *receive_channels;
OrderedHashmap *receive_channels_by_section;
OrderedHashmap *transmit_associations_by_section;
OrderedHashmap *receive_associations_by_section;
};
DEFINE_NETDEV_CAST(MACSEC, MACsec);
extern const NetDevVTable macsec_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_macsec_port);
CONFIG_PARSER_PROTOTYPE(config_parse_macsec_hw_address);
CONFIG_PARSER_PROTOTYPE(config_parse_macsec_packet_number);
CONFIG_PARSER_PROTOTYPE(config_parse_macsec_key_id);
CONFIG_PARSER_PROTOTYPE(config_parse_macsec_key);
CONFIG_PARSER_PROTOTYPE(config_parse_macsec_key_file);
CONFIG_PARSER_PROTOTYPE(config_parse_macsec_sa_activate);
CONFIG_PARSER_PROTOTYPE(config_parse_macsec_use_for_encoding);
| 2,307 | 25.227273 | 74 |
h
|
null |
systemd-main/src/network/netdev/macvlan.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
#include <netinet/in.h>
#include <linux/if_arp.h>
#include "conf-parser.h"
#include "macvlan.h"
#include "macvlan-util.h"
#include "networkd-network.h"
#include "parse-util.h"
DEFINE_CONFIG_PARSE_ENUM(config_parse_macvlan_mode, macvlan_mode, MacVlanMode, "Failed to parse macvlan mode");
static int netdev_macvlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *req) {
MacVlan *m;
int r;
assert(netdev);
assert(link);
assert(netdev->ifname);
assert(link->network);
if (netdev->kind == NETDEV_KIND_MACVLAN)
m = MACVLAN(netdev);
else
m = MACVTAP(netdev);
assert(m);
if (m->mode == NETDEV_MACVLAN_MODE_SOURCE && !set_isempty(m->match_source_mac)) {
const struct ether_addr *mac_addr;
r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_MACADDR_MODE, MACVLAN_MACADDR_SET);
if (r < 0)
return r;
r = sd_netlink_message_open_container(req, IFLA_MACVLAN_MACADDR_DATA);
if (r < 0)
return r;
SET_FOREACH(mac_addr, m->match_source_mac) {
r = sd_netlink_message_append_ether_addr(req, IFLA_MACVLAN_MACADDR, mac_addr);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
}
if (m->mode != _NETDEV_MACVLAN_MODE_INVALID) {
r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_MODE, m->mode);
if (r < 0)
return r;
}
/* set the nopromisc flag if Promiscuous= of the link is explicitly set to false */
if (m->mode == NETDEV_MACVLAN_MODE_PASSTHRU && link->network->promiscuous == 0) {
r = sd_netlink_message_append_u16(req, IFLA_MACVLAN_FLAGS, MACVLAN_FLAG_NOPROMISC);
if (r < 0)
return r;
}
if (m->bc_queue_length != UINT32_MAX) {
r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_BC_QUEUE_LEN, m->bc_queue_length);
if (r < 0)
return r;
}
return 0;
}
int config_parse_macvlan_broadcast_queue_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
MacVlan *m = ASSERT_PTR(userdata);
uint32_t v;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
if (isempty(rvalue)) {
m->bc_queue_length = UINT32_MAX;
return 0;
}
r = safe_atou32(rvalue, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse BroadcastMulticastQueueLength=%s, ignoring assignment: %m", rvalue);
return 0;
}
if (v == UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid BroadcastMulticastQueueLength=%s, ignoring assignment: %m", rvalue);
return 0;
}
m->bc_queue_length = v;
return 0;
}
static void macvlan_done(NetDev *n) {
MacVlan *m;
assert(n);
if (n->kind == NETDEV_KIND_MACVLAN)
m = MACVLAN(n);
else
m = MACVTAP(n);
assert(m);
set_free(m->match_source_mac);
}
static void macvlan_init(NetDev *n) {
MacVlan *m;
assert(n);
if (n->kind == NETDEV_KIND_MACVLAN)
m = MACVLAN(n);
else
m = MACVTAP(n);
assert(m);
m->mode = _NETDEV_MACVLAN_MODE_INVALID;
m->bc_queue_length = UINT32_MAX;
}
const NetDevVTable macvtap_vtable = {
.object_size = sizeof(MacVlan),
.init = macvlan_init,
.done = macvlan_done,
.sections = NETDEV_COMMON_SECTIONS "MACVTAP\0",
.fill_message_create = netdev_macvlan_fill_message_create,
.create_type = NETDEV_CREATE_STACKED,
.iftype = ARPHRD_ETHER,
.generate_mac = true,
};
const NetDevVTable macvlan_vtable = {
.object_size = sizeof(MacVlan),
.init = macvlan_init,
.done = macvlan_done,
.sections = NETDEV_COMMON_SECTIONS "MACVLAN\0",
.fill_message_create = netdev_macvlan_fill_message_create,
.create_type = NETDEV_CREATE_STACKED,
.iftype = ARPHRD_ETHER,
.generate_mac = true,
};
| 5,015 | 28.333333 | 112 |
c
|
null |
systemd-main/src/network/netdev/macvlan.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct MacVlan MacVlan;
#include "macvlan-util.h"
#include "netdev.h"
#include "set.h"
struct MacVlan {
NetDev meta;
MacVlanMode mode;
Set *match_source_mac;
uint32_t bc_queue_length;
};
DEFINE_NETDEV_CAST(MACVLAN, MacVlan);
DEFINE_NETDEV_CAST(MACVTAP, MacVlan);
extern const NetDevVTable macvlan_vtable;
extern const NetDevVTable macvtap_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_macvlan_mode);
CONFIG_PARSER_PROTOTYPE(config_parse_macvlan_broadcast_queue_size);
| 576 | 21.192308 | 67 |
h
|
null |
systemd-main/src/network/netdev/netdev-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "netdev-util.h"
#include "networkd-address.h"
#include "networkd-link.h"
#include "string-table.h"
static const char * const netdev_local_address_type_table[_NETDEV_LOCAL_ADDRESS_TYPE_MAX] = {
[NETDEV_LOCAL_ADDRESS_IPV4LL] = "ipv4_link_local",
[NETDEV_LOCAL_ADDRESS_IPV6LL] = "ipv6_link_local",
[NETDEV_LOCAL_ADDRESS_DHCP4] = "dhcp4",
[NETDEV_LOCAL_ADDRESS_DHCP6] = "dhcp6",
[NETDEV_LOCAL_ADDRESS_SLAAC] = "slaac",
};
DEFINE_STRING_TABLE_LOOKUP(netdev_local_address_type, NetDevLocalAddressType);
int link_get_local_address(
Link *link,
NetDevLocalAddressType type,
int family,
int *ret_family,
union in_addr_union *ret_address) {
Address *a;
assert(link);
switch (type) {
case NETDEV_LOCAL_ADDRESS_IPV4LL:
assert(IN_SET(family, AF_UNSPEC, AF_INET));
family = AF_INET;
break;
case NETDEV_LOCAL_ADDRESS_IPV6LL:
assert(IN_SET(family, AF_UNSPEC, AF_INET6));
family = AF_INET6;
break;
case NETDEV_LOCAL_ADDRESS_DHCP4:
assert(IN_SET(family, AF_UNSPEC, AF_INET));
family = AF_INET;
break;
case NETDEV_LOCAL_ADDRESS_DHCP6:
assert(IN_SET(family, AF_UNSPEC, AF_INET6));
family = AF_INET6;
break;
case NETDEV_LOCAL_ADDRESS_SLAAC:
assert(IN_SET(family, AF_UNSPEC, AF_INET6));
family = AF_INET6;
break;
default:
assert_not_reached();
}
if (!link_is_ready_to_configure(link, /* allow_unmanaged = */ false))
return -EBUSY;
SET_FOREACH(a, link->addresses) {
if (!address_is_ready(a))
continue;
if (a->family != family)
continue;
if (in_addr_is_set(a->family, &a->in_addr_peer))
continue;
switch (type) {
case NETDEV_LOCAL_ADDRESS_IPV4LL:
if (a->source != NETWORK_CONFIG_SOURCE_IPV4LL)
continue;
break;
case NETDEV_LOCAL_ADDRESS_IPV6LL:
if (!in6_addr_is_link_local(&a->in_addr.in6))
continue;
break;
case NETDEV_LOCAL_ADDRESS_DHCP4:
if (a->source != NETWORK_CONFIG_SOURCE_DHCP4)
continue;
break;
case NETDEV_LOCAL_ADDRESS_DHCP6:
if (a->source != NETWORK_CONFIG_SOURCE_DHCP6)
continue;
break;
case NETDEV_LOCAL_ADDRESS_SLAAC:
if (a->source != NETWORK_CONFIG_SOURCE_NDISC)
continue;
break;
default:
assert_not_reached();
}
if (ret_family)
*ret_family = a->family;
if (ret_address)
*ret_address = a->in_addr;
return 1;
}
return -ENXIO;
}
| 3,471 | 33.376238 | 93 |
c
|
null |
systemd-main/src/network/netdev/netdev-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "in-addr-util.h"
#include "macro.h"
typedef struct Link Link;
typedef enum NetDevLocalAddressType {
NETDEV_LOCAL_ADDRESS_IPV4LL,
NETDEV_LOCAL_ADDRESS_IPV6LL,
NETDEV_LOCAL_ADDRESS_DHCP4,
NETDEV_LOCAL_ADDRESS_DHCP6,
NETDEV_LOCAL_ADDRESS_SLAAC,
_NETDEV_LOCAL_ADDRESS_TYPE_MAX,
_NETDEV_LOCAL_ADDRESS_TYPE_INVALID = -EINVAL,
} NetDevLocalAddressType;
const char *netdev_local_address_type_to_string(NetDevLocalAddressType t) _const_;
NetDevLocalAddressType netdev_local_address_type_from_string(const char *s) _pure_;
int link_get_local_address(
Link *link,
NetDevLocalAddressType type,
int family,
int *ret_family,
union in_addr_union *ret_address);
| 858 | 29.678571 | 83 |
h
|
null |
systemd-main/src/network/netdev/netdev.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-netlink.h"
#include "conf-parser.h"
#include "ether-addr-util.h"
#include "list.h"
#include "log-link.h"
#include "networkd-link.h"
#include "time-util.h"
/* Special hardware address value to suppress generating persistent hardware address for the netdev. */
#define HW_ADDR_NONE ((struct hw_addr_data) { .length = 1, })
#define NETDEV_COMMON_SECTIONS "Match\0NetDev\0"
/* This is the list of known sections. We need to ignore them in the initial parsing phase. */
#define NETDEV_OTHER_SECTIONS \
"-BareUDP\0" \
"-BatmanAdvanced\0" \
"-Bond\0" \
"-Bridge\0" \
"-FooOverUDP\0" \
"-GENEVE\0" \
"-IPoIB\0" \
"-IPVLAN\0" \
"-IPVTAP\0" \
"-L2TP\0" \
"-L2TPSession\0" \
"-MACsec\0" \
"-MACsecReceiveAssociation\0" \
"-MACsecReceiveChannel\0" \
"-MACsecTransmitAssociation\0" \
"-MACVLAN\0" \
"-MACVTAP\0" \
"-Peer\0" \
"-Tap\0" \
"-Tun\0" \
"-Tunnel\0" \
"-VLAN\0" \
"-VRF\0" \
"-VXCAN\0" \
"-VXLAN\0" \
"-WLAN\0" \
"-WireGuard\0" \
"-WireGuardPeer\0" \
"-Xfrm\0"
typedef enum NetDevKind {
NETDEV_KIND_BAREUDP,
NETDEV_KIND_BATADV,
NETDEV_KIND_BOND,
NETDEV_KIND_BRIDGE,
NETDEV_KIND_DUMMY,
NETDEV_KIND_ERSPAN,
NETDEV_KIND_FOU,
NETDEV_KIND_GENEVE,
NETDEV_KIND_GRE,
NETDEV_KIND_GRETAP,
NETDEV_KIND_IFB,
NETDEV_KIND_IP6GRE,
NETDEV_KIND_IP6GRETAP,
NETDEV_KIND_IP6TNL,
NETDEV_KIND_IPIP,
NETDEV_KIND_IPOIB,
NETDEV_KIND_IPVLAN,
NETDEV_KIND_IPVTAP,
NETDEV_KIND_L2TP,
NETDEV_KIND_MACSEC,
NETDEV_KIND_MACVLAN,
NETDEV_KIND_MACVTAP,
NETDEV_KIND_NETDEVSIM,
NETDEV_KIND_NLMON,
NETDEV_KIND_SIT,
NETDEV_KIND_TAP,
NETDEV_KIND_TUN,
NETDEV_KIND_VCAN,
NETDEV_KIND_VETH,
NETDEV_KIND_VLAN,
NETDEV_KIND_VRF,
NETDEV_KIND_VTI,
NETDEV_KIND_VTI6,
NETDEV_KIND_VXCAN,
NETDEV_KIND_VXLAN,
NETDEV_KIND_WIREGUARD,
NETDEV_KIND_WLAN,
NETDEV_KIND_XFRM,
_NETDEV_KIND_MAX,
_NETDEV_KIND_TUNNEL, /* Used by config_parse_stacked_netdev() */
_NETDEV_KIND_INVALID = -EINVAL,
} NetDevKind;
typedef enum NetDevState {
NETDEV_STATE_LOADING,
NETDEV_STATE_FAILED,
NETDEV_STATE_CREATING,
NETDEV_STATE_READY,
NETDEV_STATE_LINGER,
_NETDEV_STATE_MAX,
_NETDEV_STATE_INVALID = -EINVAL,
} NetDevState;
typedef enum NetDevCreateType {
NETDEV_CREATE_INDEPENDENT,
NETDEV_CREATE_STACKED,
_NETDEV_CREATE_MAX,
_NETDEV_CREATE_INVALID = -EINVAL,
} NetDevCreateType;
typedef struct Manager Manager;
typedef struct Condition Condition;
typedef struct NetDev {
Manager *manager;
unsigned n_ref;
char *filename;
LIST_HEAD(Condition, conditions);
NetDevState state;
NetDevKind kind;
char *description;
char *ifname;
struct hw_addr_data hw_addr;
uint32_t mtu;
int ifindex;
} NetDev;
typedef struct NetDevVTable {
/* How much memory does an object of this unit type need */
size_t object_size;
/* Config file sections this netdev kind understands, separated
* by NUL chars */
const char *sections;
/* This should reset all type-specific variables. This should
* not allocate memory, and is called with zero-initialized
* data. It should hence only initialize variables that need
* to be set != 0. */
void (*init)(NetDev *n);
/* This is called when the interface is removed. */
void (*drop)(NetDev *n);
/* This should free all kind-specific variables. It should be
* idempotent. */
void (*done)(NetDev *n);
/* fill in message to create netdev */
int (*fill_message_create)(NetDev *netdev, Link *link, sd_netlink_message *message);
/* specifies if netdev is independent, or a master device or a stacked device */
NetDevCreateType create_type;
/* This is used for stacked netdev. Return true when the underlying link is ready. */
int (*is_ready_to_create)(NetDev *netdev, Link *link);
/* create netdev, if not done via rtnl */
int (*create)(NetDev *netdev);
/* perform additional configuration after netdev has been createad */
int (*post_create)(NetDev *netdev, Link *link);
/* verify that compulsory configuration options were specified */
int (*config_verify)(NetDev *netdev, const char *filename);
/* expected iftype, e.g. ARPHRD_ETHER. */
uint16_t iftype;
/* Generate MAC address when MACAddress= is not specified. */
bool generate_mac;
/* When assigning ifindex to the netdev, skip to check if the netdev kind matches. */
bool skip_netdev_kind_check;
} NetDevVTable;
extern const NetDevVTable * const netdev_vtable[_NETDEV_KIND_MAX];
#define NETDEV_VTABLE(n) ((n)->kind != _NETDEV_KIND_INVALID ? netdev_vtable[(n)->kind] : NULL)
/* For casting a netdev into the various netdev kinds */
#define DEFINE_NETDEV_CAST(UPPERCASE, MixedCase) \
static inline MixedCase* UPPERCASE(NetDev *n) { \
if (_unlikely_(!n || \
n->kind != NETDEV_KIND_##UPPERCASE) || \
n->state == _NETDEV_STATE_INVALID) \
return NULL; \
\
return (MixedCase*) n; \
}
/* For casting the various netdev kinds into a netdev */
#define NETDEV(n) (&(n)->meta)
int netdev_load(Manager *manager, bool reload);
int netdev_load_one(Manager *manager, const char *filename);
void netdev_drop(NetDev *netdev);
void netdev_enter_failed(NetDev *netdev);
NetDev *netdev_unref(NetDev *netdev);
NetDev *netdev_ref(NetDev *netdev);
DEFINE_TRIVIAL_DESTRUCTOR(netdev_destroy_callback, NetDev, netdev_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(NetDev*, netdev_unref);
bool netdev_is_managed(NetDev *netdev);
int netdev_get(Manager *manager, const char *name, NetDev **ret);
int netdev_set_ifindex(NetDev *netdev, sd_netlink_message *newlink);
int netdev_generate_hw_addr(NetDev *netdev, Link *link, const char *name,
const struct hw_addr_data *hw_addr, struct hw_addr_data *ret);
int link_request_stacked_netdev(Link *link, NetDev *netdev);
const char *netdev_kind_to_string(NetDevKind d) _const_;
NetDevKind netdev_kind_from_string(const char *d) _pure_;
static inline NetDevCreateType netdev_get_create_type(NetDev *netdev) {
assert(netdev);
assert(NETDEV_VTABLE(netdev));
return NETDEV_VTABLE(netdev)->create_type;
}
CONFIG_PARSER_PROTOTYPE(config_parse_netdev_kind);
CONFIG_PARSER_PROTOTYPE(config_parse_netdev_hw_addr);
/* gperf */
const struct ConfigPerfItem* network_netdev_gperf_lookup(const char *key, GPERF_LEN_TYPE length);
/* Macros which append INTERFACE= to the message */
#define log_netdev_full_errno_zerook(netdev, level, error, ...) \
({ \
const NetDev *_n = (netdev); \
log_interface_full_errno_zerook(_n ? _n->ifname : NULL, level, error, __VA_ARGS__); \
})
#define log_netdev_full_errno(netdev, level, error, ...) \
({ \
int _error = (error); \
ASSERT_NON_ZERO(_error); \
log_netdev_full_errno_zerook(netdev, level, _error, __VA_ARGS__); \
})
#define log_netdev_full(netdev, level, ...) (void) log_netdev_full_errno_zerook(netdev, level, 0, __VA_ARGS__)
#define log_netdev_debug(netdev, ...) log_netdev_full(netdev, LOG_DEBUG, __VA_ARGS__)
#define log_netdev_info(netdev, ...) log_netdev_full(netdev, LOG_INFO, __VA_ARGS__)
#define log_netdev_notice(netdev, ...) log_netdev_full(netdev, LOG_NOTICE, __VA_ARGS__)
#define log_netdev_warning(netdev, ...) log_netdev_full(netdev, LOG_WARNING, __VA_ARGS__)
#define log_netdev_error(netdev, ...) log_netdev_full(netdev, LOG_ERR, __VA_ARGS__)
#define log_netdev_debug_errno(netdev, error, ...) log_netdev_full_errno(netdev, LOG_DEBUG, error, __VA_ARGS__)
#define log_netdev_info_errno(netdev, error, ...) log_netdev_full_errno(netdev, LOG_INFO, error, __VA_ARGS__)
#define log_netdev_notice_errno(netdev, error, ...) log_netdev_full_errno(netdev, LOG_NOTICE, error, __VA_ARGS__)
#define log_netdev_warning_errno(netdev, error, ...) log_netdev_full_errno(netdev, LOG_WARNING, error, __VA_ARGS__)
#define log_netdev_error_errno(netdev, error, ...) log_netdev_full_errno(netdev, LOG_ERR, error, __VA_ARGS__)
#define LOG_NETDEV_MESSAGE(netdev, fmt, ...) "MESSAGE=%s: " fmt, (netdev)->ifname, ##__VA_ARGS__
#define LOG_NETDEV_INTERFACE(netdev) "INTERFACE=%s", (netdev)->ifname
| 10,317 | 38.231939 | 115 |
h
|
null |
systemd-main/src/network/netdev/nlmon.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/if_arp.h>
#include "nlmon.h"
static int netdev_nlmon_verify(NetDev *netdev, const char *filename) {
assert(netdev);
assert(filename);
if (netdev->hw_addr.length > 0) {
log_netdev_warning(netdev, "%s: MACAddress= is not supported. Ignoring", filename);
netdev->hw_addr = HW_ADDR_NULL;
}
return 0;
}
const NetDevVTable nlmon_vtable = {
.object_size = sizeof(NLMon),
.sections = NETDEV_COMMON_SECTIONS,
.create_type = NETDEV_CREATE_INDEPENDENT,
.config_verify = netdev_nlmon_verify,
.iftype = ARPHRD_NETLINK,
};
| 692 | 25.653846 | 99 |
c
|
null |
systemd-main/src/network/netdev/tunnel.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "in-addr-util.h"
#include "conf-parser.h"
#include "fou-tunnel.h"
#include "netdev-util.h"
#include "netdev.h"
#include "networkd-link.h"
typedef enum Ip6TnlMode {
NETDEV_IP6_TNL_MODE_IP6IP6,
NETDEV_IP6_TNL_MODE_IPIP6,
NETDEV_IP6_TNL_MODE_ANYIP6,
_NETDEV_IP6_TNL_MODE_MAX,
_NETDEV_IP6_TNL_MODE_INVALID = -EINVAL,
} Ip6TnlMode;
typedef enum IPv6FlowLabel {
NETDEV_IPV6_FLOWLABEL_INHERIT = 0xFFFFF + 1,
_NETDEV_IPV6_FLOWLABEL_MAX,
_NETDEV_IPV6_FLOWLABEL_INVALID = -EINVAL,
} IPv6FlowLabel;
typedef struct Tunnel {
NetDev meta;
uint8_t encap_limit;
int family;
int ipv6_flowlabel;
int allow_localremote;
int gre_erspan_sequence;
int isatap;
unsigned ttl;
unsigned tos;
unsigned flags;
uint32_t key;
uint32_t ikey;
uint32_t okey;
uint8_t erspan_version;
uint32_t erspan_index; /* version 1 */
uint8_t erspan_direction; /* version 2 */
uint16_t erspan_hwid; /* version 2 */
NetDevLocalAddressType local_type;
union in_addr_union local;
union in_addr_union remote;
Ip6TnlMode ip6tnl_mode;
FooOverUDPEncapType fou_encap_type;
int pmtudisc;
bool ignore_df;
bool copy_dscp;
bool independent;
bool fou_tunnel;
bool assign_to_loopback;
bool external; /* a.k.a collect metadata mode */
uint16_t encap_src_port;
uint16_t fou_destination_port;
struct in6_addr sixrd_prefix;
uint8_t sixrd_prefixlen;
} Tunnel;
int dhcp4_pd_create_6rd_tunnel_name(Link *link, char **ret);
int dhcp4_pd_create_6rd_tunnel(Link *link, link_netlink_message_handler_t callback);
DEFINE_NETDEV_CAST(IPIP, Tunnel);
DEFINE_NETDEV_CAST(GRE, Tunnel);
DEFINE_NETDEV_CAST(GRETAP, Tunnel);
DEFINE_NETDEV_CAST(IP6GRE, Tunnel);
DEFINE_NETDEV_CAST(IP6GRETAP, Tunnel);
DEFINE_NETDEV_CAST(SIT, Tunnel);
DEFINE_NETDEV_CAST(VTI, Tunnel);
DEFINE_NETDEV_CAST(VTI6, Tunnel);
DEFINE_NETDEV_CAST(IP6TNL, Tunnel);
DEFINE_NETDEV_CAST(ERSPAN, Tunnel);
static inline Tunnel* TUNNEL(NetDev *netdev) {
assert(netdev);
switch (netdev->kind) {
case NETDEV_KIND_IPIP:
return IPIP(netdev);
case NETDEV_KIND_SIT:
return SIT(netdev);
case NETDEV_KIND_GRE:
return GRE(netdev);
case NETDEV_KIND_GRETAP:
return GRETAP(netdev);
case NETDEV_KIND_IP6GRE:
return IP6GRE(netdev);
case NETDEV_KIND_IP6GRETAP:
return IP6GRETAP(netdev);
case NETDEV_KIND_VTI:
return VTI(netdev);
case NETDEV_KIND_VTI6:
return VTI6(netdev);
case NETDEV_KIND_IP6TNL:
return IP6TNL(netdev);
case NETDEV_KIND_ERSPAN:
return ERSPAN(netdev);
default:
return NULL;
}
}
extern const NetDevVTable ipip_vtable;
extern const NetDevVTable sit_vtable;
extern const NetDevVTable vti_vtable;
extern const NetDevVTable vti6_vtable;
extern const NetDevVTable gre_vtable;
extern const NetDevVTable gretap_vtable;
extern const NetDevVTable ip6gre_vtable;
extern const NetDevVTable ip6gretap_vtable;
extern const NetDevVTable ip6tnl_vtable;
extern const NetDevVTable erspan_vtable;
const char *ip6tnl_mode_to_string(Ip6TnlMode d) _const_;
Ip6TnlMode ip6tnl_mode_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_ip6tnl_mode);
CONFIG_PARSER_PROTOTYPE(config_parse_tunnel_local_address);
CONFIG_PARSER_PROTOTYPE(config_parse_tunnel_remote_address);
CONFIG_PARSER_PROTOTYPE(config_parse_ipv6_flowlabel);
CONFIG_PARSER_PROTOTYPE(config_parse_encap_limit);
CONFIG_PARSER_PROTOTYPE(config_parse_tunnel_key);
CONFIG_PARSER_PROTOTYPE(config_parse_6rd_prefix);
CONFIG_PARSER_PROTOTYPE(config_parse_erspan_version);
CONFIG_PARSER_PROTOTYPE(config_parse_erspan_index);
CONFIG_PARSER_PROTOTYPE(config_parse_erspan_direction);
CONFIG_PARSER_PROTOTYPE(config_parse_erspan_hwid);
| 4,185 | 28.9 | 84 |
h
|
null |
systemd-main/src/network/netdev/tuntap.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <netinet/if_ether.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <linux/if_tun.h>
#include "alloc-util.h"
#include "daemon-util.h"
#include "fd-util.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "socket-util.h"
#include "tuntap.h"
#include "user-util.h"
#define TUN_DEV "/dev/net/tun"
static TunTap* TUNTAP(NetDev *netdev) {
assert(netdev);
switch (netdev->kind) {
case NETDEV_KIND_TAP:
return TAP(netdev);
case NETDEV_KIND_TUN:
return TUN(netdev);
default:
return NULL;
}
}
static void *close_fd_ptr(void *p) {
safe_close(PTR_TO_FD(p));
return NULL;
}
DEFINE_PRIVATE_HASH_OPS_FULL(named_fd_hash_ops, char, string_hash_func, string_compare_func, free, void, close_fd_ptr);
int manager_add_tuntap_fd(Manager *m, int fd, const char *name) {
_cleanup_free_ char *tuntap_name = NULL;
const char *p;
int r;
assert(m);
assert(fd >= 0);
assert(name);
p = startswith(name, "tuntap-");
if (!p)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Received unknown fd (%s).", name);
if (!ifname_valid(p))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Received tuntap fd with invalid name (%s).", p);
tuntap_name = strdup(p);
if (!tuntap_name)
return log_oom_debug();
r = hashmap_ensure_put(&m->tuntap_fds_by_name, &named_fd_hash_ops, tuntap_name, FD_TO_PTR(fd));
if (r < 0)
return log_debug_errno(r, "Failed to store tuntap fd: %m");
TAKE_PTR(tuntap_name);
return 0;
}
void manager_clear_unmanaged_tuntap_fds(Manager *m) {
char *name;
void *p;
assert(m);
while ((p = hashmap_steal_first_key_and_value(m->tuntap_fds_by_name, (void**) &name))) {
close_and_notify_warn(PTR_TO_FD(p), name);
name = mfree(name);
}
}
static int tuntap_take_fd(NetDev *netdev) {
_cleanup_free_ char *name = NULL;
void *p;
int r;
assert(netdev);
assert(netdev->manager);
r = link_get_by_name(netdev->manager, netdev->ifname, NULL);
if (r < 0)
return r;
p = hashmap_remove2(netdev->manager->tuntap_fds_by_name, netdev->ifname, (void**) &name);
if (!p)
return -ENOENT;
log_netdev_debug(netdev, "Found file descriptor in fd store.");
return PTR_TO_FD(p);
}
static int netdev_create_tuntap(NetDev *netdev) {
_cleanup_close_ int fd = -EBADF;
struct ifreq ifr = {};
TunTap *t;
int r;
assert(netdev);
t = TUNTAP(netdev);
assert(t);
fd = TAKE_FD(t->fd);
if (fd < 0)
fd = tuntap_take_fd(netdev);
if (fd < 0)
fd = open(TUN_DEV, O_RDWR|O_CLOEXEC);
if (fd < 0)
return log_netdev_error_errno(netdev, errno, "Failed to open " TUN_DEV ": %m");
if (netdev->kind == NETDEV_KIND_TAP)
ifr.ifr_flags |= IFF_TAP;
else
ifr.ifr_flags |= IFF_TUN;
if (!t->packet_info)
ifr.ifr_flags |= IFF_NO_PI;
if (t->multi_queue)
ifr.ifr_flags |= IFF_MULTI_QUEUE;
if (t->vnet_hdr)
ifr.ifr_flags |= IFF_VNET_HDR;
strncpy(ifr.ifr_name, netdev->ifname, IFNAMSIZ-1);
if (ioctl(fd, TUNSETIFF, &ifr) < 0)
return log_netdev_error_errno(netdev, errno, "TUNSETIFF failed: %m");
if (t->user_name) {
const char *user = t->user_name;
uid_t uid;
r = get_user_creds(&user, &uid, NULL, NULL, NULL, USER_CREDS_ALLOW_MISSING);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Cannot resolve user name %s: %m", t->user_name);
if (ioctl(fd, TUNSETOWNER, uid) < 0)
return log_netdev_error_errno(netdev, errno, "TUNSETOWNER failed: %m");
}
if (t->group_name) {
const char *group = t->group_name;
gid_t gid;
r = get_group_creds(&group, &gid, USER_CREDS_ALLOW_MISSING);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Cannot resolve group name %s: %m", t->group_name);
if (ioctl(fd, TUNSETGROUP, gid) < 0)
return log_netdev_error_errno(netdev, errno, "TUNSETGROUP failed: %m");
}
if (ioctl(fd, TUNSETPERSIST, 1) < 0)
return log_netdev_error_errno(netdev, errno, "TUNSETPERSIST failed: %m");
if (t->keep_fd) {
t->fd = TAKE_FD(fd);
(void) notify_push_fdf(t->fd, "tuntap-%s", netdev->ifname);
}
return 0;
}
static void tuntap_init(NetDev *netdev) {
TunTap *t;
assert(netdev);
t = TUNTAP(netdev);
assert(t);
t->fd = -EBADF;
}
static void tuntap_drop(NetDev *netdev) {
TunTap *t;
assert(netdev);
t = TUNTAP(netdev);
assert(t);
t->fd = close_and_notify_warn(t->fd, netdev->ifname);
}
static void tuntap_done(NetDev *netdev) {
TunTap *t;
assert(netdev);
t = TUNTAP(netdev);
assert(t);
t->fd = safe_close(t->fd);
t->user_name = mfree(t->user_name);
t->group_name = mfree(t->group_name);
}
static int tuntap_verify(NetDev *netdev, const char *filename) {
assert(netdev);
if (netdev->mtu != 0)
log_netdev_warning(netdev,
"MTUBytes= configured for %s device in %s will be ignored.\n"
"Please set it in the corresponding .network file.",
netdev_kind_to_string(netdev->kind), filename);
if (netdev->hw_addr.length > 0)
log_netdev_warning(netdev,
"MACAddress= configured for %s device in %s will be ignored.\n"
"Please set it in the corresponding .network file.",
netdev_kind_to_string(netdev->kind), filename);
return 0;
}
const NetDevVTable tun_vtable = {
.object_size = sizeof(TunTap),
.sections = NETDEV_COMMON_SECTIONS "Tun\0",
.config_verify = tuntap_verify,
.init = tuntap_init,
.drop = tuntap_drop,
.done = tuntap_done,
.create = netdev_create_tuntap,
.create_type = NETDEV_CREATE_INDEPENDENT,
.iftype = ARPHRD_NONE,
};
const NetDevVTable tap_vtable = {
.object_size = sizeof(TunTap),
.sections = NETDEV_COMMON_SECTIONS "Tap\0",
.config_verify = tuntap_verify,
.init = tuntap_init,
.drop = tuntap_drop,
.done = tuntap_done,
.create = netdev_create_tuntap,
.create_type = NETDEV_CREATE_INDEPENDENT,
.iftype = ARPHRD_ETHER,
};
| 7,258 | 28.15261 | 119 |
c
|
null |
systemd-main/src/network/netdev/tuntap.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct TunTap TunTap;
#include "netdev.h"
struct TunTap {
NetDev meta;
int fd;
char *user_name;
char *group_name;
bool multi_queue;
bool packet_info;
bool vnet_hdr;
bool keep_fd;
};
DEFINE_NETDEV_CAST(TUN, TunTap);
DEFINE_NETDEV_CAST(TAP, TunTap);
extern const NetDevVTable tun_vtable;
extern const NetDevVTable tap_vtable;
int manager_add_tuntap_fd(Manager *m, int fd, const char *name);
void manager_clear_unmanaged_tuntap_fds(Manager *m);
| 582 | 20.592593 | 64 |
h
|
null |
systemd-main/src/network/netdev/veth.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <net/if.h>
#include <netinet/in.h>
#include <linux/if_arp.h>
#include <linux/veth.h>
#include "netlink-util.h"
#include "veth.h"
static int netdev_veth_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
struct hw_addr_data hw_addr;
Veth *v;
int r;
assert(netdev);
assert(!link);
assert(m);
v = VETH(netdev);
assert(v);
r = sd_netlink_message_open_container(m, VETH_INFO_PEER);
if (r < 0)
return r;
if (v->ifname_peer) {
r = sd_netlink_message_append_string(m, IFLA_IFNAME, v->ifname_peer);
if (r < 0)
return r;
}
r = netdev_generate_hw_addr(netdev, NULL, v->ifname_peer, &v->hw_addr_peer, &hw_addr);
if (r < 0)
return r;
if (hw_addr.length > 0) {
log_netdev_debug(netdev, "Using MAC address for peer: %s", HW_ADDR_TO_STR(&hw_addr));
r = netlink_message_append_hw_addr(m, IFLA_ADDRESS, &hw_addr);
if (r < 0)
return r;
}
if (netdev->mtu != 0) {
r = sd_netlink_message_append_u32(m, IFLA_MTU, netdev->mtu);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return r;
return 0;
}
static int netdev_veth_verify(NetDev *netdev, const char *filename) {
Veth *v;
assert(netdev);
assert(filename);
v = VETH(netdev);
assert(v);
if (!v->ifname_peer)
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"Veth NetDev without peer name configured in %s. Ignoring",
filename);
return 0;
}
static void veth_done(NetDev *n) {
Veth *v;
assert(n);
v = VETH(n);
assert(v);
free(v->ifname_peer);
}
const NetDevVTable veth_vtable = {
.object_size = sizeof(Veth),
.sections = NETDEV_COMMON_SECTIONS "Peer\0",
.done = veth_done,
.fill_message_create = netdev_veth_fill_message_create,
.create_type = NETDEV_CREATE_INDEPENDENT,
.config_verify = netdev_veth_verify,
.iftype = ARPHRD_ETHER,
.generate_mac = true,
};
| 2,525 | 24.515152 | 107 |
c
|
null |
systemd-main/src/network/netdev/vlan.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <net/if.h>
#include <linux/if_arp.h>
#include <linux/if_vlan.h>
#include "parse-util.h"
#include "vlan-util.h"
#include "vlan.h"
static int netdev_vlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *req) {
struct ifla_vlan_flags flags = {};
VLan *v;
int r;
assert(netdev);
assert(link);
assert(req);
v = VLAN(netdev);
assert(v);
r = sd_netlink_message_append_u16(req, IFLA_VLAN_ID, v->id);
if (r < 0)
return r;
if (v->protocol >= 0) {
r = sd_netlink_message_append_u16(req, IFLA_VLAN_PROTOCOL, htobe16(v->protocol));
if (r < 0)
return r;
}
if (v->gvrp != -1) {
flags.mask |= VLAN_FLAG_GVRP;
SET_FLAG(flags.flags, VLAN_FLAG_GVRP, v->gvrp);
}
if (v->mvrp != -1) {
flags.mask |= VLAN_FLAG_MVRP;
SET_FLAG(flags.flags, VLAN_FLAG_MVRP, v->mvrp);
}
if (v->reorder_hdr != -1) {
flags.mask |= VLAN_FLAG_REORDER_HDR;
SET_FLAG(flags.flags, VLAN_FLAG_REORDER_HDR, v->reorder_hdr);
}
if (v->loose_binding != -1) {
flags.mask |= VLAN_FLAG_LOOSE_BINDING;
SET_FLAG(flags.flags, VLAN_FLAG_LOOSE_BINDING, v->loose_binding);
}
r = sd_netlink_message_append_data(req, IFLA_VLAN_FLAGS, &flags, sizeof(struct ifla_vlan_flags));
if (r < 0)
return r;
if (!set_isempty(v->egress_qos_maps)) {
struct ifla_vlan_qos_mapping *m;
r = sd_netlink_message_open_container(req, IFLA_VLAN_EGRESS_QOS);
if (r < 0)
return r;
SET_FOREACH(m, v->egress_qos_maps) {
r = sd_netlink_message_append_data(req, IFLA_VLAN_QOS_MAPPING, m, sizeof(struct ifla_vlan_qos_mapping));
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
}
if (!set_isempty(v->ingress_qos_maps)) {
struct ifla_vlan_qos_mapping *m;
r = sd_netlink_message_open_container(req, IFLA_VLAN_INGRESS_QOS);
if (r < 0)
return r;
SET_FOREACH(m, v->ingress_qos_maps) {
r = sd_netlink_message_append_data(req, IFLA_VLAN_QOS_MAPPING, m, sizeof(struct ifla_vlan_qos_mapping));
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
}
return 0;
}
static void vlan_qos_maps_hash_func(const struct ifla_vlan_qos_mapping *x, struct siphash *state) {
siphash24_compress(&x->from, sizeof(x->from), state);
siphash24_compress(&x->to, sizeof(x->to), state);
}
static int vlan_qos_maps_compare_func(const struct ifla_vlan_qos_mapping *a, const struct ifla_vlan_qos_mapping *b) {
int r;
r = CMP(a->from, b->from);
if (r != 0)
return r;
return CMP(a->to, b->to);
}
DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(
vlan_qos_maps_hash_ops,
struct ifla_vlan_qos_mapping,
vlan_qos_maps_hash_func,
vlan_qos_maps_compare_func,
free);
int config_parse_vlan_qos_maps(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
Set **s = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*s = set_free(*s);
return 0;
}
for (const char *p = rvalue;;) {
_cleanup_free_ struct ifla_vlan_qos_mapping *m = NULL;
_cleanup_free_ char *w = NULL;
unsigned from, to;
r = extract_first_word(&p, &w, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s, ignoring: %s", lvalue, rvalue);
return 0;
}
if (r == 0)
return 0;
r = parse_range(w, &from, &to);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse %s, ignoring: %s", lvalue, w);
continue;
}
m = new(struct ifla_vlan_qos_mapping, 1);
if (!m)
return log_oom();
*m = (struct ifla_vlan_qos_mapping) {
.from = from,
.to = to,
};
r = set_ensure_consume(s, &vlan_qos_maps_hash_ops, TAKE_PTR(m));
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to store %s, ignoring: %s", lvalue, w);
continue;
}
}
}
static int netdev_vlan_verify(NetDev *netdev, const char *filename) {
VLan *v;
assert(netdev);
assert(filename);
v = VLAN(netdev);
assert(v);
if (v->id == VLANID_INVALID) {
log_netdev_warning(netdev, "VLAN without valid Id (%"PRIu16") configured in %s.", v->id, filename);
return -EINVAL;
}
return 0;
}
static void vlan_done(NetDev *n) {
VLan *v;
v = VLAN(n);
assert(v);
set_free(v->egress_qos_maps);
set_free(v->ingress_qos_maps);
}
static void vlan_init(NetDev *netdev) {
VLan *v = VLAN(netdev);
assert(netdev);
assert(v);
v->id = VLANID_INVALID;
v->protocol = -1;
v->gvrp = -1;
v->mvrp = -1;
v->loose_binding = -1;
v->reorder_hdr = -1;
}
const NetDevVTable vlan_vtable = {
.object_size = sizeof(VLan),
.init = vlan_init,
.sections = NETDEV_COMMON_SECTIONS "VLAN\0",
.fill_message_create = netdev_vlan_fill_message_create,
.create_type = NETDEV_CREATE_STACKED,
.config_verify = netdev_vlan_verify,
.done = vlan_done,
.iftype = ARPHRD_ETHER,
};
| 6,959 | 28.617021 | 128 |
c
|
null |
systemd-main/src/network/netdev/vrf.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
#include <netinet/in.h>
#include <linux/if_arp.h>
#include "vrf.h"
static int netdev_vrf_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
Vrf *v;
int r;
assert(netdev);
assert(!link);
assert(m);
v = VRF(netdev);
assert(v);
r = sd_netlink_message_append_u32(m, IFLA_VRF_TABLE, v->table);
if (r < 0)
return r;
return 0;
}
const NetDevVTable vrf_vtable = {
.object_size = sizeof(Vrf),
.sections = NETDEV_COMMON_SECTIONS "VRF\0",
.fill_message_create = netdev_vrf_fill_message_create,
.create_type = NETDEV_CREATE_INDEPENDENT,
.iftype = ARPHRD_ETHER,
.generate_mac = true,
};
| 818 | 21.75 | 94 |
c
|
null |
systemd-main/src/network/netdev/vxcan.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/can/vxcan.h>
#include <linux/if_arp.h>
#include "vxcan.h"
static int netdev_vxcan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
VxCan *v;
int r;
assert(netdev);
assert(!link);
assert(m);
v = VXCAN(netdev);
assert(v);
r = sd_netlink_message_open_container(m, VXCAN_INFO_PEER);
if (r < 0)
return r;
if (v->ifname_peer) {
r = sd_netlink_message_append_string(m, IFLA_IFNAME, v->ifname_peer);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return r;
return 0;
}
static int netdev_vxcan_verify(NetDev *netdev, const char *filename) {
VxCan *v;
assert(netdev);
assert(filename);
v = VXCAN(netdev);
assert(v);
if (!v->ifname_peer)
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"VxCan NetDev without peer name configured in %s. Ignoring", filename);
return 0;
}
static void vxcan_done(NetDev *n) {
VxCan *v;
assert(n);
v = VXCAN(n);
assert(v);
free(v->ifname_peer);
}
const NetDevVTable vxcan_vtable = {
.object_size = sizeof(VxCan),
.sections = NETDEV_COMMON_SECTIONS "VXCAN\0",
.done = vxcan_done,
.fill_message_create = netdev_vxcan_fill_message_create,
.create_type = NETDEV_CREATE_INDEPENDENT,
.config_verify = netdev_vxcan_verify,
.iftype = ARPHRD_CAN,
};
| 1,733 | 22.12 | 119 |
c
|
null |
systemd-main/src/network/netdev/vxlan.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
#include <netinet/in.h>
#include <linux/if_arp.h>
#include "conf-parser.h"
#include "alloc-util.h"
#include "extract-word.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "parse-util.h"
#include "vxlan.h"
static const char* const df_table[_NETDEV_VXLAN_DF_MAX] = {
[NETDEV_VXLAN_DF_NO] = "no",
[NETDEV_VXLAN_DF_YES] = "yes",
[NETDEV_VXLAN_DF_INHERIT] = "inherit",
};
DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(df, VxLanDF, NETDEV_VXLAN_DF_YES);
DEFINE_CONFIG_PARSE_ENUM(config_parse_df, df, VxLanDF, "Failed to parse VXLAN IPDoNotFragment= setting");
static int vxlan_get_local_address(VxLan *v, Link *link, int *ret_family, union in_addr_union *ret_address) {
assert(v);
if (v->local_type < 0) {
if (ret_family)
*ret_family = v->local_family;
if (ret_address)
*ret_address = v->local;
return 0;
}
return link_get_local_address(link, v->local_type, v->local_family, ret_family, ret_address);
}
static int netdev_vxlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
union in_addr_union local;
int local_family, r;
VxLan *v;
assert(netdev);
assert(m);
v = VXLAN(netdev);
assert(v);
if (v->vni <= VXLAN_VID_MAX) {
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_ID, v->vni);
if (r < 0)
return r;
}
if (in_addr_is_set(v->group_family, &v->group)) {
if (v->group_family == AF_INET)
r = sd_netlink_message_append_in_addr(m, IFLA_VXLAN_GROUP, &v->group.in);
else
r = sd_netlink_message_append_in6_addr(m, IFLA_VXLAN_GROUP6, &v->group.in6);
if (r < 0)
return r;
} else if (in_addr_is_set(v->remote_family, &v->remote)) {
if (v->remote_family == AF_INET)
r = sd_netlink_message_append_in_addr(m, IFLA_VXLAN_GROUP, &v->remote.in);
else
r = sd_netlink_message_append_in6_addr(m, IFLA_VXLAN_GROUP6, &v->remote.in6);
if (r < 0)
return r;
}
r = vxlan_get_local_address(v, link, &local_family, &local);
if (r < 0)
return r;
if (in_addr_is_set(local_family, &local)) {
if (local_family == AF_INET)
r = sd_netlink_message_append_in_addr(m, IFLA_VXLAN_LOCAL, &local.in);
else
r = sd_netlink_message_append_in6_addr(m, IFLA_VXLAN_LOCAL6, &local.in6);
if (r < 0)
return r;
}
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LINK, link ? link->ifindex : 0);
if (r < 0)
return r;
if (v->inherit) {
r = sd_netlink_message_append_flag(m, IFLA_VXLAN_TTL_INHERIT);
if (r < 0)
return r;
} else {
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_TTL, v->ttl);
if (r < 0)
return r;
}
if (v->tos != 0) {
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_TOS, v->tos);
if (r < 0)
return r;
}
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_LEARNING, v->learning);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_RSC, v->route_short_circuit);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_PROXY, v->arp_proxy);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_L2MISS, v->l2miss);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_L3MISS, v->l3miss);
if (r < 0)
return r;
if (v->fdb_ageing != 0) {
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_AGEING, v->fdb_ageing / USEC_PER_SEC);
if (r < 0)
return r;
}
if (v->max_fdb != 0) {
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LIMIT, v->max_fdb);
if (r < 0)
return r;
}
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_CSUM, v->udpcsum);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_TX, v->udp6zerocsumtx);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_RX, v->udp6zerocsumrx);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_REMCSUM_TX, v->remote_csum_tx);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_REMCSUM_RX, v->remote_csum_rx);
if (r < 0)
return r;
r = sd_netlink_message_append_u16(m, IFLA_VXLAN_PORT, htobe16(v->dest_port));
if (r < 0)
return r;
if (v->port_range.low != 0 || v->port_range.high != 0) {
struct ifla_vxlan_port_range port_range;
port_range.low = htobe16(v->port_range.low);
port_range.high = htobe16(v->port_range.high);
r = sd_netlink_message_append_data(m, IFLA_VXLAN_PORT_RANGE, &port_range, sizeof(port_range));
if (r < 0)
return r;
}
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LABEL, htobe32(v->flow_label));
if (r < 0)
return r;
if (v->group_policy) {
r = sd_netlink_message_append_flag(m, IFLA_VXLAN_GBP);
if (r < 0)
return r;
}
if (v->generic_protocol_extension) {
r = sd_netlink_message_append_flag(m, IFLA_VXLAN_GPE);
if (r < 0)
return r;
}
if (v->df != _NETDEV_VXLAN_DF_INVALID) {
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_DF, v->df);
if (r < 0)
return r;
}
return 0;
}
int config_parse_vxlan_address(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
VxLan *v = ASSERT_PTR(userdata);
union in_addr_union *addr = data, buffer;
int *family, f, r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
if (streq(lvalue, "Local"))
family = &v->local_family;
else if (streq(lvalue, "Remote"))
family = &v->remote_family;
else if (streq(lvalue, "Group"))
family = &v->group_family;
else
assert_not_reached();
if (isempty(rvalue)) {
*addr = IN_ADDR_NULL;
*family = AF_UNSPEC;
return 0;
}
if (streq(lvalue, "Local")) {
NetDevLocalAddressType t;
t = netdev_local_address_type_from_string(rvalue);
if (t >= 0) {
v->local = IN_ADDR_NULL;
v->local_family = AF_UNSPEC;
v->local_type = t;
return 0;
}
}
r = in_addr_from_string_auto(rvalue, &f, &buffer);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
r = in_addr_is_multicast(f, &buffer);
if (streq(lvalue, "Group")) {
if (r <= 0) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"%s= must be a multicast address, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
} else {
if (r > 0) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"%s= cannot be a multicast address, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
}
if (streq(lvalue, "Local"))
v->local_type = _NETDEV_LOCAL_ADDRESS_TYPE_INVALID;
*addr = buffer;
*family = f;
return 0;
}
int config_parse_port_range(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
VxLan *v = userdata;
uint16_t low, high;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
r = parse_ip_port_range(rvalue, &low, &high);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse VXLAN port range '%s'. Port should be greater than 0 and less than 65535.", rvalue);
return 0;
}
v->port_range.low = low;
v->port_range.high = high;
return 0;
}
int config_parse_flow_label(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
VxLan *v = userdata;
unsigned f;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
r = safe_atou(rvalue, &f);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse VXLAN flow label '%s'.", rvalue);
return 0;
}
if (f & ~VXLAN_FLOW_LABEL_MAX_MASK) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"VXLAN flow label '%s' not valid. Flow label range should be [0-1048575].", rvalue);
return 0;
}
v->flow_label = f;
return 0;
}
int config_parse_vxlan_ttl(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
VxLan *v = userdata;
unsigned f;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
if (streq(rvalue, "inherit"))
v->inherit = true;
else {
r = safe_atou(rvalue, &f);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse VXLAN TTL '%s', ignoring assignment: %m", rvalue);
return 0;
}
if (f > 255) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid VXLAN TTL '%s'. TTL must be <= 255. Ignoring assignment.", rvalue);
return 0;
}
v->ttl = f;
}
return 0;
}
static int netdev_vxlan_verify(NetDev *netdev, const char *filename) {
VxLan *v = VXLAN(netdev);
assert(netdev);
assert(v);
assert(filename);
if (v->vni > VXLAN_VID_MAX)
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"%s: VXLAN without valid VNI (or VXLAN Segment ID) configured. Ignoring.",
filename);
if (v->ttl > 255)
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"%s: VXLAN TTL must be <= 255. Ignoring.",
filename);
if (!v->dest_port && v->generic_protocol_extension)
v->dest_port = 4790;
if (in_addr_is_set(v->group_family, &v->group) && in_addr_is_set(v->remote_family, &v->remote))
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"%s: VXLAN both 'Group=' and 'Remote=' cannot be specified. Ignoring.",
filename);
if (v->independent && v->local_type >= 0)
return log_netdev_error_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"The local address cannot be '%s' when Independent= is enabled, ignoring.",
strna(netdev_local_address_type_to_string(v->local_type)));
return 0;
}
static int netdev_vxlan_is_ready_to_create(NetDev *netdev, Link *link) {
VxLan *v;
assert(netdev);
v = VXLAN(netdev);
assert(v);
if (v->independent)
return true;
return vxlan_get_local_address(v, link, NULL, NULL) >= 0;
}
static void vxlan_init(NetDev *netdev) {
VxLan *v;
assert(netdev);
v = VXLAN(netdev);
assert(v);
v->local_type = _NETDEV_LOCAL_ADDRESS_TYPE_INVALID;
v->vni = VXLAN_VID_MAX + 1;
v->df = _NETDEV_VXLAN_DF_INVALID;
v->learning = true;
v->udpcsum = false;
v->udp6zerocsumtx = false;
v->udp6zerocsumrx = false;
}
const NetDevVTable vxlan_vtable = {
.object_size = sizeof(VxLan),
.init = vxlan_init,
.sections = NETDEV_COMMON_SECTIONS "VXLAN\0",
.fill_message_create = netdev_vxlan_fill_message_create,
.create_type = NETDEV_CREATE_STACKED,
.is_ready_to_create = netdev_vxlan_is_ready_to_create,
.config_verify = netdev_vxlan_verify,
.iftype = ARPHRD_ETHER,
.generate_mac = true,
};
| 14,969 | 30.918977 | 128 |
c
|
null |
systemd-main/src/network/netdev/vxlan.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct VxLan VxLan;
#include <linux/if_link.h>
#include "in-addr-util.h"
#include "netdev-util.h"
#include "netdev.h"
#define VXLAN_VID_MAX (1u << 24) - 1
#define VXLAN_FLOW_LABEL_MAX_MASK 0xFFFFFU
typedef enum VxLanDF {
NETDEV_VXLAN_DF_NO = VXLAN_DF_UNSET,
NETDEV_VXLAN_DF_YES = VXLAN_DF_SET,
NETDEV_VXLAN_DF_INHERIT = VXLAN_DF_INHERIT,
_NETDEV_VXLAN_DF_MAX,
_NETDEV_VXLAN_DF_INVALID = -EINVAL,
} VxLanDF;
struct VxLan {
NetDev meta;
uint32_t vni;
int remote_family;
int local_family;
int group_family;
VxLanDF df;
NetDevLocalAddressType local_type;
union in_addr_union local;
union in_addr_union remote;
union in_addr_union group;
unsigned tos;
unsigned ttl;
unsigned max_fdb;
unsigned flow_label;
uint16_t dest_port;
usec_t fdb_ageing;
bool learning;
bool arp_proxy;
bool route_short_circuit;
bool l2miss;
bool l3miss;
bool udpcsum;
bool udp6zerocsumtx;
bool udp6zerocsumrx;
bool remote_csum_tx;
bool remote_csum_rx;
bool group_policy;
bool generic_protocol_extension;
bool inherit;
bool independent;
struct ifla_vxlan_port_range port_range;
};
DEFINE_NETDEV_CAST(VXLAN, VxLan);
extern const NetDevVTable vxlan_vtable;
const char *df_to_string(VxLanDF d) _const_;
VxLanDF df_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_vxlan_address);
CONFIG_PARSER_PROTOTYPE(config_parse_port_range);
CONFIG_PARSER_PROTOTYPE(config_parse_flow_label);
CONFIG_PARSER_PROTOTYPE(config_parse_df);
CONFIG_PARSER_PROTOTYPE(config_parse_vxlan_ttl);
| 1,833 | 22.818182 | 52 |
h
|
null |
systemd-main/src/network/netdev/wireguard.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct Wireguard Wireguard;
#include <netinet/in.h>
#include <linux/wireguard.h>
#include "sd-event.h"
#include "sd-resolve.h"
#include "in-addr-util.h"
#include "netdev.h"
#include "socket-util.h"
typedef struct WireguardIPmask {
uint16_t family;
union in_addr_union ip;
uint8_t cidr;
LIST_FIELDS(struct WireguardIPmask, ipmasks);
} WireguardIPmask;
typedef struct WireguardPeer {
Wireguard *wireguard;
ConfigSection *section;
uint8_t public_key[WG_KEY_LEN];
uint8_t preshared_key[WG_KEY_LEN];
char *preshared_key_file;
uint32_t flags;
uint16_t persistent_keepalive_interval;
union sockaddr_union endpoint;
char *endpoint_host;
char *endpoint_port;
unsigned n_retries;
sd_event_source *resolve_retry_event_source;
sd_resolve_query *resolve_query;
uint32_t route_table;
uint32_t route_priority;
bool route_table_set;
bool route_priority_set;
LIST_HEAD(WireguardIPmask, ipmasks);
LIST_FIELDS(struct WireguardPeer, peers);
} WireguardPeer;
struct Wireguard {
NetDev meta;
unsigned last_peer_section;
uint32_t flags;
uint8_t private_key[WG_KEY_LEN];
char *private_key_file;
uint16_t port;
uint32_t fwmark;
Hashmap *peers_by_section;
LIST_HEAD(WireguardPeer, peers);
Set *routes;
uint32_t route_table;
uint32_t route_priority;
};
DEFINE_NETDEV_CAST(WIREGUARD, Wireguard);
extern const NetDevVTable wireguard_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_allowed_ips);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_endpoint);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_listen_port);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_peer_key);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_private_key);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_private_key_file);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_preshared_key_file);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_keepalive);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_route_table);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_peer_route_table);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_route_priority);
CONFIG_PARSER_PROTOTYPE(config_parse_wireguard_peer_route_priority);
| 2,433 | 27.635294 | 68 |
h
|
null |
systemd-main/src/network/netdev/wlan.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if_arp.h>
#include "sd-netlink.h"
#include "netlink-util.h"
#include "networkd-manager.h"
#include "networkd-wiphy.h"
#include "parse-util.h"
#include "wifi-util.h"
#include "wlan.h"
static void wlan_done(NetDev *netdev) {
WLan *w;
assert(netdev);
w = WLAN(netdev);
assert(w);
w->wiphy_name = mfree(w->wiphy_name);
}
static void wlan_init(NetDev *netdev) {
WLan *w;
assert(netdev);
w = WLAN(netdev);
assert(w);
w->wiphy_index = UINT32_MAX;
w->wds = -1;
}
static int wlan_get_wiphy(NetDev *netdev, Wiphy **ret) {
WLan *w;
assert(netdev);
w = WLAN(netdev);
assert(w);
if (w->wiphy_name)
return wiphy_get_by_name(netdev->manager, w->wiphy_name, ret);
return wiphy_get_by_index(netdev->manager, w->wiphy_index, ret);
}
static int wlan_is_ready_to_create(NetDev *netdev, Link *link) {
return wlan_get_wiphy(netdev, NULL) >= 0;
}
static int wlan_fill_message(NetDev *netdev, sd_netlink_message *m) {
Wiphy *wiphy;
WLan *w;
int r;
assert(netdev);
assert(m);
w = WLAN(netdev);
assert(w);
r = wlan_get_wiphy(netdev, &wiphy);
if (r < 0)
return r;
r = sd_netlink_message_append_u32(m, NL80211_ATTR_WIPHY, wiphy->index);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NL80211_ATTR_IFNAME, netdev->ifname);
if (r < 0)
return r;
r = sd_netlink_message_append_u32(m, NL80211_ATTR_IFTYPE, w->iftype);
if (r < 0)
return r;
if (!hw_addr_is_null(&netdev->hw_addr) && netdev->hw_addr.length == ETH_ALEN) {
r = sd_netlink_message_append_ether_addr(m, NL80211_ATTR_MAC, &netdev->hw_addr.ether);
if (r < 0)
return r;
}
if (w->wds >= 0) {
r = sd_netlink_message_append_u8(m, NL80211_ATTR_4ADDR, w->wds);
if (r < 0)
return r;
}
return 0;
}
static int wlan_create_handler(sd_netlink *genl, sd_netlink_message *m, NetDev *netdev) {
int r;
assert(netdev);
assert(netdev->state != _NETDEV_STATE_INVALID);
r = sd_netlink_message_get_errno(m);
if (IN_SET(r, -EEXIST, -ENFILE))
/* Unlike the other netdevs, the kernel may return -ENFILE. See dev_alloc_name(). */
log_netdev_info(netdev, "WLAN interface exists, using existing without changing its parameters.");
else if (r < 0) {
log_netdev_warning_errno(netdev, r, "WLAN interface could not be created: %m");
netdev_enter_failed(netdev);
return 1;
}
log_netdev_debug(netdev, "WLAN interface is created.");
return 1;
}
static int wlan_create(NetDev *netdev) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(netdev);
assert(netdev->manager);
assert(netdev->manager->genl);
r = sd_genl_message_new(netdev->manager->genl, NL80211_GENL_NAME, NL80211_CMD_NEW_INTERFACE, &m);
if (r < 0)
return log_netdev_warning_errno(netdev, r, "Failed to allocate netlink message: %m");
r = wlan_fill_message(netdev, m);
if (r < 0)
return log_netdev_warning_errno(netdev, r, "Failed to fill netlink message: %m");
r = netlink_call_async(netdev->manager->genl, NULL, m, wlan_create_handler,
netdev_destroy_callback, netdev);
if (r < 0)
return log_netdev_warning_errno(netdev, r, "Failed to send netlink message: %m");
netdev_ref(netdev);
return 0;
}
static int wlan_verify(NetDev *netdev, const char *filename) {
WLan *w;
assert(netdev);
assert(filename);
w = WLAN(netdev);
assert(w);
if (w->iftype == NL80211_IFTYPE_UNSPECIFIED)
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"%s: WLAN interface type is not specified, ignoring.",
filename);
if (w->wiphy_index == UINT32_MAX && isempty(w->wiphy_name))
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"%s: physical WLAN device is not specified, ignoring.",
filename);
return 0;
}
int config_parse_wiphy(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
WLan *w = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
w->wiphy_name = mfree(w->wiphy_name);
w->wiphy_index = UINT32_MAX;
return 0;
}
r = safe_atou32(rvalue, &w->wiphy_index);
if (r >= 0) {
w->wiphy_name = mfree(w->wiphy_name);
return 0;
}
r = free_and_strdup_warn(&w->wiphy_name, rvalue);
if (r < 0)
return r;
w->wiphy_index = UINT32_MAX;
return 0;
}
int config_parse_wlan_iftype(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
enum nl80211_iftype t, *iftype = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*iftype = NL80211_IFTYPE_UNSPECIFIED;
return 0;
}
t = nl80211_iftype_from_string(rvalue);
/* We reuse the kernel provided enum which does not contain negative value. So, the cast
* below is mandatory. Otherwise, the check below always passes. */
if ((int) t < 0) {
log_syntax(unit, LOG_WARNING, filename, line, t,
"Failed to parse wlan interface type, ignoring assignment: %s",
rvalue);
return 0;
}
*iftype = t;
return 0;
}
const NetDevVTable wlan_vtable = {
.object_size = sizeof(WLan),
.init = wlan_init,
.done = wlan_done,
.sections = NETDEV_COMMON_SECTIONS "WLAN\0",
.is_ready_to_create = wlan_is_ready_to_create,
.create = wlan_create,
.create_type = NETDEV_CREATE_INDEPENDENT,
.config_verify = wlan_verify,
.iftype = ARPHRD_ETHER,
.generate_mac = true,
.skip_netdev_kind_check = true,
};
| 7,335 | 27.324324 | 114 |
c
|
null |
systemd-main/src/network/netdev/xfrm.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/if_arp.h>
#include "missing_network.h"
#include "xfrm.h"
static int xfrm_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *message) {
Xfrm *x;
int r;
assert(netdev);
assert(message);
x = XFRM(netdev);
assert(x);
assert(link || x->independent);
r = sd_netlink_message_append_u32(message, IFLA_XFRM_LINK, link ? link->ifindex : LOOPBACK_IFINDEX);
if (r < 0)
return r;
r = sd_netlink_message_append_u32(message, IFLA_XFRM_IF_ID, x->if_id);
if (r < 0)
return r;
return 0;
}
static int xfrm_verify(NetDev *netdev, const char *filename) {
Xfrm *x;
assert(netdev);
assert(filename);
x = XFRM(netdev);
assert(x);
if (x->if_id == 0)
return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
"%s: Xfrm interface ID cannot be zero.", filename);
return 0;
}
const NetDevVTable xfrm_vtable = {
.object_size = sizeof(Xfrm),
.sections = NETDEV_COMMON_SECTIONS "Xfrm\0",
.fill_message_create = xfrm_fill_message_create,
.config_verify = xfrm_verify,
.create_type = NETDEV_CREATE_STACKED,
.iftype = ARPHRD_NONE,
};
| 1,400 | 24.017857 | 108 |
c
|
null |
systemd-main/src/network/tc/cake.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "cake.h"
#include "conf-parser.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "qdisc.h"
#include "string-table.h"
#include "string-util.h"
static int cake_init(QDisc *qdisc) {
CommonApplicationsKeptEnhanced *c;
assert(qdisc);
c = CAKE(qdisc);
c->autorate = -1;
c->compensation_mode = _CAKE_COMPENSATION_MODE_INVALID;
c->raw = -1;
c->flow_isolation_mode = _CAKE_FLOW_ISOLATION_MODE_INVALID;
c->nat = -1;
c->preset = _CAKE_PRESET_INVALID;
c->wash = -1;
c->split_gso = -1;
c->ack_filter = _CAKE_ACK_FILTER_INVALID;
return 0;
}
static int cake_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
CommonApplicationsKeptEnhanced *c;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(c = CAKE(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "cake");
if (r < 0)
return r;
if (c->bandwidth > 0) {
r = sd_netlink_message_append_u64(req, TCA_CAKE_BASE_RATE64, c->bandwidth);
if (r < 0)
return r;
}
if (c->autorate >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_AUTORATE, c->autorate);
if (r < 0)
return r;
}
if (c->overhead_set) {
r = sd_netlink_message_append_s32(req, TCA_CAKE_OVERHEAD, c->overhead);
if (r < 0)
return r;
}
if (c->mpu > 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_MPU, c->mpu);
if (r < 0)
return r;
}
if (c->compensation_mode >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_ATM, c->compensation_mode);
if (r < 0)
return r;
}
if (c->raw > 0) {
/* TCA_CAKE_RAW attribute is mostly a flag, not boolean. */
r = sd_netlink_message_append_u32(req, TCA_CAKE_RAW, 0);
if (r < 0)
return r;
}
if (c->flow_isolation_mode >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_FLOW_MODE, c->flow_isolation_mode);
if (r < 0)
return r;
}
if (c->nat >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_NAT, c->nat);
if (r < 0)
return r;
}
if (c->preset >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_DIFFSERV_MODE, c->preset);
if (r < 0)
return r;
}
if (c->fwmark > 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_FWMARK, c->fwmark);
if (r < 0)
return r;
}
if (c->wash >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_WASH, c->wash);
if (r < 0)
return r;
}
if (c->split_gso >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_SPLIT_GSO, c->split_gso);
if (r < 0)
return r;
}
if (c->rtt > 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_RTT, c->rtt);
if (r < 0)
return r;
}
if (c->ack_filter >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_ACK_FILTER, c->ack_filter);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_cake_bandwidth(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
Network *network = ASSERT_PTR(data);
uint64_t k;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (isempty(rvalue)) {
c->bandwidth = 0;
TAKE_PTR(qdisc);
return 0;
}
r = parse_size(rvalue, 1000, &k);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
c->bandwidth = k/8;
TAKE_PTR(qdisc);
return 0;
}
int config_parse_cake_overhead(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
Network *network = ASSERT_PTR(data);
int32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (isempty(rvalue)) {
c->overhead_set = false;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atoi32(rvalue, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (v < -64 || v > 256) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
c->overhead = v;
c->overhead_set = true;
TAKE_PTR(qdisc);
return 0;
}
int config_parse_cake_mpu(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
Network *network = ASSERT_PTR(data);
uint32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (isempty(rvalue)) {
c->mpu = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32(rvalue, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (v <= 0 || v > 256) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
c->mpu = v;
TAKE_PTR(qdisc);
return 0;
}
int config_parse_cake_tristate(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
Network *network = ASSERT_PTR(data);
int *dest, r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (streq(lvalue, "AutoRateIngress"))
dest = &c->autorate;
else if (streq(lvalue, "UseRawPacketSize"))
dest = &c->raw;
else if (streq(lvalue, "NAT"))
dest = &c->nat;
else if (streq(lvalue, "Wash"))
dest = &c->wash;
else if (streq(lvalue, "SplitGSO"))
dest = &c->split_gso;
else
assert_not_reached();
if (isempty(rvalue)) {
*dest = -1;
TAKE_PTR(qdisc);
return 0;
}
r = parse_boolean(rvalue);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
*dest = r;
TAKE_PTR(qdisc);
return 0;
}
static const char * const cake_compensation_mode_table[_CAKE_COMPENSATION_MODE_MAX] = {
[CAKE_COMPENSATION_MODE_NONE] = "none",
[CAKE_COMPENSATION_MODE_ATM] = "atm",
[CAKE_COMPENSATION_MODE_PTM] = "ptm",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(cake_compensation_mode, CakeCompensationMode);
int config_parse_cake_compensation_mode(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
Network *network = ASSERT_PTR(data);
CakeCompensationMode mode;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (isempty(rvalue)) {
c->compensation_mode = _CAKE_COMPENSATION_MODE_INVALID;
TAKE_PTR(qdisc);
return 0;
}
mode = cake_compensation_mode_from_string(rvalue);
if (mode < 0) {
log_syntax(unit, LOG_WARNING, filename, line, mode,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
c->compensation_mode = mode;
TAKE_PTR(qdisc);
return 0;
}
static const char * const cake_flow_isolation_mode_table[_CAKE_FLOW_ISOLATION_MODE_MAX] = {
[CAKE_FLOW_ISOLATION_MODE_NONE] = "none",
[CAKE_FLOW_ISOLATION_MODE_SRC_IP] = "src-host",
[CAKE_FLOW_ISOLATION_MODE_DST_IP] = "dst-host",
[CAKE_FLOW_ISOLATION_MODE_HOSTS] = "hosts",
[CAKE_FLOW_ISOLATION_MODE_FLOWS] = "flows",
[CAKE_FLOW_ISOLATION_MODE_DUAL_SRC] = "dual-src-host",
[CAKE_FLOW_ISOLATION_MODE_DUAL_DST] = "dual-dst-host",
[CAKE_FLOW_ISOLATION_MODE_TRIPLE] = "triple",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(cake_flow_isolation_mode, CakeFlowIsolationMode);
int config_parse_cake_flow_isolation_mode(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
Network *network = ASSERT_PTR(data);
CakeFlowIsolationMode mode;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (isempty(rvalue)) {
c->flow_isolation_mode = _CAKE_FLOW_ISOLATION_MODE_INVALID;
TAKE_PTR(qdisc);
return 0;
}
mode = cake_flow_isolation_mode_from_string(rvalue);
if (mode < 0) {
log_syntax(unit, LOG_WARNING, filename, line, mode,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
c->flow_isolation_mode = mode;
TAKE_PTR(qdisc);
return 0;
}
static const char * const cake_priority_queueing_preset_table[_CAKE_PRESET_MAX] = {
[CAKE_PRESET_DIFFSERV3] = "diffserv3",
[CAKE_PRESET_DIFFSERV4] = "diffserv4",
[CAKE_PRESET_DIFFSERV8] = "diffserv8",
[CAKE_PRESET_BESTEFFORT] = "besteffort",
[CAKE_PRESET_PRECEDENCE] = "precedence",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(cake_priority_queueing_preset, CakePriorityQueueingPreset);
int config_parse_cake_priority_queueing_preset(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
CakePriorityQueueingPreset preset;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (isempty(rvalue)) {
c->preset = _CAKE_PRESET_INVALID;
TAKE_PTR(qdisc);
return 0;
}
preset = cake_priority_queueing_preset_from_string(rvalue);
if (preset < 0) {
log_syntax(unit, LOG_WARNING, filename, line, preset,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
c->preset = preset;
TAKE_PTR(qdisc);
return 0;
}
int config_parse_cake_fwmark(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
Network *network = ASSERT_PTR(data);
uint32_t fwmark;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (isempty(rvalue)) {
c->fwmark = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32(rvalue, &fwmark);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (fwmark <= 0) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
c->fwmark = fwmark;
TAKE_PTR(qdisc);
return 0;
}
int config_parse_cake_rtt(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
Network *network = ASSERT_PTR(data);
usec_t t;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (isempty(rvalue)) {
c->rtt = 0;
TAKE_PTR(qdisc);
return 0;
}
r = parse_sec(rvalue, &t);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (t <= 0 || t > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
c->rtt = t;
TAKE_PTR(qdisc);
return 0;
}
static const char * const cake_ack_filter_table[_CAKE_ACK_FILTER_MAX] = {
[CAKE_ACK_FILTER_NO] = "no",
[CAKE_ACK_FILTER_YES] = "yes",
[CAKE_ACK_FILTER_AGGRESSIVE] = "aggressive",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING_WITH_BOOLEAN(cake_ack_filter, CakeAckFilter, CAKE_ACK_FILTER_YES);
int config_parse_cake_ack_filter(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
CakeAckFilter ack_filter;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
c = CAKE(qdisc);
if (isempty(rvalue)) {
c->ack_filter = _CAKE_ACK_FILTER_INVALID;
TAKE_PTR(qdisc);
return 0;
}
ack_filter = cake_ack_filter_from_string(rvalue);
if (ack_filter < 0) {
log_syntax(unit, LOG_WARNING, filename, line, ack_filter,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
c->ack_filter = ack_filter;
TAKE_PTR(qdisc);
return 0;
}
const QDiscVTable cake_vtable = {
.object_size = sizeof(CommonApplicationsKeptEnhanced),
.tca_kind = "cake",
.init = cake_init,
.fill_message = cake_fill_message,
};
| 23,012 | 29.889933 | 113 |
c
|
null |
systemd-main/src/network/tc/cake.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#pragma once
#include <linux/pkt_sched.h>
#include "conf-parser.h"
#include "qdisc.h"
typedef enum CakeCompensationMode {
CAKE_COMPENSATION_MODE_NONE = CAKE_ATM_NONE,
CAKE_COMPENSATION_MODE_ATM = CAKE_ATM_ATM,
CAKE_COMPENSATION_MODE_PTM = CAKE_ATM_PTM,
_CAKE_COMPENSATION_MODE_MAX,
_CAKE_COMPENSATION_MODE_INVALID = -EINVAL,
} CakeCompensationMode;
typedef enum CakeFlowIsolationMode {
CAKE_FLOW_ISOLATION_MODE_NONE = CAKE_FLOW_NONE,
CAKE_FLOW_ISOLATION_MODE_SRC_IP = CAKE_FLOW_SRC_IP,
CAKE_FLOW_ISOLATION_MODE_DST_IP = CAKE_FLOW_DST_IP,
CAKE_FLOW_ISOLATION_MODE_HOSTS = CAKE_FLOW_HOSTS,
CAKE_FLOW_ISOLATION_MODE_FLOWS = CAKE_FLOW_FLOWS,
CAKE_FLOW_ISOLATION_MODE_DUAL_SRC = CAKE_FLOW_DUAL_SRC,
CAKE_FLOW_ISOLATION_MODE_DUAL_DST = CAKE_FLOW_DUAL_DST,
CAKE_FLOW_ISOLATION_MODE_TRIPLE = CAKE_FLOW_TRIPLE,
_CAKE_FLOW_ISOLATION_MODE_MAX,
_CAKE_FLOW_ISOLATION_MODE_INVALID = -EINVAL,
} CakeFlowIsolationMode;
typedef enum CakePriorityQueueingPreset {
CAKE_PRESET_DIFFSERV3 = CAKE_DIFFSERV_DIFFSERV3,
CAKE_PRESET_DIFFSERV4 = CAKE_DIFFSERV_DIFFSERV4,
CAKE_PRESET_DIFFSERV8 = CAKE_DIFFSERV_DIFFSERV8,
CAKE_PRESET_BESTEFFORT = CAKE_DIFFSERV_BESTEFFORT,
CAKE_PRESET_PRECEDENCE = CAKE_DIFFSERV_PRECEDENCE,
_CAKE_PRESET_MAX,
_CAKE_PRESET_INVALID = -EINVAL,
} CakePriorityQueueingPreset;
typedef enum CakeAckFilter {
CAKE_ACK_FILTER_NO = CAKE_ACK_NONE,
CAKE_ACK_FILTER_YES = CAKE_ACK_FILTER,
CAKE_ACK_FILTER_AGGRESSIVE = CAKE_ACK_AGGRESSIVE,
_CAKE_ACK_FILTER_MAX,
_CAKE_ACK_FILTER_INVALID = -EINVAL,
} CakeAckFilter;
typedef struct CommonApplicationsKeptEnhanced {
QDisc meta;
/* Shaper parameters */
int autorate;
uint64_t bandwidth;
/* Overhead compensation parameters */
bool overhead_set;
int overhead;
uint32_t mpu;
CakeCompensationMode compensation_mode;
int raw;
/* Flow isolation parameters */
CakeFlowIsolationMode flow_isolation_mode;
int nat;
/* Priority queue parameters */
CakePriorityQueueingPreset preset;
uint32_t fwmark;
/* Other parameters */
int wash;
int split_gso;
usec_t rtt;
CakeAckFilter ack_filter;
} CommonApplicationsKeptEnhanced;
DEFINE_QDISC_CAST(CAKE, CommonApplicationsKeptEnhanced);
extern const QDiscVTable cake_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_cake_bandwidth);
CONFIG_PARSER_PROTOTYPE(config_parse_cake_overhead);
CONFIG_PARSER_PROTOTYPE(config_parse_cake_mpu);
CONFIG_PARSER_PROTOTYPE(config_parse_cake_tristate);
CONFIG_PARSER_PROTOTYPE(config_parse_cake_compensation_mode);
CONFIG_PARSER_PROTOTYPE(config_parse_cake_flow_isolation_mode);
CONFIG_PARSER_PROTOTYPE(config_parse_cake_priority_queueing_preset);
CONFIG_PARSER_PROTOTYPE(config_parse_cake_fwmark);
CONFIG_PARSER_PROTOTYPE(config_parse_cake_rtt);
CONFIG_PARSER_PROTOTYPE(config_parse_cake_ack_filter);
| 3,214 | 34.32967 | 68 |
h
|
null |
systemd-main/src/network/tc/codel.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "qdisc.h"
#include "string-util.h"
static int controlled_delay_init(QDisc *qdisc) {
ControlledDelay *cd;
assert(qdisc);
cd = CODEL(qdisc);
cd->ce_threshold_usec = USEC_INFINITY;
cd->ecn = -1;
return 0;
}
static int controlled_delay_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
ControlledDelay *cd;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(cd = CODEL(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "codel");
if (r < 0)
return r;
if (cd->packet_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_CODEL_LIMIT, cd->packet_limit);
if (r < 0)
return r;
}
if (cd->interval_usec > 0) {
r = sd_netlink_message_append_u32(req, TCA_CODEL_INTERVAL, cd->interval_usec);
if (r < 0)
return r;
}
if (cd->target_usec > 0) {
r = sd_netlink_message_append_u32(req, TCA_CODEL_TARGET, cd->target_usec);
if (r < 0)
return r;
}
if (cd->ecn >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CODEL_ECN, cd->ecn);
if (r < 0)
return r;
}
if (cd->ce_threshold_usec != USEC_INFINITY) {
r = sd_netlink_message_append_u32(req, TCA_CODEL_CE_THRESHOLD, cd->ce_threshold_usec);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_controlled_delay_u32(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
ControlledDelay *cd;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
cd = CODEL(qdisc);
if (isempty(rvalue)) {
cd->packet_limit = 0;
qdisc = NULL;
return 0;
}
r = safe_atou32(rvalue, &cd->packet_limit);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
qdisc = NULL;
return 0;
}
int config_parse_controlled_delay_usec(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
ControlledDelay *cd;
Network *network = ASSERT_PTR(data);
usec_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
cd = CODEL(qdisc);
if (streq(lvalue, "TargetSec"))
p = &cd->target_usec;
else if (streq(lvalue, "IntervalSec"))
p = &cd->interval_usec;
else if (streq(lvalue, "CEThresholdSec"))
p = &cd->ce_threshold_usec;
else
assert_not_reached();
if (isempty(rvalue)) {
if (streq(lvalue, "CEThresholdSec"))
*p = USEC_INFINITY;
else
*p = 0;
qdisc = NULL;
return 0;
}
r = parse_sec(rvalue, p);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
qdisc = NULL;
return 0;
}
int config_parse_controlled_delay_bool(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
ControlledDelay *cd;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
cd = CODEL(qdisc);
if (isempty(rvalue)) {
cd->ecn = -1;
qdisc = NULL;
return 0;
}
r = parse_boolean(rvalue);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
cd->ecn = r;
qdisc = NULL;
return 0;
}
const QDiscVTable codel_vtable = {
.object_size = sizeof(ControlledDelay),
.tca_kind = "codel",
.init = controlled_delay_init,
.fill_message = controlled_delay_fill_message,
};
| 7,072 | 26.956522 | 102 |
c
|
null |
systemd-main/src/network/tc/codel.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "qdisc.h"
#include "time-util.h"
typedef struct ControlledDelay {
QDisc meta;
uint32_t packet_limit;
usec_t interval_usec;
usec_t target_usec;
usec_t ce_threshold_usec;
int ecn;
} ControlledDelay;
DEFINE_QDISC_CAST(CODEL, ControlledDelay);
extern const QDiscVTable codel_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_controlled_delay_u32);
CONFIG_PARSER_PROTOTYPE(config_parse_controlled_delay_usec);
CONFIG_PARSER_PROTOTYPE(config_parse_controlled_delay_bool);
| 643 | 24.76 | 60 |
h
|
null |
systemd-main/src/network/tc/drr.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "drr.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "string-util.h"
const QDiscVTable drr_vtable = {
.object_size = sizeof(DeficitRoundRobinScheduler),
.tca_kind = "drr",
};
static int drr_class_fill_message(Link *link, TClass *tclass, sd_netlink_message *req) {
DeficitRoundRobinSchedulerClass *drr;
int r;
assert(link);
assert(tclass);
assert(req);
assert_se(drr = TCLASS_TO_DRR(tclass));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "drr");
if (r < 0)
return r;
if (drr->quantum > 0) {
r = sd_netlink_message_append_u32(req, TCA_DRR_QUANTUM, drr->quantum);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_drr_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
DeficitRoundRobinSchedulerClass *drr;
Network *network = ASSERT_PTR(data);
uint64_t u;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = tclass_new_static(TCLASS_KIND_DRR, network, filename, section_line, &tclass);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to create traffic control class, ignoring assignment: %m");
return 0;
}
drr = TCLASS_TO_DRR(tclass);
if (isempty(rvalue)) {
drr->quantum = 0;
TAKE_PTR(tclass);
return 0;
}
r = parse_size(rvalue, 1024, &u);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (u > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
drr->quantum = (uint32_t) u;
TAKE_PTR(tclass);
return 0;
}
const TClassVTable drr_tclass_vtable = {
.object_size = sizeof(DeficitRoundRobinSchedulerClass),
.tca_kind = "drr",
.fill_message = drr_class_fill_message,
};
| 3,035 | 26.853211 | 106 |
c
|
null |
systemd-main/src/network/tc/drr.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#pragma once
#include "qdisc.h"
typedef struct DeficitRoundRobinScheduler {
QDisc meta;
} DeficitRoundRobinScheduler;
DEFINE_QDISC_CAST(DRR, DeficitRoundRobinScheduler);
extern const QDiscVTable drr_vtable;
typedef struct DeficitRoundRobinSchedulerClass {
TClass meta;
uint32_t quantum;
} DeficitRoundRobinSchedulerClass;
DEFINE_TCLASS_CAST(DRR, DeficitRoundRobinSchedulerClass);
extern const TClassVTable drr_tclass_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_drr_size);
| 586 | 23.458333 | 57 |
h
|
null |
systemd-main/src/network/tc/ets.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "ets.h"
#include "extract-word.h"
#include "memory-util.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "qdisc.h"
#include "string-util.h"
#include "tc-util.h"
static int enhanced_transmission_selection_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
EnhancedTransmissionSelection *ets;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(ets = ETS(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "ets");
if (r < 0)
return r;
r = sd_netlink_message_append_u8(req, TCA_ETS_NBANDS, ets->n_bands);
if (r < 0)
return r;
if (ets->n_strict > 0) {
r = sd_netlink_message_append_u8(req, TCA_ETS_NSTRICT, ets->n_strict);
if (r < 0)
return r;
}
if (ets->n_quanta > 0) {
r = sd_netlink_message_open_container(req, TCA_ETS_QUANTA);
if (r < 0)
return r;
for (unsigned i = 0; i < ets->n_quanta; i++) {
r = sd_netlink_message_append_u32(req, TCA_ETS_QUANTA_BAND, ets->quanta[i]);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
}
if (ets->n_prio > 0) {
r = sd_netlink_message_open_container(req, TCA_ETS_PRIOMAP);
if (r < 0)
return r;
for (unsigned i = 0; i < ets->n_prio; i++) {
r = sd_netlink_message_append_u8(req, TCA_ETS_PRIOMAP_BAND, ets->prio[i]);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_ets_u8(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
EnhancedTransmissionSelection *ets;
Network *network = ASSERT_PTR(data);
uint8_t v, *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_ETS, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
ets = ETS(qdisc);
if (streq(lvalue, "Bands"))
p = &ets->n_bands;
else if (streq(lvalue, "StrictBands"))
p = &ets->n_strict;
else
assert_not_reached();
if (isempty(rvalue)) {
*p = 0;
qdisc = NULL;
return 0;
}
r = safe_atou8(rvalue, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (v > TCQ_ETS_MAX_BANDS) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s='. The value must be <= %d, ignoring assignment: %s",
lvalue, TCQ_ETS_MAX_BANDS, rvalue);
return 0;
}
*p = v;
qdisc = NULL;
return 0;
}
int config_parse_ets_quanta(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
EnhancedTransmissionSelection *ets;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_ETS, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
ets = ETS(qdisc);
if (isempty(rvalue)) {
memzero(ets->quanta, sizeof(uint32_t) * TCQ_ETS_MAX_BANDS);
ets->n_quanta = 0;
qdisc = NULL;
return 0;
}
for (const char *p = rvalue;;) {
_cleanup_free_ char *word = NULL;
uint64_t v;
r = extract_first_word(&p, &word, NULL, 0);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to extract next value, ignoring: %m");
break;
}
if (r == 0)
break;
r = parse_size(word, 1024, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, word);
continue;
}
if (v == 0 || v > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, word);
continue;
}
if (ets->n_quanta >= TCQ_ETS_MAX_BANDS) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Too many quanta in '%s=', ignoring assignment: %s",
lvalue, word);
continue;
}
ets->quanta[ets->n_quanta++] = v;
}
qdisc = NULL;
return 0;
}
int config_parse_ets_prio(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
EnhancedTransmissionSelection *ets;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_ETS, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
ets = ETS(qdisc);
if (isempty(rvalue)) {
memzero(ets->prio, sizeof(uint8_t) * (TC_PRIO_MAX + 1));
ets->n_prio = 0;
qdisc = NULL;
return 0;
}
for (const char *p = rvalue;;) {
_cleanup_free_ char *word = NULL;
uint8_t v;
r = extract_first_word(&p, &word, NULL, 0);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to extract next value, ignoring: %m");
break;
}
if (r == 0)
break;
r = safe_atou8(word, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, word);
continue;
}
if (ets->n_prio > TC_PRIO_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Too many priomap in '%s=', ignoring assignment: %s",
lvalue, word);
continue;
}
ets->prio[ets->n_prio++] = v;
}
qdisc = NULL;
return 0;
}
static int enhanced_transmission_selection_verify(QDisc *qdisc) {
EnhancedTransmissionSelection *ets;
assert(qdisc);
ets = ETS(qdisc);
if (ets->n_bands == 0)
ets->n_bands = ets->n_strict + ets->n_quanta;
if (ets->n_bands == 0)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: At least one of Band=, Strict=, or Quanta= must be specified. "
"Ignoring [EnhancedTransmissionSelection] section from line %u.",
qdisc->section->filename, qdisc->section->line);
if (ets->n_bands < ets->n_strict + ets->n_quanta)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: Not enough total bands to cover all the strict bands and quanta. "
"Ignoring [EnhancedTransmissionSelection] section from line %u.",
qdisc->section->filename, qdisc->section->line);
for (unsigned i = 0; i < ets->n_prio; i++)
if (ets->prio[i] >= ets->n_bands)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: PriorityMap= element is out of bands. "
"Ignoring [EnhancedTransmissionSelection] section from line %u.",
qdisc->section->filename, qdisc->section->line);
return 0;
}
const QDiscVTable ets_vtable = {
.object_size = sizeof(EnhancedTransmissionSelection),
.tca_kind = "ets",
.fill_message = enhanced_transmission_selection_fill_message,
.verify = enhanced_transmission_selection_verify,
};
| 11,460 | 32.413994 | 114 |
c
|
null |
systemd-main/src/network/tc/ets.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <linux/pkt_sched.h>
#include "conf-parser.h"
#include "qdisc.h"
typedef struct EnhancedTransmissionSelection {
QDisc meta;
uint8_t n_bands;
uint8_t n_strict;
unsigned n_quanta;
uint32_t quanta[TCQ_ETS_MAX_BANDS];
unsigned n_prio;
uint8_t prio[TC_PRIO_MAX + 1];
} EnhancedTransmissionSelection;
DEFINE_QDISC_CAST(ETS, EnhancedTransmissionSelection);
extern const QDiscVTable ets_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_ets_u8);
CONFIG_PARSER_PROTOTYPE(config_parse_ets_quanta);
CONFIG_PARSER_PROTOTYPE(config_parse_ets_prio);
| 663 | 24.538462 | 54 |
h
|
null |
systemd-main/src/network/tc/fifo.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "fifo.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "string-util.h"
static int fifo_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
FirstInFirstOut *fifo;
int r;
assert(link);
assert(qdisc);
assert(req);
switch (qdisc->kind) {
case QDISC_KIND_PFIFO:
assert_se(fifo = PFIFO(qdisc));
break;
case QDISC_KIND_BFIFO:
assert_se(fifo = BFIFO(qdisc));
break;
case QDISC_KIND_PFIFO_HEAD_DROP:
assert_se(fifo = PFIFO_HEAD_DROP(qdisc));
break;
default:
assert_not_reached();
}
const struct tc_fifo_qopt opt = { .limit = fifo->limit };
r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(opt));
if (r < 0)
return r;
return 0;
}
int config_parse_pfifo_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
FirstInFirstOut *fifo;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
switch (qdisc->kind) {
case QDISC_KIND_PFIFO:
fifo = PFIFO(qdisc);
break;
case QDISC_KIND_PFIFO_HEAD_DROP:
fifo = PFIFO_HEAD_DROP(qdisc);
break;
default:
assert_not_reached();
}
if (isempty(rvalue)) {
fifo->limit = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32(rvalue, &fifo->limit);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
int config_parse_bfifo_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
FirstInFirstOut *fifo;
uint64_t u;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_BFIFO, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fifo = BFIFO(qdisc);
if (isempty(rvalue)) {
fifo->limit = 0;
TAKE_PTR(qdisc);
return 0;
}
r = parse_size(rvalue, 1024, &u);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (u > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
fifo->limit = (uint32_t) u;
TAKE_PTR(qdisc);
return 0;
}
const QDiscVTable pfifo_vtable = {
.object_size = sizeof(FirstInFirstOut),
.tca_kind = "pfifo",
.fill_message = fifo_fill_message,
};
const QDiscVTable bfifo_vtable = {
.object_size = sizeof(FirstInFirstOut),
.tca_kind = "bfifo",
.fill_message = fifo_fill_message,
};
const QDiscVTable pfifo_head_drop_vtable = {
.object_size = sizeof(FirstInFirstOut),
.tca_kind = "pfifo_head_drop",
.fill_message = fifo_fill_message,
};
const QDiscVTable pfifo_fast_vtable = {
.object_size = sizeof(FirstInFirstOut),
.tca_kind = "pfifo_fast",
};
| 5,182 | 27.168478 | 106 |
c
|
null |
systemd-main/src/network/tc/fifo.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "qdisc.h"
typedef struct FirstInFirstOut {
QDisc meta;
uint32_t limit;
} FirstInFirstOut;
DEFINE_QDISC_CAST(PFIFO, FirstInFirstOut);
DEFINE_QDISC_CAST(BFIFO, FirstInFirstOut);
DEFINE_QDISC_CAST(PFIFO_HEAD_DROP, FirstInFirstOut);
DEFINE_QDISC_CAST(PFIFO_FAST, FirstInFirstOut);
extern const QDiscVTable pfifo_vtable;
extern const QDiscVTable bfifo_vtable;
extern const QDiscVTable pfifo_head_drop_vtable;
extern const QDiscVTable pfifo_fast_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_pfifo_size);
CONFIG_PARSER_PROTOTYPE(config_parse_bfifo_size);
| 699 | 25.923077 | 52 |
h
|
null |
systemd-main/src/network/tc/fq-codel.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "qdisc.h"
#include "string-util.h"
#include "strv.h"
static int fair_queueing_controlled_delay_init(QDisc *qdisc) {
FairQueueingControlledDelay *fqcd;
assert(qdisc);
fqcd = FQ_CODEL(qdisc);
fqcd->memory_limit = UINT32_MAX;
fqcd->ce_threshold_usec = USEC_INFINITY;
fqcd->ecn = -1;
return 0;
}
static int fair_queueing_controlled_delay_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
FairQueueingControlledDelay *fqcd;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(fqcd = FQ_CODEL(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "fq_codel");
if (r < 0)
return r;
if (fqcd->packet_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_LIMIT, fqcd->packet_limit);
if (r < 0)
return r;
}
if (fqcd->flows > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_FLOWS, fqcd->flows);
if (r < 0)
return r;
}
if (fqcd->quantum > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_QUANTUM, fqcd->quantum);
if (r < 0)
return r;
}
if (fqcd->interval_usec > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_INTERVAL, fqcd->interval_usec);
if (r < 0)
return r;
}
if (fqcd->target_usec > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_TARGET, fqcd->target_usec);
if (r < 0)
return r;
}
if (fqcd->ecn >= 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_ECN, fqcd->ecn);
if (r < 0)
return r;
}
if (fqcd->ce_threshold_usec != USEC_INFINITY) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_CE_THRESHOLD, fqcd->ce_threshold_usec);
if (r < 0)
return r;
}
if (fqcd->memory_limit != UINT32_MAX) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_MEMORY_LIMIT, fqcd->memory_limit);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_fair_queueing_controlled_delay_u32(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueingControlledDelay *fqcd;
Network *network = ASSERT_PTR(data);
uint32_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fqcd = FQ_CODEL(qdisc);
if (streq(lvalue, "PacketLimit"))
p = &fqcd->packet_limit;
else if (streq(lvalue, "Flows"))
p = &fqcd->flows;
else
assert_not_reached();
if (isempty(rvalue)) {
*p = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32(rvalue, p);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
int config_parse_fair_queueing_controlled_delay_usec(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueingControlledDelay *fqcd;
Network *network = ASSERT_PTR(data);
usec_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fqcd = FQ_CODEL(qdisc);
if (streq(lvalue, "TargetSec"))
p = &fqcd->target_usec;
else if (streq(lvalue, "IntervalSec"))
p = &fqcd->interval_usec;
else if (streq(lvalue, "CEThresholdSec"))
p = &fqcd->ce_threshold_usec;
else
assert_not_reached();
if (isempty(rvalue)) {
if (streq(lvalue, "CEThresholdSec"))
*p = USEC_INFINITY;
else
*p = 0;
TAKE_PTR(qdisc);
return 0;
}
r = parse_sec(rvalue, p);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
int config_parse_fair_queueing_controlled_delay_bool(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueingControlledDelay *fqcd;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fqcd = FQ_CODEL(qdisc);
if (isempty(rvalue)) {
fqcd->ecn = -1;
TAKE_PTR(qdisc);
return 0;
}
r = parse_boolean(rvalue);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
fqcd->ecn = r;
TAKE_PTR(qdisc);
return 0;
}
int config_parse_fair_queueing_controlled_delay_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueingControlledDelay *fqcd;
Network *network = ASSERT_PTR(data);
uint64_t sz;
uint32_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fqcd = FQ_CODEL(qdisc);
if (STR_IN_SET(lvalue, "MemoryLimitBytes", "MemoryLimit"))
p = &fqcd->memory_limit;
else if (STR_IN_SET(lvalue, "QuantumBytes", "Quantum"))
p = &fqcd->quantum;
else
assert_not_reached();
if (isempty(rvalue)) {
if (STR_IN_SET(lvalue, "MemoryLimitBytes", "MemoryLimit"))
*p = UINT32_MAX;
else
*p = 0;
TAKE_PTR(qdisc);
return 0;
}
r = parse_size(rvalue, 1024, &sz);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (sz >= UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Specified '%s=' is too large, ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
*p = sz;
TAKE_PTR(qdisc);
return 0;
}
const QDiscVTable fq_codel_vtable = {
.object_size = sizeof(FairQueueingControlledDelay),
.tca_kind = "fq_codel",
.init = fair_queueing_controlled_delay_init,
.fill_message = fair_queueing_controlled_delay_fill_message,
};
| 10,467 | 28.738636 | 107 |
c
|
null |
systemd-main/src/network/tc/fq-codel.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "qdisc.h"
#include "time-util.h"
typedef struct FairQueueingControlledDelay {
QDisc meta;
uint32_t packet_limit;
uint32_t flows;
uint32_t quantum;
uint32_t memory_limit;
usec_t target_usec;
usec_t interval_usec;
usec_t ce_threshold_usec;
int ecn;
} FairQueueingControlledDelay;
DEFINE_QDISC_CAST(FQ_CODEL, FairQueueingControlledDelay);
extern const QDiscVTable fq_codel_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_fair_queueing_controlled_delay_u32);
CONFIG_PARSER_PROTOTYPE(config_parse_fair_queueing_controlled_delay_usec);
CONFIG_PARSER_PROTOTYPE(config_parse_fair_queueing_controlled_delay_bool);
CONFIG_PARSER_PROTOTYPE(config_parse_fair_queueing_controlled_delay_size);
| 883 | 29.482759 | 74 |
h
|
null |
systemd-main/src/network/tc/fq-pie.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "fq-pie.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "string-util.h"
static int fq_pie_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
FlowQueuePIE *fq_pie;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(fq_pie = FQ_PIE(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "fq_pie");
if (r < 0)
return r;
if (fq_pie->packet_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_PIE_LIMIT, fq_pie->packet_limit);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_fq_pie_packet_limit(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FlowQueuePIE *fq_pie;
Network *network = ASSERT_PTR(data);
uint32_t val;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ_PIE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0)
return log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
fq_pie = FQ_PIE(qdisc);
if (isempty(rvalue)) {
fq_pie->packet_limit = 0;
qdisc = NULL;
return 0;
}
r = safe_atou32(rvalue, &val);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (val == 0) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
fq_pie->packet_limit = val;
qdisc = NULL;
return 0;
}
const QDiscVTable fq_pie_vtable = {
.object_size = sizeof(FlowQueuePIE),
.tca_kind = "fq_pie",
.fill_message = fq_pie_fill_message,
};
| 2,869 | 26.864078 | 104 |
c
|
null |
systemd-main/src/network/tc/fq.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "fq.h"
#include "logarithm.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "string-util.h"
#include "strv.h"
static int fair_queueing_init(QDisc *qdisc) {
FairQueueing *fq;
assert(qdisc);
fq = FQ(qdisc);
fq->pacing = -1;
fq->ce_threshold_usec = USEC_INFINITY;
return 0;
}
static int fair_queueing_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
FairQueueing *fq;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(fq = FQ(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "fq");
if (r < 0)
return r;
if (fq->packet_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_PLIMIT, fq->packet_limit);
if (r < 0)
return r;
}
if (fq->flow_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_FLOW_PLIMIT, fq->flow_limit);
if (r < 0)
return r;
}
if (fq->quantum > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_QUANTUM, fq->quantum);
if (r < 0)
return r;
}
if (fq->initial_quantum > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_INITIAL_QUANTUM, fq->initial_quantum);
if (r < 0)
return r;
}
if (fq->pacing >= 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_RATE_ENABLE, fq->pacing);
if (r < 0)
return r;
}
if (fq->max_rate > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_FLOW_MAX_RATE, fq->max_rate);
if (r < 0)
return r;
}
if (fq->buckets > 0) {
uint32_t l;
l = log2u(fq->buckets);
r = sd_netlink_message_append_u32(req, TCA_FQ_BUCKETS_LOG, l);
if (r < 0)
return r;
}
if (fq->orphan_mask > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_ORPHAN_MASK, fq->orphan_mask);
if (r < 0)
return r;
}
if (fq->ce_threshold_usec != USEC_INFINITY) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CE_THRESHOLD, fq->ce_threshold_usec);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_fair_queueing_u32(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
Network *network = ASSERT_PTR(data);
uint32_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fq = FQ(qdisc);
if (streq(lvalue, "PacketLimit"))
p = &fq->packet_limit;
else if (streq(lvalue, "FlowLimit"))
p = &fq->flow_limit;
else if (streq(lvalue, "Buckets"))
p = &fq->buckets;
else if (streq(lvalue, "OrphanMask"))
p = &fq->orphan_mask;
else
assert_not_reached();
if (isempty(rvalue)) {
*p = 0;
qdisc = NULL;
return 0;
}
r = safe_atou32(rvalue, p);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
qdisc = NULL;
return 0;
}
int config_parse_fair_queueing_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
Network *network = ASSERT_PTR(data);
uint64_t sz;
uint32_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fq = FQ(qdisc);
if (STR_IN_SET(lvalue, "QuantumBytes", "Quantum"))
p = &fq->quantum;
else if (STR_IN_SET(lvalue, "InitialQuantumBytes", "InitialQuantum"))
p = &fq->initial_quantum;
else
assert_not_reached();
if (isempty(rvalue)) {
*p = 0;
qdisc = NULL;
return 0;
}
r = parse_size(rvalue, 1024, &sz);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (sz > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Specified '%s=' is too large, ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
*p = sz;
qdisc = NULL;
return 0;
}
int config_parse_fair_queueing_bool(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fq = FQ(qdisc);
if (isempty(rvalue)) {
fq->pacing = -1;
qdisc = NULL;
return 0;
}
r = parse_boolean(rvalue);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
fq->pacing = r;
qdisc = NULL;
return 0;
}
int config_parse_fair_queueing_usec(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
Network *network = ASSERT_PTR(data);
usec_t sec;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fq = FQ(qdisc);
if (isempty(rvalue)) {
fq->ce_threshold_usec = USEC_INFINITY;
qdisc = NULL;
return 0;
}
r = parse_sec(rvalue, &sec);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (sec > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Specified '%s=' is too large, ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
fq->ce_threshold_usec = sec;
qdisc = NULL;
return 0;
}
int config_parse_fair_queueing_max_rate(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
Network *network = ASSERT_PTR(data);
uint64_t sz;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
fq = FQ(qdisc);
if (isempty(rvalue)) {
fq->max_rate = 0;
qdisc = NULL;
return 0;
}
r = parse_size(rvalue, 1000, &sz);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (sz / 8 > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Specified '%s=' is too large, ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
fq->max_rate = sz / 8;
qdisc = NULL;
return 0;
}
const QDiscVTable fq_vtable = {
.init = fair_queueing_init,
.object_size = sizeof(FairQueueing),
.tca_kind = "fq",
.fill_message = fair_queueing_fill_message,
};
| 11,979 | 27.729017 | 100 |
c
|
null |
systemd-main/src/network/tc/fq.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "qdisc.h"
typedef struct FairQueueing {
QDisc meta;
uint32_t packet_limit;
uint32_t flow_limit;
uint32_t quantum;
uint32_t initial_quantum;
uint32_t max_rate;
uint32_t buckets;
uint32_t orphan_mask;
int pacing;
usec_t ce_threshold_usec;
} FairQueueing;
DEFINE_QDISC_CAST(FQ, FairQueueing);
extern const QDiscVTable fq_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_fair_queueing_u32);
CONFIG_PARSER_PROTOTYPE(config_parse_fair_queueing_size);
CONFIG_PARSER_PROTOTYPE(config_parse_fair_queueing_bool);
CONFIG_PARSER_PROTOTYPE(config_parse_fair_queueing_usec);
CONFIG_PARSER_PROTOTYPE(config_parse_fair_queueing_max_rate);
| 833 | 26.8 | 61 |
h
|
null |
systemd-main/src/network/tc/gred.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "qdisc.h"
#include "string-util.h"
static int generic_random_early_detection_init(QDisc *qdisc) {
GenericRandomEarlyDetection *gred;
assert(qdisc);
gred = GRED(qdisc);
gred->grio = -1;
return 0;
}
static int generic_random_early_detection_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
GenericRandomEarlyDetection *gred;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(gred = GRED(qdisc));
const struct tc_gred_sopt opt = {
.DPs = gred->virtual_queues,
.def_DP = gred->default_virtual_queue,
.grio = gred->grio,
};
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "gred");
if (r < 0)
return r;
r = sd_netlink_message_append_data(req, TCA_GRED_DPS, &opt, sizeof(opt));
if (r < 0)
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
static int generic_random_early_detection_verify(QDisc *qdisc) {
GenericRandomEarlyDetection *gred = GRED(qdisc);
if (gred->default_virtual_queue >= gred->virtual_queues)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: DefaultVirtualQueue= must be less than VirtualQueues=. "
"Ignoring [GenericRandomEarlyDetection] section from line %u.",
qdisc->section->filename, qdisc->section->line);
return 0;
}
int config_parse_generic_random_early_detection_u32(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
GenericRandomEarlyDetection *gred;
Network *network = ASSERT_PTR(data);
uint32_t *p;
uint32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_GRED, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
gred = GRED(qdisc);
if (streq(lvalue, "VirtualQueues"))
p = &gred->virtual_queues;
else if (streq(lvalue, "DefaultVirtualQueue"))
p = &gred->default_virtual_queue;
else
assert_not_reached();
if (isempty(rvalue)) {
*p = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32(rvalue, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (v > MAX_DPs)
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
*p = v;
TAKE_PTR(qdisc);
return 0;
}
int config_parse_generic_random_early_detection_bool(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
GenericRandomEarlyDetection *gred;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_GRED, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
gred = GRED(qdisc);
if (isempty(rvalue)) {
gred->grio = -1;
TAKE_PTR(qdisc);
return 0;
}
r = parse_boolean(rvalue);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
gred->grio = r;
TAKE_PTR(qdisc);
return 0;
}
const QDiscVTable gred_vtable = {
.object_size = sizeof(GenericRandomEarlyDetection),
.tca_kind = "gred",
.init = generic_random_early_detection_init,
.fill_message = generic_random_early_detection_fill_message,
.verify = generic_random_early_detection_verify,
};
| 5,699 | 28.381443 | 107 |
c
|
null |
systemd-main/src/network/tc/gred.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "qdisc.h"
typedef struct GenericRandomEarlyDetection {
QDisc meta;
uint32_t virtual_queues;
uint32_t default_virtual_queue;
int grio;
} GenericRandomEarlyDetection;
DEFINE_QDISC_CAST(GRED, GenericRandomEarlyDetection);
extern const QDiscVTable gred_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_generic_random_early_detection_u32);
CONFIG_PARSER_PROTOTYPE(config_parse_generic_random_early_detection_bool);
| 572 | 26.285714 | 74 |
h
|
null |
systemd-main/src/network/tc/hhf.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "hhf.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "string-util.h"
static int heavy_hitter_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
HeavyHitterFilter *hhf;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(hhf = HHF(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "hhf");
if (r < 0)
return r;
if (hhf->packet_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_HHF_BACKLOG_LIMIT, hhf->packet_limit);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_heavy_hitter_filter_packet_limit(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
HeavyHitterFilter *hhf;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_HHF, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
hhf = HHF(qdisc);
if (isempty(rvalue)) {
hhf->packet_limit = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32(rvalue, &hhf->packet_limit);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
const QDiscVTable hhf_vtable = {
.object_size = sizeof(HeavyHitterFilter),
.tca_kind = "hhf",
.fill_message = heavy_hitter_filter_fill_message,
};
| 2,633 | 26.154639 | 97 |
c
|
null |
systemd-main/src/network/tc/htb.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "netlink-util.h"
#include "networkd-link.h"
#include "parse-util.h"
#include "qdisc.h"
#include "htb.h"
#include "string-util.h"
#include "tc-util.h"
#define HTB_DEFAULT_RATE_TO_QUANTUM 10
#define HTB_DEFAULT_MTU 1600 /* Ethernet packet length */
static int hierarchy_token_bucket_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
HierarchyTokenBucket *htb;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(htb = HTB(qdisc));
struct tc_htb_glob opt = {
.version = 3,
.rate2quantum = htb->rate_to_quantum,
.defcls = htb->default_class,
};
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "htb");
if (r < 0)
return r;
r = sd_netlink_message_append_data(req, TCA_HTB_INIT, &opt, sizeof(opt));
if (r < 0)
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_hierarchy_token_bucket_default_class(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
HierarchyTokenBucket *htb;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_HTB, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
htb = HTB(qdisc);
if (isempty(rvalue)) {
htb->default_class = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32_full(rvalue, 16, &htb->default_class);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
int config_parse_hierarchy_token_bucket_u32(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
HierarchyTokenBucket *htb;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_HTB, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
htb = HTB(qdisc);
if (isempty(rvalue)) {
htb->rate_to_quantum = HTB_DEFAULT_RATE_TO_QUANTUM;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32(rvalue, &htb->rate_to_quantum);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
static int hierarchy_token_bucket_init(QDisc *qdisc) {
HierarchyTokenBucket *htb;
assert(qdisc);
htb = HTB(qdisc);
htb->rate_to_quantum = HTB_DEFAULT_RATE_TO_QUANTUM;
return 0;
}
const QDiscVTable htb_vtable = {
.object_size = sizeof(HierarchyTokenBucket),
.tca_kind = "htb",
.fill_message = hierarchy_token_bucket_fill_message,
.init = hierarchy_token_bucket_init,
};
static int hierarchy_token_bucket_class_fill_message(Link *link, TClass *tclass, sd_netlink_message *req) {
HierarchyTokenBucketClass *htb;
uint32_t rtab[256], ctab[256];
int r;
assert(link);
assert(tclass);
assert(req);
assert_se(htb = TCLASS_TO_HTB(tclass));
struct tc_htb_opt opt = {
.prio = htb->priority,
.quantum = htb->quantum,
.rate.rate = (htb->rate >= (1ULL << 32)) ? ~0U : htb->rate,
.ceil.rate = (htb->ceil_rate >= (1ULL << 32)) ? ~0U : htb->ceil_rate,
.rate.overhead = htb->overhead,
.ceil.overhead = htb->overhead,
};
r = tc_transmit_time(htb->rate, htb->buffer, &opt.buffer);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to calculate buffer size: %m");
r = tc_transmit_time(htb->ceil_rate, htb->ceil_buffer, &opt.cbuffer);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to calculate ceil buffer size: %m");
r = tc_fill_ratespec_and_table(&opt.rate, rtab, htb->mtu);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to calculate rate table: %m");
r = tc_fill_ratespec_and_table(&opt.ceil, ctab, htb->mtu);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to calculate ceil rate table: %m");
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "htb");
if (r < 0)
return r;
r = sd_netlink_message_append_data(req, TCA_HTB_PARMS, &opt, sizeof(opt));
if (r < 0)
return r;
if (htb->rate >= (1ULL << 32)) {
r = sd_netlink_message_append_u64(req, TCA_HTB_RATE64, htb->rate);
if (r < 0)
return r;
}
if (htb->ceil_rate >= (1ULL << 32)) {
r = sd_netlink_message_append_u64(req, TCA_HTB_CEIL64, htb->ceil_rate);
if (r < 0)
return r;
}
r = sd_netlink_message_append_data(req, TCA_HTB_RTAB, rtab, sizeof(rtab));
if (r < 0)
return r;
r = sd_netlink_message_append_data(req, TCA_HTB_CTAB, ctab, sizeof(ctab));
if (r < 0)
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_hierarchy_token_bucket_class_u32(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
HierarchyTokenBucketClass *htb;
Network *network = ASSERT_PTR(data);
uint32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to create traffic control class, ignoring assignment: %m");
return 0;
}
htb = TCLASS_TO_HTB(tclass);
if (isempty(rvalue)) {
htb->priority = 0;
tclass = NULL;
return 0;
}
r = safe_atou32(rvalue, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
htb->priority = v;
tclass = NULL;
return 0;
}
int config_parse_hierarchy_token_bucket_class_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
HierarchyTokenBucketClass *htb;
Network *network = ASSERT_PTR(data);
uint64_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to create traffic control class, ignoring assignment: %m");
return 0;
}
htb = TCLASS_TO_HTB(tclass);
if (isempty(rvalue)) {
if (streq(lvalue, "QuantumBytes"))
htb->quantum = 0;
else if (streq(lvalue, "MTUBytes"))
htb->mtu = HTB_DEFAULT_MTU;
else if (streq(lvalue, "OverheadBytes"))
htb->overhead = 0;
else if (streq(lvalue, "BufferBytes"))
htb->buffer = 0;
else if (streq(lvalue, "CeilBufferBytes"))
htb->ceil_buffer = 0;
else
assert_not_reached();
tclass = NULL;
return 0;
}
r = parse_size(rvalue, 1024, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if ((streq(lvalue, "OverheadBytes") && v > UINT16_MAX) || v > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (streq(lvalue, "QuantumBytes"))
htb->quantum = v;
else if (streq(lvalue, "OverheadBytes"))
htb->overhead = v;
else if (streq(lvalue, "MTUBytes"))
htb->mtu = v;
else if (streq(lvalue, "BufferBytes"))
htb->buffer = v;
else if (streq(lvalue, "CeilBufferBytes"))
htb->ceil_buffer = v;
else
assert_not_reached();
tclass = NULL;
return 0;
}
int config_parse_hierarchy_token_bucket_class_rate(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
HierarchyTokenBucketClass *htb;
Network *network = ASSERT_PTR(data);
uint64_t *v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to create traffic control class, ignoring assignment: %m");
return 0;
}
htb = TCLASS_TO_HTB(tclass);
if (streq(lvalue, "Rate"))
v = &htb->rate;
else if (streq(lvalue, "CeilRate"))
v = &htb->ceil_rate;
else
assert_not_reached();
if (isempty(rvalue)) {
*v = 0;
tclass = NULL;
return 0;
}
r = parse_size(rvalue, 1000, v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
*v /= 8;
tclass = NULL;
return 0;
}
static int hierarchy_token_bucket_class_init(TClass *tclass) {
HierarchyTokenBucketClass *htb;
assert(tclass);
htb = TCLASS_TO_HTB(tclass);
htb->mtu = HTB_DEFAULT_MTU;
return 0;
}
static int hierarchy_token_bucket_class_verify(TClass *tclass) {
HierarchyTokenBucketClass *htb;
uint32_t hz;
int r;
assert(tclass);
htb = TCLASS_TO_HTB(tclass);
if (htb->rate == 0)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: Rate= is mandatory. "
"Ignoring [HierarchyTokenBucketClass] section from line %u.",
tclass->section->filename, tclass->section->line);
/* if CeilRate= setting is missing, use the same as Rate= */
if (htb->ceil_rate == 0)
htb->ceil_rate = htb->rate;
r = tc_init(NULL, &hz);
if (r < 0)
return log_error_errno(r, "Failed to read /proc/net/psched: %m");
if (htb->buffer == 0)
htb->buffer = htb->rate / hz + htb->mtu;
if (htb->ceil_buffer == 0)
htb->ceil_buffer = htb->ceil_rate / hz + htb->mtu;
return 0;
}
const TClassVTable htb_tclass_vtable = {
.object_size = sizeof(HierarchyTokenBucketClass),
.tca_kind = "htb",
.fill_message = hierarchy_token_bucket_class_fill_message,
.init = hierarchy_token_bucket_class_init,
.verify = hierarchy_token_bucket_class_verify,
};
| 14,874 | 29.481557 | 107 |
c
|
null |
systemd-main/src/network/tc/htb.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "conf-parser.h"
#include "qdisc.h"
#include "tclass.h"
typedef struct HierarchyTokenBucket {
QDisc meta;
uint32_t default_class;
uint32_t rate_to_quantum;
} HierarchyTokenBucket;
DEFINE_QDISC_CAST(HTB, HierarchyTokenBucket);
extern const QDiscVTable htb_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_hierarchy_token_bucket_default_class);
CONFIG_PARSER_PROTOTYPE(config_parse_hierarchy_token_bucket_u32);
typedef struct HierarchyTokenBucketClass {
TClass meta;
uint32_t priority;
uint32_t quantum;
uint32_t mtu;
uint16_t overhead;
uint64_t rate;
uint32_t buffer;
uint64_t ceil_rate;
uint32_t ceil_buffer;
} HierarchyTokenBucketClass;
DEFINE_TCLASS_CAST(HTB, HierarchyTokenBucketClass);
extern const TClassVTable htb_tclass_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_hierarchy_token_bucket_class_u32);
CONFIG_PARSER_PROTOTYPE(config_parse_hierarchy_token_bucket_class_size);
CONFIG_PARSER_PROTOTYPE(config_parse_hierarchy_token_bucket_class_rate);
| 1,124 | 27.125 | 75 |
h
|
null |
systemd-main/src/network/tc/netem.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "netem.h"
#include "netlink-util.h"
#include "networkd-manager.h"
#include "parse-util.h"
#include "qdisc.h"
#include "strv.h"
#include "tc-util.h"
static int network_emulator_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
NetworkEmulator *ne;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(ne = NETEM(qdisc));
struct tc_netem_qopt opt = {
.limit = ne->limit > 0 ? ne->limit : 1000,
.loss = ne->loss,
.duplicate = ne->duplicate,
};
if (ne->delay != USEC_INFINITY) {
r = tc_time_to_tick(ne->delay, &opt.latency);
if (r < 0)
return log_link_error_errno(link, r, "Failed to calculate latency in TCA_OPTION: %m");
}
if (ne->jitter != USEC_INFINITY) {
r = tc_time_to_tick(ne->jitter, &opt.jitter);
if (r < 0)
return log_link_error_errno(link, r, "Failed to calculate jitter in TCA_OPTION: %m");
}
r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(opt));
if (r < 0)
return r;
return 0;
}
int config_parse_network_emulator_delay(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
NetworkEmulator *ne;
usec_t u;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_NETEM, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
ne = NETEM(qdisc);
if (isempty(rvalue)) {
if (STR_IN_SET(lvalue, "DelaySec", "NetworkEmulatorDelaySec"))
ne->delay = USEC_INFINITY;
else if (STR_IN_SET(lvalue, "DelayJitterSec", "NetworkEmulatorDelayJitterSec"))
ne->jitter = USEC_INFINITY;
TAKE_PTR(qdisc);
return 0;
}
r = parse_sec(rvalue, &u);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (STR_IN_SET(lvalue, "DelaySec", "NetworkEmulatorDelaySec"))
ne->delay = u;
else if (STR_IN_SET(lvalue, "DelayJitterSec", "NetworkEmulatorDelayJitterSec"))
ne->jitter = u;
TAKE_PTR(qdisc);
return 0;
}
int config_parse_network_emulator_rate(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
NetworkEmulator *ne;
uint32_t rate;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_NETEM, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
ne = NETEM(qdisc);
if (isempty(rvalue)) {
if (STR_IN_SET(lvalue, "LossRate", "NetworkEmulatorLossRate"))
ne->loss = 0;
else if (STR_IN_SET(lvalue, "DuplicateRate", "NetworkEmulatorDuplicateRate"))
ne->duplicate = 0;
TAKE_PTR(qdisc);
return 0;
}
r = parse_tc_percent(rvalue, &rate);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (STR_IN_SET(lvalue, "LossRate", "NetworkEmulatorLossRate"))
ne->loss = rate;
else if (STR_IN_SET(lvalue, "DuplicateRate", "NetworkEmulatorDuplicateRate"))
ne->duplicate = rate;
TAKE_PTR(qdisc);
return 0;
}
int config_parse_network_emulator_packet_limit(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
NetworkEmulator *ne;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_NETEM, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
ne = NETEM(qdisc);
if (isempty(rvalue)) {
ne->limit = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou(rvalue, &ne->limit);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
const QDiscVTable netem_vtable = {
.object_size = sizeof(NetworkEmulator),
.tca_kind = "netem",
.fill_message = network_emulator_fill_message,
};
| 6,973 | 29.587719 | 110 |
c
|
null |
systemd-main/src/network/tc/netem.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "qdisc.h"
#include "time-util.h"
typedef struct NetworkEmulator {
QDisc meta;
usec_t delay;
usec_t jitter;
uint32_t limit;
uint32_t loss;
uint32_t duplicate;
} NetworkEmulator;
DEFINE_QDISC_CAST(NETEM, NetworkEmulator);
extern const QDiscVTable netem_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_network_emulator_delay);
CONFIG_PARSER_PROTOTYPE(config_parse_network_emulator_rate);
CONFIG_PARSER_PROTOTYPE(config_parse_network_emulator_packet_limit);
| 634 | 23.423077 | 68 |
h
|
null |
systemd-main/src/network/tc/pie.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "pie.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "string-util.h"
static int pie_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
ProportionalIntegralControllerEnhanced *pie;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(pie = PIE(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "pie");
if (r < 0)
return r;
if (pie->packet_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_PIE_LIMIT, pie->packet_limit);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_pie_packet_limit(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
ProportionalIntegralControllerEnhanced *pie;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_PIE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
pie = PIE(qdisc);
if (isempty(rvalue)) {
pie->packet_limit = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32(rvalue, &pie->packet_limit);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
const QDiscVTable pie_vtable = {
.object_size = sizeof(ProportionalIntegralControllerEnhanced),
.tca_kind = "pie",
.fill_message = pie_fill_message,
};
| 2,641 | 26.237113 | 97 |
c
|
null |
systemd-main/src/network/tc/qdisc.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "in-addr-util.h"
#include "netlink-util.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-network.h"
#include "networkd-queue.h"
#include "parse-util.h"
#include "qdisc.h"
#include "set.h"
#include "string-util.h"
#include "strv.h"
#include "tc-util.h"
const QDiscVTable * const qdisc_vtable[_QDISC_KIND_MAX] = {
[QDISC_KIND_BFIFO] = &bfifo_vtable,
[QDISC_KIND_CAKE] = &cake_vtable,
[QDISC_KIND_CODEL] = &codel_vtable,
[QDISC_KIND_DRR] = &drr_vtable,
[QDISC_KIND_ETS] = &ets_vtable,
[QDISC_KIND_FQ] = &fq_vtable,
[QDISC_KIND_FQ_CODEL] = &fq_codel_vtable,
[QDISC_KIND_FQ_PIE] = &fq_pie_vtable,
[QDISC_KIND_GRED] = &gred_vtable,
[QDISC_KIND_HHF] = &hhf_vtable,
[QDISC_KIND_HTB] = &htb_vtable,
[QDISC_KIND_NETEM] = &netem_vtable,
[QDISC_KIND_PIE] = &pie_vtable,
[QDISC_KIND_QFQ] = &qfq_vtable,
[QDISC_KIND_PFIFO] = &pfifo_vtable,
[QDISC_KIND_PFIFO_FAST] = &pfifo_fast_vtable,
[QDISC_KIND_PFIFO_HEAD_DROP] = &pfifo_head_drop_vtable,
[QDISC_KIND_SFB] = &sfb_vtable,
[QDISC_KIND_SFQ] = &sfq_vtable,
[QDISC_KIND_TBF] = &tbf_vtable,
[QDISC_KIND_TEQL] = &teql_vtable,
};
static int qdisc_new(QDiscKind kind, QDisc **ret) {
_cleanup_(qdisc_freep) QDisc *qdisc = NULL;
int r;
if (kind == _QDISC_KIND_INVALID) {
qdisc = new(QDisc, 1);
if (!qdisc)
return -ENOMEM;
*qdisc = (QDisc) {
.parent = TC_H_ROOT,
.kind = kind,
};
} else {
assert(kind >= 0 && kind < _QDISC_KIND_MAX);
qdisc = malloc0(qdisc_vtable[kind]->object_size);
if (!qdisc)
return -ENOMEM;
qdisc->parent = TC_H_ROOT;
qdisc->kind = kind;
if (QDISC_VTABLE(qdisc)->init) {
r = QDISC_VTABLE(qdisc)->init(qdisc);
if (r < 0)
return r;
}
}
*ret = TAKE_PTR(qdisc);
return 0;
}
int qdisc_new_static(QDiscKind kind, Network *network, const char *filename, unsigned section_line, QDisc **ret) {
_cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(qdisc_freep) QDisc *qdisc = NULL;
QDisc *existing;
int r;
assert(network);
assert(ret);
assert(filename);
assert(section_line > 0);
r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
existing = hashmap_get(network->qdiscs_by_section, n);
if (existing) {
if (existing->kind != _QDISC_KIND_INVALID &&
kind != _QDISC_KIND_INVALID &&
existing->kind != kind)
return -EINVAL;
if (existing->kind == kind || kind == _QDISC_KIND_INVALID) {
*ret = existing;
return 0;
}
}
r = qdisc_new(kind, &qdisc);
if (r < 0)
return r;
if (existing) {
qdisc->handle = existing->handle;
qdisc->parent = existing->parent;
qdisc->tca_kind = TAKE_PTR(existing->tca_kind);
qdisc_free(existing);
}
qdisc->network = network;
qdisc->section = TAKE_PTR(n);
qdisc->source = NETWORK_CONFIG_SOURCE_STATIC;
r = hashmap_ensure_put(&network->qdiscs_by_section, &config_section_hash_ops, qdisc->section, qdisc);
if (r < 0)
return r;
*ret = TAKE_PTR(qdisc);
return 0;
}
QDisc* qdisc_free(QDisc *qdisc) {
if (!qdisc)
return NULL;
if (qdisc->network && qdisc->section)
hashmap_remove(qdisc->network->qdiscs_by_section, qdisc->section);
config_section_free(qdisc->section);
if (qdisc->link)
set_remove(qdisc->link->qdiscs, qdisc);
free(qdisc->tca_kind);
return mfree(qdisc);
}
static const char *qdisc_get_tca_kind(const QDisc *qdisc) {
assert(qdisc);
return (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->tca_kind) ?
QDISC_VTABLE(qdisc)->tca_kind : qdisc->tca_kind;
}
static void qdisc_hash_func(const QDisc *qdisc, struct siphash *state) {
assert(qdisc);
assert(state);
siphash24_compress(&qdisc->handle, sizeof(qdisc->handle), state);
siphash24_compress(&qdisc->parent, sizeof(qdisc->parent), state);
siphash24_compress_string(qdisc_get_tca_kind(qdisc), state);
}
static int qdisc_compare_func(const QDisc *a, const QDisc *b) {
int r;
assert(a);
assert(b);
r = CMP(a->handle, b->handle);
if (r != 0)
return r;
r = CMP(a->parent, b->parent);
if (r != 0)
return r;
return strcmp_ptr(qdisc_get_tca_kind(a), qdisc_get_tca_kind(b));
}
DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(
qdisc_hash_ops,
QDisc,
qdisc_hash_func,
qdisc_compare_func,
qdisc_free);
static int qdisc_get(Link *link, const QDisc *in, QDisc **ret) {
QDisc *existing;
assert(link);
assert(in);
existing = set_get(link->qdiscs, in);
if (!existing)
return -ENOENT;
if (ret)
*ret = existing;
return 0;
}
static int qdisc_add(Link *link, QDisc *qdisc) {
int r;
assert(link);
assert(qdisc);
r = set_ensure_put(&link->qdiscs, &qdisc_hash_ops, qdisc);
if (r < 0)
return r;
if (r == 0)
return -EEXIST;
qdisc->link = link;
return 0;
}
static int qdisc_dup(const QDisc *src, QDisc **ret) {
_cleanup_(qdisc_freep) QDisc *dst = NULL;
assert(src);
assert(ret);
if (QDISC_VTABLE(src))
dst = memdup(src, QDISC_VTABLE(src)->object_size);
else
dst = newdup(QDisc, src, 1);
if (!dst)
return -ENOMEM;
/* clear all pointers */
dst->network = NULL;
dst->section = NULL;
dst->link = NULL;
dst->tca_kind = NULL;
if (src->tca_kind) {
dst->tca_kind = strdup(src->tca_kind);
if (!dst->tca_kind)
return -ENOMEM;
}
*ret = TAKE_PTR(dst);
return 0;
}
static void log_qdisc_debug(QDisc *qdisc, Link *link, const char *str) {
_cleanup_free_ char *state = NULL;
assert(qdisc);
assert(str);
if (!DEBUG_LOGGING)
return;
(void) network_config_state_to_string_alloc(qdisc->state, &state);
log_link_debug(link, "%s %s QDisc (%s): handle=%"PRIx32":%"PRIx32", parent=%"PRIx32":%"PRIx32", kind=%s",
str, strna(network_config_source_to_string(qdisc->source)), strna(state),
TC_H_MAJ(qdisc->handle) >> 16, TC_H_MIN(qdisc->handle),
TC_H_MAJ(qdisc->parent) >> 16, TC_H_MIN(qdisc->parent),
strna(qdisc_get_tca_kind(qdisc)));
}
int link_find_qdisc(Link *link, uint32_t handle, uint32_t parent, const char *kind, QDisc **ret) {
QDisc *qdisc;
assert(link);
handle = TC_H_MAJ(handle);
SET_FOREACH(qdisc, link->qdiscs) {
if (qdisc->handle != handle)
continue;
if (qdisc->parent != parent)
continue;
if (qdisc->source == NETWORK_CONFIG_SOURCE_FOREIGN)
continue;
if (!qdisc_exists(qdisc))
continue;
if (kind && !streq_ptr(kind, qdisc_get_tca_kind(qdisc)))
continue;
if (ret)
*ret = qdisc;
return 0;
}
return -ENOENT;
}
static int qdisc_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, QDisc *qdisc) {
int r;
assert(m);
assert(link);
r = sd_netlink_message_get_errno(m);
if (r < 0 && r != -EEXIST) {
log_link_message_error_errno(link, m, r, "Could not set QDisc");
link_enter_failed(link);
return 1;
}
if (link->tc_messages == 0) {
log_link_debug(link, "Traffic control configured");
link->tc_configured = true;
link_check_ready(link);
}
return 1;
}
static int qdisc_configure(QDisc *qdisc, Link *link, Request *req) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(qdisc);
assert(link);
assert(link->manager);
assert(link->manager->rtnl);
assert(link->ifindex > 0);
assert(req);
log_qdisc_debug(qdisc, link, "Configuring");
r = sd_rtnl_message_new_traffic_control(link->manager->rtnl, &m, RTM_NEWQDISC,
link->ifindex, qdisc->handle, qdisc->parent);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, TCA_KIND, qdisc_get_tca_kind(qdisc));
if (r < 0)
return r;
if (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->fill_message) {
r = QDISC_VTABLE(qdisc)->fill_message(link, qdisc, m);
if (r < 0)
return r;
}
return request_call_netlink_async(link->manager->rtnl, m, req);
}
static bool qdisc_is_ready_to_configure(QDisc *qdisc, Link *link) {
assert(qdisc);
assert(link);
if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
return false;
/* TC_H_CLSACT == TC_H_INGRESS */
if (!IN_SET(qdisc->parent, TC_H_ROOT, TC_H_CLSACT) &&
link_find_tclass(link, qdisc->parent, NULL) < 0)
return false;
if (QDISC_VTABLE(qdisc) &&
QDISC_VTABLE(qdisc)->is_ready &&
QDISC_VTABLE(qdisc)->is_ready(qdisc, link) <= 0)
return false;
return true;
}
static int qdisc_process_request(Request *req, Link *link, QDisc *qdisc) {
int r;
assert(req);
assert(link);
assert(qdisc);
if (!qdisc_is_ready_to_configure(qdisc, link))
return 0;
r = qdisc_configure(qdisc, link, req);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to configure QDisc: %m");
qdisc_enter_configuring(qdisc);
return 1;
}
int link_request_qdisc(Link *link, QDisc *qdisc) {
QDisc *existing;
int r;
assert(link);
assert(qdisc);
if (qdisc_get(link, qdisc, &existing) < 0) {
_cleanup_(qdisc_freep) QDisc *tmp = NULL;
r = qdisc_dup(qdisc, &tmp);
if (r < 0)
return log_oom();
r = qdisc_add(link, tmp);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to store QDisc: %m");
existing = TAKE_PTR(tmp);
} else
existing->source = qdisc->source;
log_qdisc_debug(existing, link, "Requesting");
r = link_queue_request_safe(link, REQUEST_TYPE_TC_QDISC,
existing, NULL,
qdisc_hash_func,
qdisc_compare_func,
qdisc_process_request,
&link->tc_messages,
qdisc_handler,
NULL);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to request QDisc: %m");
if (r == 0)
return 0;
qdisc_enter_requesting(existing);
return 1;
}
int manager_rtnl_process_qdisc(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
_cleanup_(qdisc_freep) QDisc *tmp = NULL;
QDisc *qdisc = NULL;
Link *link;
uint16_t type;
int ifindex, r;
assert(rtnl);
assert(message);
assert(m);
if (sd_netlink_message_is_error(message)) {
r = sd_netlink_message_get_errno(message);
if (r < 0)
log_message_warning_errno(message, r, "rtnl: failed to receive QDisc message, ignoring");
return 0;
}
r = sd_netlink_message_get_type(message, &type);
if (r < 0) {
log_warning_errno(r, "rtnl: could not get message type, ignoring: %m");
return 0;
} else if (!IN_SET(type, RTM_NEWQDISC, RTM_DELQDISC)) {
log_warning("rtnl: received unexpected message type %u when processing QDisc, ignoring.", type);
return 0;
}
r = sd_rtnl_message_traffic_control_get_ifindex(message, &ifindex);
if (r < 0) {
log_warning_errno(r, "rtnl: could not get ifindex from message, ignoring: %m");
return 0;
} else if (ifindex <= 0) {
log_warning("rtnl: received QDisc message with invalid ifindex %d, ignoring.", ifindex);
return 0;
}
if (link_get_by_index(m, ifindex, &link) < 0) {
if (!m->enumerating)
log_warning("rtnl: received QDisc for link '%d' we don't know about, ignoring.", ifindex);
return 0;
}
r = qdisc_new(_QDISC_KIND_INVALID, &tmp);
if (r < 0)
return log_oom();
r = sd_rtnl_message_traffic_control_get_handle(message, &tmp->handle);
if (r < 0) {
log_link_warning_errno(link, r, "rtnl: received QDisc message without handle, ignoring: %m");
return 0;
}
r = sd_rtnl_message_traffic_control_get_parent(message, &tmp->parent);
if (r < 0) {
log_link_warning_errno(link, r, "rtnl: received QDisc message without parent, ignoring: %m");
return 0;
}
r = sd_netlink_message_read_string_strdup(message, TCA_KIND, &tmp->tca_kind);
if (r < 0) {
log_link_warning_errno(link, r, "rtnl: received QDisc message without kind, ignoring: %m");
return 0;
}
(void) qdisc_get(link, tmp, &qdisc);
switch (type) {
case RTM_NEWQDISC:
if (qdisc) {
qdisc_enter_configured(qdisc);
log_qdisc_debug(qdisc, link, "Received remembered");
} else {
qdisc_enter_configured(tmp);
log_qdisc_debug(tmp, link, "Received new");
r = qdisc_add(link, tmp);
if (r < 0) {
log_link_warning_errno(link, r, "Failed to remember QDisc, ignoring: %m");
return 0;
}
qdisc = TAKE_PTR(tmp);
}
break;
case RTM_DELQDISC:
if (qdisc) {
qdisc_enter_removed(qdisc);
if (qdisc->state == 0) {
log_qdisc_debug(qdisc, link, "Forgetting");
qdisc_free(qdisc);
} else
log_qdisc_debug(qdisc, link, "Removed");
} else
log_qdisc_debug(tmp, link, "Kernel removed unknown");
break;
default:
assert_not_reached();
}
return 1;
}
static int qdisc_section_verify(QDisc *qdisc, bool *has_root, bool *has_clsact) {
int r;
assert(qdisc);
assert(has_root);
assert(has_clsact);
if (section_is_invalid(qdisc->section))
return -EINVAL;
if (QDISC_VTABLE(qdisc) && QDISC_VTABLE(qdisc)->verify) {
r = QDISC_VTABLE(qdisc)->verify(qdisc);
if (r < 0)
return r;
}
if (qdisc->parent == TC_H_ROOT) {
if (*has_root)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: More than one root qdisc section is defined. "
"Ignoring the qdisc section from line %u.",
qdisc->section->filename, qdisc->section->line);
*has_root = true;
} else if (qdisc->parent == TC_H_CLSACT) { /* TC_H_CLSACT == TC_H_INGRESS */
if (*has_clsact)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: More than one clsact or ingress qdisc section is defined. "
"Ignoring the qdisc section from line %u.",
qdisc->section->filename, qdisc->section->line);
*has_clsact = true;
}
return 0;
}
void network_drop_invalid_qdisc(Network *network) {
bool has_root = false, has_clsact = false;
QDisc *qdisc;
assert(network);
HASHMAP_FOREACH(qdisc, network->qdiscs_by_section)
if (qdisc_section_verify(qdisc, &has_root, &has_clsact) < 0)
qdisc_free(qdisc);
}
int config_parse_qdisc_parent(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
if (streq(rvalue, "root"))
qdisc->parent = TC_H_ROOT;
else if (streq(rvalue, "clsact")) {
qdisc->parent = TC_H_CLSACT;
qdisc->handle = TC_H_MAKE(TC_H_CLSACT, 0);
} else if (streq(rvalue, "ingress")) {
qdisc->parent = TC_H_INGRESS;
qdisc->handle = TC_H_MAKE(TC_H_INGRESS, 0);
} else {
r = parse_handle(rvalue, &qdisc->parent);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse 'Parent=', ignoring assignment: %s",
rvalue);
return 0;
}
}
if (STR_IN_SET(rvalue, "clsact", "ingress")) {
r = free_and_strdup(&qdisc->tca_kind, rvalue);
if (r < 0)
return log_oom();
} else
qdisc->tca_kind = mfree(qdisc->tca_kind);
TAKE_PTR(qdisc);
return 0;
}
int config_parse_qdisc_handle(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
uint16_t n;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
if (isempty(rvalue)) {
qdisc->handle = TC_H_UNSPEC;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou16_full(rvalue, 16, &n);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse 'Handle=', ignoring assignment: %s",
rvalue);
return 0;
}
qdisc->handle = (uint32_t) n << 16;
TAKE_PTR(qdisc);
return 0;
}
| 21,607 | 30.406977 | 114 |
c
|
null |
systemd-main/src/network/tc/qdisc.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "networkd-util.h"
typedef struct Link Link;
typedef struct Manager Manager;
typedef struct Network Network;
typedef enum QDiscKind {
QDISC_KIND_BFIFO,
QDISC_KIND_CAKE,
QDISC_KIND_CODEL,
QDISC_KIND_DRR,
QDISC_KIND_ETS,
QDISC_KIND_FQ,
QDISC_KIND_FQ_CODEL,
QDISC_KIND_FQ_PIE,
QDISC_KIND_GRED,
QDISC_KIND_HHF,
QDISC_KIND_HTB,
QDISC_KIND_NETEM,
QDISC_KIND_PFIFO,
QDISC_KIND_PFIFO_FAST,
QDISC_KIND_PFIFO_HEAD_DROP,
QDISC_KIND_PIE,
QDISC_KIND_QFQ,
QDISC_KIND_SFB,
QDISC_KIND_SFQ,
QDISC_KIND_TBF,
QDISC_KIND_TEQL,
_QDISC_KIND_MAX,
_QDISC_KIND_INVALID = -EINVAL,
} QDiscKind;
typedef struct QDisc {
Link *link;
Network *network;
ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
uint32_t handle;
uint32_t parent;
char *tca_kind;
QDiscKind kind;
} QDisc;
typedef struct QDiscVTable {
size_t object_size;
const char *tca_kind;
/* called in qdisc_new() */
int (*init)(QDisc *qdisc);
int (*fill_message)(Link *link, QDisc *qdisc, sd_netlink_message *m);
int (*verify)(QDisc *qdisc);
int (*is_ready)(QDisc *qdisc, Link *link);
} QDiscVTable;
extern const QDiscVTable * const qdisc_vtable[_QDISC_KIND_MAX];
#define QDISC_VTABLE(q) ((q)->kind != _QDISC_KIND_INVALID ? qdisc_vtable[(q)->kind] : NULL)
/* For casting a qdisc into the various qdisc kinds */
#define DEFINE_QDISC_CAST(UPPERCASE, MixedCase) \
static inline MixedCase* UPPERCASE(QDisc *q) { \
if (_unlikely_(!q || q->kind != QDISC_KIND_##UPPERCASE)) \
return NULL; \
\
return (MixedCase*) q; \
}
DEFINE_NETWORK_CONFIG_STATE_FUNCTIONS(QDisc, qdisc);
QDisc* qdisc_free(QDisc *qdisc);
int qdisc_new_static(QDiscKind kind, Network *network, const char *filename, unsigned section_line, QDisc **ret);
int link_find_qdisc(Link *link, uint32_t handle, uint32_t parent, const char *kind, QDisc **qdisc);
int link_request_qdisc(Link *link, QDisc *qdisc);
void network_drop_invalid_qdisc(Network *network);
int manager_rtnl_process_qdisc(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
DEFINE_SECTION_CLEANUP_FUNCTIONS(QDisc, qdisc_free);
CONFIG_PARSER_PROTOTYPE(config_parse_qdisc_parent);
CONFIG_PARSER_PROTOTYPE(config_parse_qdisc_handle);
#include "cake.h"
#include "codel.h"
#include "ets.h"
#include "fifo.h"
#include "fq-codel.h"
#include "fq-pie.h"
#include "fq.h"
#include "gred.h"
#include "hhf.h"
#include "htb.h"
#include "pie.h"
#include "qfq.h"
#include "netem.h"
#include "drr.h"
#include "sfb.h"
#include "sfq.h"
#include "tbf.h"
#include "teql.h"
| 3,163 | 27.504505 | 113 |
h
|
null |
systemd-main/src/network/tc/qfq.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "parse-util.h"
#include "qdisc.h"
#include "qfq.h"
#include "string-util.h"
#define QFQ_MAX_WEIGHT (1 << 10)
#define QFQ_MIN_MAX_PACKET 512
#define QFQ_MAX_MAX_PACKET (1 << 16)
const QDiscVTable qfq_vtable = {
.object_size = sizeof(QuickFairQueueing),
.tca_kind = "qfq",
};
static int quick_fair_queueing_class_fill_message(Link *link, TClass *tclass, sd_netlink_message *req) {
QuickFairQueueingClass *qfq;
int r;
assert(link);
assert(tclass);
assert(req);
assert_se(qfq = TCLASS_TO_QFQ(tclass));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "qfq");
if (r < 0)
return r;
if (qfq->weight > 0) {
r = sd_netlink_message_append_u32(req, TCA_QFQ_WEIGHT, qfq->weight);
if (r < 0)
return r;
}
if (qfq->max_packet > 0) {
r = sd_netlink_message_append_u32(req, TCA_QFQ_LMAX, qfq->max_packet);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_quick_fair_queueing_weight(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
QuickFairQueueingClass *qfq;
Network *network = ASSERT_PTR(data);
uint32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = tclass_new_static(TCLASS_KIND_QFQ, network, filename, section_line, &tclass);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to create traffic control class, ignoring assignment: %m");
return 0;
}
qfq = TCLASS_TO_QFQ(tclass);
if (isempty(rvalue)) {
qfq->weight = 0;
TAKE_PTR(tclass);
return 0;
}
r = safe_atou32(rvalue, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (v == 0 || v > QFQ_MAX_WEIGHT) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
qfq->weight = v;
TAKE_PTR(tclass);
return 0;
}
int config_parse_quick_fair_queueing_max_packet(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
QuickFairQueueingClass *qfq;
Network *network = ASSERT_PTR(data);
uint64_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = tclass_new_static(TCLASS_KIND_QFQ, network, filename, section_line, &tclass);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to create traffic control class, ignoring assignment: %m");
return 0;
}
qfq = TCLASS_TO_QFQ(tclass);
if (isempty(rvalue)) {
qfq->max_packet = 0;
TAKE_PTR(tclass);
return 0;
}
r = parse_size(rvalue, 1024, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (v < QFQ_MIN_MAX_PACKET || v > QFQ_MAX_MAX_PACKET) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
qfq->max_packet = (uint32_t) v;
TAKE_PTR(tclass);
return 0;
}
const TClassVTable qfq_tclass_vtable = {
.object_size = sizeof(QuickFairQueueingClass),
.tca_kind = "qfq",
.fill_message = quick_fair_queueing_class_fill_message,
};
| 5,170 | 28.050562 | 104 |
c
|
null |
systemd-main/src/network/tc/qfq.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "qdisc.h"
typedef struct QuickFairQueueing {
QDisc meta;
} QuickFairQueueing;
DEFINE_QDISC_CAST(QFQ, QuickFairQueueing);
extern const QDiscVTable qfq_vtable;
typedef struct QuickFairQueueingClass {
TClass meta;
uint32_t weight;
uint32_t max_packet;
} QuickFairQueueingClass;
DEFINE_TCLASS_CAST(QFQ, QuickFairQueueingClass);
extern const TClassVTable qfq_tclass_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_quick_fair_queueing_weight);
CONFIG_PARSER_PROTOTYPE(config_parse_quick_fair_queueing_max_packet);
| 673 | 23.962963 | 69 |
h
|
null |
systemd-main/src/network/tc/sfb.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2020 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "qdisc.h"
#include "sfb.h"
#include "string-util.h"
static int stochastic_fair_blue_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
StochasticFairBlue *sfb;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(sfb = SFB(qdisc));
const struct tc_sfb_qopt opt = {
.rehash_interval = 600*1000,
.warmup_time = 60*1000,
.penalty_rate = 10,
.penalty_burst = 20,
.increment = (SFB_MAX_PROB + 1000) / 2000,
.decrement = (SFB_MAX_PROB + 10000) / 20000,
.max = 25,
.bin_size = 20,
.limit = sfb->packet_limit,
};
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "sfb");
if (r < 0)
return r;
r = sd_netlink_message_append_data(req, TCA_SFB_PARMS, &opt, sizeof(opt));
if (r < 0)
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_stochastic_fair_blue_u32(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
StochasticFairBlue *sfb;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_SFB, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
sfb = SFB(qdisc);
if (isempty(rvalue)) {
sfb->packet_limit = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou32(rvalue, &sfb->packet_limit);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
const QDiscVTable sfb_vtable = {
.object_size = sizeof(StochasticFairBlue),
.tca_kind = "sfb",
.fill_message = stochastic_fair_blue_fill_message,
};
| 2,970 | 26.509259 | 97 |
c
|
null |
systemd-main/src/network/tc/sfq.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "qdisc.h"
#include "sfq.h"
#include "string-util.h"
static int stochastic_fairness_queueing_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
StochasticFairnessQueueing *sfq;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(sfq = SFQ(qdisc));
const struct tc_sfq_qopt_v1 opt = {
.v0.perturb_period = sfq->perturb_period / USEC_PER_SEC,
};
r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(opt));
if (r < 0)
return r;
return 0;
}
int config_parse_stochastic_fairness_queueing_perturb_period(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
StochasticFairnessQueueing *sfq;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_SFQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
sfq = SFQ(qdisc);
if (isempty(rvalue)) {
sfq->perturb_period = 0;
TAKE_PTR(qdisc);
return 0;
}
r = parse_sec(rvalue, &sfq->perturb_period);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(qdisc);
return 0;
}
const QDiscVTable sfq_vtable = {
.object_size = sizeof(StochasticFairnessQueueing),
.tca_kind = "sfq",
.fill_message = stochastic_fairness_queueing_fill_message,
};
| 2,537 | 26.586957 | 105 |
c
|
null |
systemd-main/src/network/tc/tbf.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#include <linux/pkt_sched.h>
#include <math.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "netem.h"
#include "netlink-util.h"
#include "networkd-manager.h"
#include "parse-util.h"
#include "qdisc.h"
#include "string-util.h"
#include "strv.h"
#include "tc-util.h"
static int token_bucket_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
uint32_t rtab[256], ptab[256];
TokenBucketFilter *tbf;
int r;
assert(link);
assert(qdisc);
assert(req);
assert_se(tbf = TBF(qdisc));
struct tc_tbf_qopt opt = {
.rate.rate = tbf->rate >= (1ULL << 32) ? ~0U : tbf->rate,
.peakrate.rate = tbf->peak_rate >= (1ULL << 32) ? ~0U : tbf->peak_rate,
.rate.mpu = tbf->mpu,
};
if (tbf->limit > 0)
opt.limit = tbf->limit;
else {
double lim, lim2;
lim = tbf->rate * (double) tbf->latency / USEC_PER_SEC + tbf->burst;
if (tbf->peak_rate > 0) {
lim2 = tbf->peak_rate * (double) tbf->latency / USEC_PER_SEC + tbf->mtu;
lim = MIN(lim, lim2);
}
opt.limit = lim;
}
r = tc_fill_ratespec_and_table(&opt.rate, rtab, tbf->mtu);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to calculate ratespec: %m");
r = tc_transmit_time(opt.rate.rate, tbf->burst, &opt.buffer);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to calculate buffer size: %m");
if (opt.peakrate.rate > 0) {
opt.peakrate.mpu = tbf->mpu;
r = tc_fill_ratespec_and_table(&opt.peakrate, ptab, tbf->mtu);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to calculate ratespec: %m");
r = tc_transmit_time(opt.peakrate.rate, tbf->mtu, &opt.mtu);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to calculate mtu size: %m");
}
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "tbf");
if (r < 0)
return r;
r = sd_netlink_message_append_data(req, TCA_TBF_PARMS, &opt, sizeof(opt));
if (r < 0)
return r;
r = sd_netlink_message_append_data(req, TCA_TBF_BURST, &tbf->burst, sizeof(tbf->burst));
if (r < 0)
return r;
if (tbf->rate >= (1ULL << 32)) {
r = sd_netlink_message_append_u64(req, TCA_TBF_RATE64, tbf->rate);
if (r < 0)
return r;
}
r = sd_netlink_message_append_data(req, TCA_TBF_RTAB, rtab, sizeof(rtab));
if (r < 0)
return r;
if (opt.peakrate.rate > 0) {
if (tbf->peak_rate >= (1ULL << 32)) {
r = sd_netlink_message_append_u64(req, TCA_TBF_PRATE64, tbf->peak_rate);
if (r < 0)
return r;
}
r = sd_netlink_message_append_u32(req, TCA_TBF_PBURST, tbf->mtu);
if (r < 0)
return r;
r = sd_netlink_message_append_data(req, TCA_TBF_PTAB, ptab, sizeof(ptab));
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return r;
return 0;
}
int config_parse_token_bucket_filter_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
TokenBucketFilter *tbf;
uint64_t k;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
tbf = TBF(qdisc);
if (isempty(rvalue)) {
if (STR_IN_SET(lvalue, "BurstBytes", "Burst"))
tbf->burst = 0;
else if (STR_IN_SET(lvalue, "LimitBytes", "LimitSize"))
tbf->limit = 0;
else if (streq(lvalue, "MTUBytes"))
tbf->mtu = 0;
else if (streq(lvalue, "MPUBytes"))
tbf->mpu = 0;
else
assert_not_reached();
TAKE_PTR(qdisc);
return 0;
}
r = parse_size(rvalue, 1024, &k);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (STR_IN_SET(lvalue, "BurstBytes", "Burst"))
tbf->burst = k;
else if (STR_IN_SET(lvalue, "LimitBytes", "LimitSize"))
tbf->limit = k;
else if (streq(lvalue, "MPUBytes"))
tbf->mpu = k;
else if (streq(lvalue, "MTUBytes"))
tbf->mtu = k;
else
assert_not_reached();
TAKE_PTR(qdisc);
return 0;
}
int config_parse_token_bucket_filter_rate(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
TokenBucketFilter *tbf;
uint64_t k, *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
tbf = TBF(qdisc);
if (streq(lvalue, "Rate"))
p = &tbf->rate;
else if (streq(lvalue, "PeakRate"))
p = &tbf->peak_rate;
else
assert_not_reached();
if (isempty(rvalue)) {
*p = 0;
TAKE_PTR(qdisc);
return 0;
}
r = parse_size(rvalue, 1000, &k);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
*p = k / 8;
qdisc = NULL;
return 0;
}
int config_parse_token_bucket_filter_latency(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
Network *network = ASSERT_PTR(data);
TokenBucketFilter *tbf;
usec_t u;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
tbf = TBF(qdisc);
if (isempty(rvalue)) {
tbf->latency = 0;
qdisc = NULL;
return 0;
}
r = parse_sec(rvalue, &u);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
tbf->latency = u;
qdisc = NULL;
return 0;
}
static int token_bucket_filter_verify(QDisc *qdisc) {
TokenBucketFilter *tbf = TBF(qdisc);
if (tbf->limit > 0 && tbf->latency > 0)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: Specifying both LimitBytes= and LatencySec= is not allowed. "
"Ignoring [TokenBucketFilter] section from line %u.",
qdisc->section->filename, qdisc->section->line);
if (tbf->limit == 0 && tbf->latency == 0)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: Either LimitBytes= or LatencySec= is required. "
"Ignoring [TokenBucketFilter] section from line %u.",
qdisc->section->filename, qdisc->section->line);
if (tbf->rate == 0)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: Rate= is mandatory. "
"Ignoring [TokenBucketFilter] section from line %u.",
qdisc->section->filename, qdisc->section->line);
if (tbf->burst == 0)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: BurstBytes= is mandatory. "
"Ignoring [TokenBucketFilter] section from line %u.",
qdisc->section->filename, qdisc->section->line);
if (tbf->peak_rate > 0 && tbf->mtu == 0)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: MTUBytes= is mandatory when PeakRate= is specified. "
"Ignoring [TokenBucketFilter] section from line %u.",
qdisc->section->filename, qdisc->section->line);
return 0;
}
const QDiscVTable tbf_vtable = {
.object_size = sizeof(TokenBucketFilter),
.tca_kind = "tbf",
.fill_message = token_bucket_filter_fill_message,
.verify = token_bucket_filter_verify
};
| 11,434 | 32.241279 | 107 |
c
|
null |
systemd-main/src/network/tc/tbf.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "qdisc.h"
#include "time-util.h"
typedef struct TokenBucketFilter {
QDisc meta;
uint64_t rate;
uint64_t peak_rate;
uint32_t burst;
uint32_t mtu;
usec_t latency;
size_t limit;
size_t mpu;
} TokenBucketFilter;
DEFINE_QDISC_CAST(TBF, TokenBucketFilter);
extern const QDiscVTable tbf_vtable;
CONFIG_PARSER_PROTOTYPE(config_parse_token_bucket_filter_latency);
CONFIG_PARSER_PROTOTYPE(config_parse_token_bucket_filter_size);
CONFIG_PARSER_PROTOTYPE(config_parse_token_bucket_filter_rate);
| 681 | 24.259259 | 66 |
h
|
null |
systemd-main/src/network/tc/tc-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#include "alloc-util.h"
#include "extract-word.h"
#include "fileio.h"
#include "parse-util.h"
#include "percent-util.h"
#include "tc-util.h"
#include "time-util.h"
int tc_init(double *ret_ticks_in_usec, uint32_t *ret_hz) {
static double ticks_in_usec = -1;
static uint32_t hz;
if (ticks_in_usec < 0) {
uint32_t clock_resolution, ticks_to_usec, usec_to_ticks;
_cleanup_free_ char *line = NULL;
double clock_factor;
int r;
r = read_one_line_file("/proc/net/psched", &line);
if (r < 0)
return r;
r = sscanf(line, "%08x%08x%08x%08x", &ticks_to_usec, &usec_to_ticks, &clock_resolution, &hz);
if (r < 4)
return -EIO;
clock_factor = (double) clock_resolution / USEC_PER_SEC;
ticks_in_usec = (double) ticks_to_usec / usec_to_ticks * clock_factor;
}
if (ret_ticks_in_usec)
*ret_ticks_in_usec = ticks_in_usec;
if (ret_hz)
*ret_hz = hz;
return 0;
}
int tc_time_to_tick(usec_t t, uint32_t *ret) {
double ticks_in_usec;
usec_t a;
int r;
assert(ret);
r = tc_init(&ticks_in_usec, NULL);
if (r < 0)
return r;
a = t * ticks_in_usec;
if (a > UINT32_MAX)
return -ERANGE;
*ret = a;
return 0;
}
int parse_tc_percent(const char *s, uint32_t *ret_fraction) {
int r;
assert(s);
assert(ret_fraction);
r = parse_permyriad(s);
if (r < 0)
return r;
*ret_fraction = (double) r / 10000 * UINT32_MAX;
return 0;
}
int tc_transmit_time(uint64_t rate, uint32_t size, uint32_t *ret) {
return tc_time_to_tick(USEC_PER_SEC * ((double)size / (double)rate), ret);
}
int tc_fill_ratespec_and_table(struct tc_ratespec *rate, uint32_t *rtab, uint32_t mtu) {
uint32_t cell_log = 0;
int r;
if (mtu == 0)
mtu = 2047;
while ((mtu >> cell_log) > 255)
cell_log++;
for (size_t i = 0; i < 256; i++) {
uint32_t sz;
sz = (i + 1) << cell_log;
if (sz < rate->mpu)
sz = rate->mpu;
r = tc_transmit_time(rate->rate, sz, &rtab[i]);
if (r < 0)
return r;
}
rate->cell_align = -1;
rate->cell_log = cell_log;
rate->linklayer = TC_LINKLAYER_ETHERNET;
return 0;
}
int parse_handle(const char *t, uint32_t *ret) {
_cleanup_free_ char *word = NULL;
uint16_t major, minor;
int r;
assert(t);
assert(ret);
/* Extract the major number. */
r = extract_first_word(&t, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
if (r < 0)
return r;
if (r == 0)
return -EINVAL;
if (!t)
return -EINVAL;
r = safe_atou16_full(word, 16, &major);
if (r < 0)
return r;
r = safe_atou16_full(t, 16, &minor);
if (r < 0)
return r;
*ret = ((uint32_t) major << 16) | minor;
return 0;
}
| 3,436 | 24.649254 | 109 |
c
|
null |
systemd-main/src/network/tc/tc-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#pragma once
#include <linux/pkt_sched.h>
#include "time-util.h"
int tc_init(double *ret_ticks_in_usec, uint32_t *ret_hz);
int tc_time_to_tick(usec_t t, uint32_t *ret);
int parse_tc_percent(const char *s, uint32_t *percent);
int tc_transmit_time(uint64_t rate, uint32_t size, uint32_t *ret);
int tc_fill_ratespec_and_table(struct tc_ratespec *rate, uint32_t *rtab, uint32_t mtu);
int parse_handle(const char *t, uint32_t *ret);
| 513 | 33.266667 | 87 |
h
|
null |
systemd-main/src/network/tc/tc.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "macro.h"
#include "networkd-link.h"
#include "networkd-network.h"
#include "qdisc.h"
#include "tc.h"
#include "tclass.h"
int link_request_traffic_control(Link *link) {
TClass *tclass;
QDisc *qdisc;
int r;
assert(link);
assert(link->network);
link->tc_configured = false;
HASHMAP_FOREACH(qdisc, link->network->qdiscs_by_section) {
r = link_request_qdisc(link, qdisc);
if (r < 0)
return r;
}
HASHMAP_FOREACH(tclass, link->network->tclasses_by_section) {
r = link_request_tclass(link, tclass);
if (r < 0)
return r;
}
if (link->tc_messages == 0) {
link->tc_configured = true;
link_check_ready(link);
} else {
log_link_debug(link, "Setting traffic control");
link_set_state(link, LINK_STATE_CONFIGURING);
}
return 0;
}
| 1,069 | 24.47619 | 69 |
c
|
null |
systemd-main/src/network/tc/tclass.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#include <linux/pkt_sched.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "in-addr-util.h"
#include "netlink-util.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-network.h"
#include "networkd-queue.h"
#include "parse-util.h"
#include "set.h"
#include "string-util.h"
#include "strv.h"
#include "tc-util.h"
#include "tclass.h"
const TClassVTable * const tclass_vtable[_TCLASS_KIND_MAX] = {
[TCLASS_KIND_DRR] = &drr_tclass_vtable,
[TCLASS_KIND_HTB] = &htb_tclass_vtable,
[TCLASS_KIND_QFQ] = &qfq_tclass_vtable,
};
static int tclass_new(TClassKind kind, TClass **ret) {
_cleanup_(tclass_freep) TClass *tclass = NULL;
int r;
if (kind == _TCLASS_KIND_INVALID) {
tclass = new(TClass, 1);
if (!tclass)
return -ENOMEM;
*tclass = (TClass) {
.parent = TC_H_ROOT,
.kind = kind,
};
} else {
assert(kind >= 0 && kind < _TCLASS_KIND_MAX);
tclass = malloc0(tclass_vtable[kind]->object_size);
if (!tclass)
return -ENOMEM;
tclass->parent = TC_H_ROOT;
tclass->kind = kind;
if (TCLASS_VTABLE(tclass)->init) {
r = TCLASS_VTABLE(tclass)->init(tclass);
if (r < 0)
return r;
}
}
*ret = TAKE_PTR(tclass);
return 0;
}
int tclass_new_static(TClassKind kind, Network *network, const char *filename, unsigned section_line, TClass **ret) {
_cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(tclass_freep) TClass *tclass = NULL;
TClass *existing;
int r;
assert(network);
assert(ret);
assert(filename);
assert(section_line > 0);
r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
existing = hashmap_get(network->tclasses_by_section, n);
if (existing) {
if (existing->kind != kind)
return -EINVAL;
*ret = existing;
return 0;
}
r = tclass_new(kind, &tclass);
if (r < 0)
return r;
tclass->network = network;
tclass->section = TAKE_PTR(n);
tclass->source = NETWORK_CONFIG_SOURCE_STATIC;
r = hashmap_ensure_put(&network->tclasses_by_section, &config_section_hash_ops, tclass->section, tclass);
if (r < 0)
return r;
*ret = TAKE_PTR(tclass);
return 0;
}
TClass* tclass_free(TClass *tclass) {
if (!tclass)
return NULL;
if (tclass->network && tclass->section)
hashmap_remove(tclass->network->tclasses_by_section, tclass->section);
config_section_free(tclass->section);
if (tclass->link)
set_remove(tclass->link->tclasses, tclass);
free(tclass->tca_kind);
return mfree(tclass);
}
static const char *tclass_get_tca_kind(const TClass *tclass) {
assert(tclass);
return (TCLASS_VTABLE(tclass) && TCLASS_VTABLE(tclass)->tca_kind) ?
TCLASS_VTABLE(tclass)->tca_kind : tclass->tca_kind;
}
static void tclass_hash_func(const TClass *tclass, struct siphash *state) {
assert(tclass);
assert(state);
siphash24_compress(&tclass->classid, sizeof(tclass->classid), state);
siphash24_compress(&tclass->parent, sizeof(tclass->parent), state);
siphash24_compress_string(tclass_get_tca_kind(tclass), state);
}
static int tclass_compare_func(const TClass *a, const TClass *b) {
int r;
assert(a);
assert(b);
r = CMP(a->classid, b->classid);
if (r != 0)
return r;
r = CMP(a->parent, b->parent);
if (r != 0)
return r;
return strcmp_ptr(tclass_get_tca_kind(a), tclass_get_tca_kind(b));
}
DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(
tclass_hash_ops,
TClass,
tclass_hash_func,
tclass_compare_func,
tclass_free);
static int tclass_get(Link *link, const TClass *in, TClass **ret) {
TClass *existing;
assert(link);
assert(in);
existing = set_get(link->tclasses, in);
if (!existing)
return -ENOENT;
if (ret)
*ret = existing;
return 0;
}
static int tclass_add(Link *link, TClass *tclass) {
int r;
assert(link);
assert(tclass);
r = set_ensure_put(&link->tclasses, &tclass_hash_ops, tclass);
if (r < 0)
return r;
if (r == 0)
return -EEXIST;
tclass->link = link;
return 0;
}
static int tclass_dup(const TClass *src, TClass **ret) {
_cleanup_(tclass_freep) TClass *dst = NULL;
assert(src);
assert(ret);
if (TCLASS_VTABLE(src))
dst = memdup(src, TCLASS_VTABLE(src)->object_size);
else
dst = newdup(TClass, src, 1);
if (!dst)
return -ENOMEM;
/* clear all pointers */
dst->network = NULL;
dst->section = NULL;
dst->link = NULL;
dst->tca_kind = NULL;
if (src->tca_kind) {
dst->tca_kind = strdup(src->tca_kind);
if (!dst->tca_kind)
return -ENOMEM;
}
*ret = TAKE_PTR(dst);
return 0;
}
int link_find_tclass(Link *link, uint32_t classid, TClass **ret) {
TClass *tclass;
assert(link);
SET_FOREACH(tclass, link->tclasses) {
if (tclass->classid != classid)
continue;
if (tclass->source == NETWORK_CONFIG_SOURCE_FOREIGN)
continue;
if (!tclass_exists(tclass))
continue;
if (ret)
*ret = tclass;
return 0;
}
return -ENOENT;
}
static void log_tclass_debug(TClass *tclass, Link *link, const char *str) {
_cleanup_free_ char *state = NULL;
assert(tclass);
assert(str);
if (!DEBUG_LOGGING)
return;
(void) network_config_state_to_string_alloc(tclass->state, &state);
log_link_debug(link, "%s %s TClass (%s): classid=%"PRIx32":%"PRIx32", parent=%"PRIx32":%"PRIx32", kind=%s",
str, strna(network_config_source_to_string(tclass->source)), strna(state),
TC_H_MAJ(tclass->classid) >> 16, TC_H_MIN(tclass->classid),
TC_H_MAJ(tclass->parent) >> 16, TC_H_MIN(tclass->parent),
strna(tclass_get_tca_kind(tclass)));
}
static int tclass_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, TClass *tclass) {
int r;
assert(m);
assert(link);
r = sd_netlink_message_get_errno(m);
if (r < 0 && r != -EEXIST) {
log_link_message_error_errno(link, m, r, "Could not set TClass");
link_enter_failed(link);
return 1;
}
if (link->tc_messages == 0) {
log_link_debug(link, "Traffic control configured");
link->tc_configured = true;
link_check_ready(link);
}
return 1;
}
static int tclass_configure(TClass *tclass, Link *link, Request *req) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(tclass);
assert(link);
assert(link->manager);
assert(link->manager->rtnl);
assert(link->ifindex > 0);
assert(req);
log_tclass_debug(tclass, link, "Configuring");
r = sd_rtnl_message_new_traffic_control(link->manager->rtnl, &m, RTM_NEWTCLASS,
link->ifindex, tclass->classid, tclass->parent);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, TCA_KIND, TCLASS_VTABLE(tclass)->tca_kind);
if (r < 0)
return r;
if (TCLASS_VTABLE(tclass)->fill_message) {
r = TCLASS_VTABLE(tclass)->fill_message(link, tclass, m);
if (r < 0)
return r;
}
return request_call_netlink_async(link->manager->rtnl, m, req);
}
static bool tclass_is_ready_to_configure(TClass *tclass, Link *link) {
assert(tclass);
assert(link);
if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
return false;
return link_find_qdisc(link, tclass->classid, tclass->parent, tclass_get_tca_kind(tclass), NULL) >= 0;
}
static int tclass_process_request(Request *req, Link *link, TClass *tclass) {
int r;
assert(req);
assert(link);
assert(tclass);
if (!tclass_is_ready_to_configure(tclass, link))
return 0;
r = tclass_configure(tclass, link, req);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to configure TClass: %m");
tclass_enter_configuring(tclass);
return 1;
}
int link_request_tclass(Link *link, TClass *tclass) {
TClass *existing;
int r;
assert(link);
assert(tclass);
if (tclass_get(link, tclass, &existing) < 0) {
_cleanup_(tclass_freep) TClass *tmp = NULL;
r = tclass_dup(tclass, &tmp);
if (r < 0)
return log_oom();
r = tclass_add(link, tmp);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to store TClass: %m");
existing = TAKE_PTR(tmp);
} else
existing->source = tclass->source;
log_tclass_debug(existing, link, "Requesting");
r = link_queue_request_safe(link, REQUEST_TYPE_TC_CLASS,
existing, NULL,
tclass_hash_func,
tclass_compare_func,
tclass_process_request,
&link->tc_messages,
tclass_handler,
NULL);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to request TClass: %m");
if (r == 0)
return 0;
tclass_enter_requesting(existing);
return 1;
}
int manager_rtnl_process_tclass(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
_cleanup_(tclass_freep) TClass *tmp = NULL;
TClass *tclass = NULL;
Link *link;
uint16_t type;
int ifindex, r;
assert(rtnl);
assert(message);
assert(m);
if (sd_netlink_message_is_error(message)) {
r = sd_netlink_message_get_errno(message);
if (r < 0)
log_message_warning_errno(message, r, "rtnl: failed to receive TClass message, ignoring");
return 0;
}
r = sd_netlink_message_get_type(message, &type);
if (r < 0) {
log_warning_errno(r, "rtnl: could not get message type, ignoring: %m");
return 0;
} else if (!IN_SET(type, RTM_NEWTCLASS, RTM_DELTCLASS)) {
log_warning("rtnl: received unexpected message type %u when processing TClass, ignoring.", type);
return 0;
}
r = sd_rtnl_message_traffic_control_get_ifindex(message, &ifindex);
if (r < 0) {
log_warning_errno(r, "rtnl: could not get ifindex from message, ignoring: %m");
return 0;
} else if (ifindex <= 0) {
log_warning("rtnl: received TClass message with invalid ifindex %d, ignoring.", ifindex);
return 0;
}
if (link_get_by_index(m, ifindex, &link) < 0) {
if (!m->enumerating)
log_warning("rtnl: received TClass for link '%d' we don't know about, ignoring.", ifindex);
return 0;
}
r = tclass_new(_TCLASS_KIND_INVALID, &tmp);
if (r < 0)
return log_oom();
r = sd_rtnl_message_traffic_control_get_handle(message, &tmp->classid);
if (r < 0) {
log_link_warning_errno(link, r, "rtnl: received TClass message without handle, ignoring: %m");
return 0;
}
r = sd_rtnl_message_traffic_control_get_parent(message, &tmp->parent);
if (r < 0) {
log_link_warning_errno(link, r, "rtnl: received TClass message without parent, ignoring: %m");
return 0;
}
r = sd_netlink_message_read_string_strdup(message, TCA_KIND, &tmp->tca_kind);
if (r < 0) {
log_link_warning_errno(link, r, "rtnl: received TClass message without kind, ignoring: %m");
return 0;
}
(void) tclass_get(link, tmp, &tclass);
switch (type) {
case RTM_NEWTCLASS:
if (tclass) {
tclass_enter_configured(tclass);
log_tclass_debug(tclass, link, "Received remembered");
} else {
tclass_enter_configured(tmp);
log_tclass_debug(tmp, link, "Received new");
r = tclass_add(link, tmp);
if (r < 0) {
log_link_warning_errno(link, r, "Failed to remember TClass, ignoring: %m");
return 0;
}
tclass = TAKE_PTR(tmp);
}
break;
case RTM_DELTCLASS:
if (tclass) {
tclass_enter_removed(tclass);
if (tclass->state == 0) {
log_tclass_debug(tclass, link, "Forgetting");
tclass_free(tclass);
} else
log_tclass_debug(tclass, link, "Removed");
} else
log_tclass_debug(tmp, link, "Kernel removed unknown");
break;
default:
assert_not_reached();
}
return 1;
}
static int tclass_section_verify(TClass *tclass) {
int r;
assert(tclass);
if (section_is_invalid(tclass->section))
return -EINVAL;
if (TCLASS_VTABLE(tclass)->verify) {
r = TCLASS_VTABLE(tclass)->verify(tclass);
if (r < 0)
return r;
}
return 0;
}
void network_drop_invalid_tclass(Network *network) {
TClass *tclass;
assert(network);
HASHMAP_FOREACH(tclass, network->tclasses_by_section)
if (tclass_section_verify(tclass) < 0)
tclass_free(tclass);
}
int config_parse_tclass_parent(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = tclass_new_static(ltype, network, filename, section_line, &tclass);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to create traffic control class, ignoring assignment: %m");
return 0;
}
if (streq(rvalue, "root"))
tclass->parent = TC_H_ROOT;
else {
r = parse_handle(rvalue, &tclass->parent);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse 'Parent=', ignoring assignment: %s",
rvalue);
return 0;
}
}
TAKE_PTR(tclass);
return 0;
}
int config_parse_tclass_classid(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = tclass_new_static(ltype, network, filename, section_line, &tclass);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to create traffic control class, ignoring assignment: %m");
return 0;
}
if (isempty(rvalue)) {
tclass->classid = TC_H_UNSPEC;
TAKE_PTR(tclass);
return 0;
}
r = parse_handle(rvalue, &tclass->classid);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse 'ClassId=', ignoring assignment: %s",
rvalue);
return 0;
}
TAKE_PTR(tclass);
return 0;
}
| 18,284 | 29.173267 | 117 |
c
|
null |
systemd-main/src/network/tc/tclass.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc. */
#pragma once
#include "conf-parser.h"
#include "networkd-util.h"
typedef struct Link Link;
typedef struct Manager Manager;
typedef struct Network Network;
typedef enum TClassKind {
TCLASS_KIND_DRR,
TCLASS_KIND_HTB,
TCLASS_KIND_QFQ,
_TCLASS_KIND_MAX,
_TCLASS_KIND_INVALID = -EINVAL,
} TClassKind;
typedef struct TClass {
Link *link;
Network *network;
ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
uint32_t classid;
uint32_t parent;
TClassKind kind;
char *tca_kind;
} TClass;
typedef struct TClassVTable {
size_t object_size;
const char *tca_kind;
/* called in tclass_new() */
int (*init)(TClass *tclass);
int (*fill_message)(Link *link, TClass *tclass, sd_netlink_message *m);
int (*verify)(TClass *tclass);
} TClassVTable;
extern const TClassVTable * const tclass_vtable[_TCLASS_KIND_MAX];
#define TCLASS_VTABLE(t) ((t)->kind != _TCLASS_KIND_INVALID ? tclass_vtable[(t)->kind] : NULL)
/* For casting a tclass into the various tclass kinds */
#define DEFINE_TCLASS_CAST(UPPERCASE, MixedCase) \
static inline MixedCase* TCLASS_TO_##UPPERCASE(TClass *t) { \
if (_unlikely_(!t || t->kind != TCLASS_KIND_##UPPERCASE)) \
return NULL; \
\
return (MixedCase*) t; \
}
DEFINE_NETWORK_CONFIG_STATE_FUNCTIONS(TClass, tclass);
TClass* tclass_free(TClass *tclass);
int tclass_new_static(TClassKind kind, Network *network, const char *filename, unsigned section_line, TClass **ret);
int link_find_tclass(Link *link, uint32_t classid, TClass **ret);
int link_request_tclass(Link *link, TClass *tclass);
void network_drop_invalid_tclass(Network *network);
int manager_rtnl_process_tclass(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
DEFINE_SECTION_CLEANUP_FUNCTIONS(TClass, tclass_free);
CONFIG_PARSER_PROTOTYPE(config_parse_tclass_parent);
CONFIG_PARSER_PROTOTYPE(config_parse_tclass_classid);
#include "drr.h"
#include "htb.h"
#include "qfq.h"
| 2,386 | 30 | 116 |
h
|
null |
systemd-main/src/network/tc/teql.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "macro.h"
#include "networkd-link.h"
#include "parse-util.h"
#include "string-util.h"
#include "teql.h"
static int trivial_link_equalizer_verify(QDisc *qdisc) {
_cleanup_free_ char *tca_kind = NULL;
TrivialLinkEqualizer *teql;
teql = TEQL(ASSERT_PTR(qdisc));
if (asprintf(&tca_kind, "teql%u", teql->id) < 0)
return log_oom();
return free_and_replace(qdisc->tca_kind, tca_kind);
}
static int trivial_link_equalizer_is_ready(QDisc *qdisc, Link *link) {
Link *teql;
assert(qdisc);
assert(qdisc->tca_kind);
assert(link);
assert(link->manager);
if (link_get_by_name(link->manager, qdisc->tca_kind, &teql) < 0)
return false;
return link_is_ready_to_configure(teql, /* allow_unmanaged = */ true);
}
const QDiscVTable teql_vtable = {
.object_size = sizeof(TrivialLinkEqualizer),
.verify = trivial_link_equalizer_verify,
.is_ready = trivial_link_equalizer_is_ready,
};
int config_parse_trivial_link_equalizer_id(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
TrivialLinkEqualizer *teql;
Network *network = ASSERT_PTR(data);
unsigned id;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = qdisc_new_static(QDISC_KIND_TEQL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"More than one kind of queueing discipline, ignoring assignment: %m");
return 0;
}
teql = TEQL(qdisc);
if (isempty(rvalue)) {
teql->id = 0;
TAKE_PTR(qdisc);
return 0;
}
r = safe_atou(rvalue, &id);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse '%s=', ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
if (id > INT_MAX)
log_syntax(unit, LOG_WARNING, filename, line, 0,
"'%s=' is too large, ignoring assignment: %s",
lvalue, rvalue);
teql->id = id;
TAKE_PTR(qdisc);
return 0;
}
| 2,814 | 27.72449 | 97 |
c
|
null |
systemd-main/src/network/wait-online/link.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-network.h"
#include "alloc-util.h"
#include "format-util.h"
#include "hashmap.h"
#include "link.h"
#include "manager.h"
#include "string-util.h"
#include "strv.h"
int link_new(Manager *m, Link **ret, int ifindex, const char *ifname) {
_cleanup_(link_freep) Link *l = NULL;
_cleanup_free_ char *n = NULL;
int r;
assert(m);
assert(ifindex > 0);
assert(ifname);
n = strdup(ifname);
if (!n)
return -ENOMEM;
l = new(Link, 1);
if (!l)
return -ENOMEM;
*l = (Link) {
.manager = m,
.ifname = TAKE_PTR(n),
.ifindex = ifindex,
.required_operstate = LINK_OPERSTATE_RANGE_DEFAULT,
};
r = hashmap_ensure_put(&m->links_by_index, NULL, INT_TO_PTR(ifindex), l);
if (r < 0)
return r;
r = hashmap_ensure_put(&m->links_by_name, &string_hash_ops, l->ifname, l);
if (r < 0)
return r;
if (ret)
*ret = l;
TAKE_PTR(l);
return 0;
}
Link *link_free(Link *l) {
if (!l)
return NULL;
if (l->manager) {
hashmap_remove(l->manager->links_by_index, INT_TO_PTR(l->ifindex));
hashmap_remove(l->manager->links_by_name, l->ifname);
STRV_FOREACH(n, l->altnames)
hashmap_remove(l->manager->links_by_name, *n);
}
free(l->state);
free(l->ifname);
strv_free(l->altnames);
return mfree(l);
}
static int link_update_name(Link *l, sd_netlink_message *m) {
char ifname_from_index[IF_NAMESIZE];
const char *ifname;
int r;
assert(l);
assert(l->manager);
assert(m);
r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
if (r == -ENODATA)
/* Hmm? But ok. */
return 0;
if (r < 0)
return r;
if (streq(ifname, l->ifname))
return 0;
/* The kernel sometimes sends wrong ifname change. Let's confirm the received name. */
r = format_ifname(l->ifindex, ifname_from_index);
if (r < 0)
return r;
if (!streq(ifname, ifname_from_index)) {
log_link_debug(l, "New interface name '%s' received from the kernel does not correspond "
"with the name currently configured on the actual interface '%s'. Ignoring.",
ifname, ifname_from_index);
return 0;
}
hashmap_remove(l->manager->links_by_name, l->ifname);
r = free_and_strdup(&l->ifname, ifname);
if (r < 0)
return r;
r = hashmap_ensure_put(&l->manager->links_by_name, &string_hash_ops, l->ifname, l);
if (r < 0)
return r;
return 0;
}
static int link_update_altnames(Link *l, sd_netlink_message *m) {
_cleanup_strv_free_ char **altnames = NULL;
int r;
assert(l);
assert(l->manager);
assert(m);
r = sd_netlink_message_read_strv(m, IFLA_PROP_LIST, IFLA_ALT_IFNAME, &altnames);
if (r == -ENODATA)
/* The message does not have IFLA_PROP_LIST container attribute. It does not mean the
* interface has no alternative name. */
return 0;
if (r < 0)
return r;
if (strv_equal(altnames, l->altnames))
return 0;
STRV_FOREACH(n, l->altnames)
hashmap_remove(l->manager->links_by_name, *n);
strv_free_and_replace(l->altnames, altnames);
STRV_FOREACH(n, l->altnames) {
r = hashmap_ensure_put(&l->manager->links_by_name, &string_hash_ops, *n, l);
if (r < 0)
return r;
}
return 0;
}
int link_update_rtnl(Link *l, sd_netlink_message *m) {
int r;
assert(l);
assert(l->manager);
assert(m);
r = sd_rtnl_message_link_get_flags(m, &l->flags);
if (r < 0)
return r;
r = link_update_name(l, m);
if (r < 0)
return r;
r = link_update_altnames(l, m);
if (r < 0)
return r;
return 0;
}
int link_update_monitor(Link *l) {
_cleanup_free_ char *required_operstate = NULL, *required_family = NULL,
*ipv4_address_state = NULL, *ipv6_address_state = NULL, *state = NULL;
int r, ret = 0;
assert(l);
assert(l->ifname);
r = sd_network_link_get_required_for_online(l->ifindex);
if (r < 0 && r != -ENODATA)
ret = log_link_debug_errno(l, r, "Failed to determine whether the link is required for online or not, "
"assuming required: %m");
l->required_for_online = r != 0;
r = sd_network_link_get_required_operstate_for_online(l->ifindex, &required_operstate);
if (r < 0 && r != -ENODATA)
ret = log_link_debug_errno(l, r, "Failed to get required operational state, ignoring: %m");
if (isempty(required_operstate))
l->required_operstate = LINK_OPERSTATE_RANGE_DEFAULT;
else {
r = parse_operational_state_range(required_operstate, &l->required_operstate);
if (r < 0)
ret = log_link_debug_errno(l, SYNTHETIC_ERRNO(EINVAL),
"Failed to parse required operational state, ignoring: %m");
}
r = network_link_get_operational_state(l->ifindex, &l->operational_state);
if (r < 0)
ret = log_link_debug_errno(l, r, "Failed to get operational state, ignoring: %m");
r = sd_network_link_get_required_family_for_online(l->ifindex, &required_family);
if (r < 0 && r != -ENODATA)
ret = log_link_debug_errno(l, r, "Failed to get required address family, ignoring: %m");
if (isempty(required_family))
l->required_family = ADDRESS_FAMILY_NO;
else {
AddressFamily f;
f = link_required_address_family_from_string(required_family);
if (f < 0)
ret = log_link_debug_errno(l, f, "Failed to parse required address family, ignoring: %m");
else
l->required_family = f;
}
r = sd_network_link_get_ipv4_address_state(l->ifindex, &ipv4_address_state);
if (r < 0)
ret = log_link_debug_errno(l, r, "Failed to get IPv4 address state, ignoring: %m");
else {
LinkAddressState s;
s = link_address_state_from_string(ipv4_address_state);
if (s < 0)
ret = log_link_debug_errno(l, s, "Failed to parse IPv4 address state, ignoring: %m");
else
l->ipv4_address_state = s;
}
r = sd_network_link_get_ipv6_address_state(l->ifindex, &ipv6_address_state);
if (r < 0)
ret = log_link_debug_errno(l, r, "Failed to get IPv6 address state, ignoring: %m");
else {
LinkAddressState s;
s = link_address_state_from_string(ipv6_address_state);
if (s < 0)
ret = log_link_debug_errno(l, s, "Failed to parse IPv6 address state, ignoring: %m");
else
l->ipv6_address_state = s;
}
r = sd_network_link_get_setup_state(l->ifindex, &state);
if (r < 0)
ret = log_link_debug_errno(l, r, "Failed to get setup state, ignoring: %m");
else
free_and_replace(l->state, state);
return ret;
}
| 7,999 | 30.87251 | 119 |
c
|
null |
systemd-main/src/network/wait-online/link.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-netlink.h"
#include "log-link.h"
#include "network-util.h"
typedef struct Link Link;
typedef struct Manager Manager;
struct Link {
Manager *manager;
int ifindex;
char *ifname;
char **altnames;
unsigned flags;
bool required_for_online;
LinkOperationalStateRange required_operstate;
LinkOperationalState operational_state;
AddressFamily required_family;
LinkAddressState ipv4_address_state;
LinkAddressState ipv6_address_state;
char *state;
};
int link_new(Manager *m, Link **ret, int ifindex, const char *ifname);
Link *link_free(Link *l);
int link_update_rtnl(Link *l, sd_netlink_message *m);
int link_update_monitor(Link *l);
DEFINE_TRIVIAL_CLEANUP_FUNC(Link*, link_free);
| 853 | 23.4 | 70 |
h
|
null |
systemd-main/src/network/wait-online/manager.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <netinet/ether.h>
#include <linux/if.h>
#include <fnmatch.h>
#include "alloc-util.h"
#include "link.h"
#include "manager.h"
#include "netlink-util.h"
#include "strv.h"
#include "time-util.h"
static bool link_in_command_line_interfaces(Link *link, Manager *m) {
assert(link);
assert(m);
if (hashmap_contains(m->command_line_interfaces_by_name, link->ifname))
return true;
STRV_FOREACH(n, link->altnames)
if (hashmap_contains(m->command_line_interfaces_by_name, *n))
return true;
return false;
}
static bool manager_ignore_link(Manager *m, Link *link) {
assert(m);
assert(link);
/* always ignore the loopback interface */
if (link->flags & IFF_LOOPBACK)
return true;
/* if interfaces are given on the command line, ignore all others */
if (m->command_line_interfaces_by_name &&
!link_in_command_line_interfaces(link, m))
return true;
if (!link->required_for_online)
return true;
/* ignore interfaces we explicitly are asked to ignore */
if (strv_fnmatch(m->ignored_interfaces, link->ifname))
return true;
STRV_FOREACH(n, link->altnames)
if (strv_fnmatch(m->ignored_interfaces, *n))
return true;
return false;
}
static int manager_link_is_online(Manager *m, Link *l, LinkOperationalStateRange s) {
AddressFamily required_family;
bool needs_ipv4;
bool needs_ipv6;
assert(m);
assert(l);
/* This returns the following:
* -EAGAIN : not processed by udev
* -EBUSY : being processed by networkd
* -EADDRNOTAVAIL: requested conditions (operstate and/or addresses) are not satisfied
* false : unmanaged
* true : online */
if (!l->state || streq(l->state, "pending"))
/* If no state string exists, networkd (and possibly also udevd) has not detected the
* interface yet, that mean we cannot determine whether the interface is managed or
* not. Hence, return negative value.
* If the link is in pending state, then udevd has not processed the link, and networkd
* has not tried to find .network file for the link. Hence, return negative value. */
return log_link_debug_errno(l, SYNTHETIC_ERRNO(EAGAIN),
"link has not yet been processed by udev: setup state is %s.",
strna(l->state));
if (streq(l->state, "unmanaged")) {
/* If the link is in unmanaged state, then ignore the interface unless the interface is
* specified in '--interface/-i' option. */
if (!link_in_command_line_interfaces(l, m)) {
log_link_debug(l, "link is not managed by networkd.");
return false;
}
} else if (!streq(l->state, "configured"))
/* If the link is in non-configured state, return negative value here. */
return log_link_debug_errno(l, SYNTHETIC_ERRNO(EBUSY),
"link is being processed by networkd: setup state is %s.",
l->state);
if (s.min < 0)
s.min = m->required_operstate.min >= 0 ? m->required_operstate.min
: l->required_operstate.min;
if (s.max < 0)
s.max = m->required_operstate.max >= 0 ? m->required_operstate.max
: l->required_operstate.max;
if (l->operational_state < s.min || l->operational_state > s.max)
return log_link_debug_errno(l, SYNTHETIC_ERRNO(EADDRNOTAVAIL),
"Operational state '%s' is not in range ['%s':'%s']",
link_operstate_to_string(l->operational_state),
link_operstate_to_string(s.min), link_operstate_to_string(s.max));
required_family = m->required_family > 0 ? m->required_family : l->required_family;
needs_ipv4 = required_family & ADDRESS_FAMILY_IPV4;
needs_ipv6 = required_family & ADDRESS_FAMILY_IPV6;
if (s.min < LINK_OPERSTATE_ROUTABLE) {
if (needs_ipv4 && l->ipv4_address_state < LINK_ADDRESS_STATE_DEGRADED)
return log_link_debug_errno(l, SYNTHETIC_ERRNO(EADDRNOTAVAIL),
"No routable or link-local IPv4 address is configured.");
if (needs_ipv6 && l->ipv6_address_state < LINK_ADDRESS_STATE_DEGRADED)
return log_link_debug_errno(l, SYNTHETIC_ERRNO(EADDRNOTAVAIL),
"No routable or link-local IPv6 address is configured.");
} else {
if (needs_ipv4 && l->ipv4_address_state < LINK_ADDRESS_STATE_ROUTABLE)
return log_link_debug_errno(l, SYNTHETIC_ERRNO(EADDRNOTAVAIL),
"No routable IPv4 address is configured.");
if (needs_ipv6 && l->ipv6_address_state < LINK_ADDRESS_STATE_ROUTABLE)
return log_link_debug_errno(l, SYNTHETIC_ERRNO(EADDRNOTAVAIL),
"No routable IPv6 address is configured.");
}
log_link_debug(l, "link is configured by networkd and online.");
return true;
}
bool manager_configured(Manager *m) {
Link *l;
int r;
if (!hashmap_isempty(m->command_line_interfaces_by_name)) {
LinkOperationalStateRange *range;
const char *ifname;
/* wait for all the links given on the command line to appear */
HASHMAP_FOREACH_KEY(range, ifname, m->command_line_interfaces_by_name) {
l = hashmap_get(m->links_by_name, ifname);
if (!l) {
if (range->min == LINK_OPERSTATE_MISSING) {
if (m->any)
return true;
} else {
log_debug("still waiting for %s", ifname);
if (!m->any)
return false;
}
continue;
}
r = manager_link_is_online(m, l, *range);
if (r <= 0 && !m->any)
return false;
if (r > 0 && m->any)
return true;
}
/* With '--any' : no interface is ready → return false
* Without '--any': all interfaces are ready → return true */
return !m->any;
}
/* wait for all links networkd manages */
bool has_online = false;
HASHMAP_FOREACH(l, m->links_by_index) {
if (manager_ignore_link(m, l)) {
log_link_debug(l, "link is ignored");
continue;
}
r = manager_link_is_online(m, l,
(LinkOperationalStateRange) { _LINK_OPERSTATE_INVALID,
_LINK_OPERSTATE_INVALID });
if (r < 0 && !m->any) /* Unlike the above loop, unmanaged interfaces are ignored here. */
return false;
if (r > 0) {
if (m->any)
return true;
has_online = true;
}
}
/* With '--any' : no interface is ready → return false
* Without '--any': all interfaces are ready or unmanaged
*
* In this stage, drivers for interfaces may not be loaded yet, and there may be only lo.
* To avoid that wait-online exits earlier than that drivers are loaded, let's request at least one
* managed online interface exists. See issue #27822. */
return !m->any && has_online;
}
static int manager_process_link(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
uint16_t type;
Link *l;
const char *ifname;
int ifindex, r;
assert(rtnl);
assert(mm);
r = sd_netlink_message_get_type(mm, &type);
if (r < 0) {
log_warning_errno(r, "rtnl: Could not get message type, ignoring: %m");
return 0;
}
r = sd_rtnl_message_link_get_ifindex(mm, &ifindex);
if (r < 0) {
log_warning_errno(r, "rtnl: Could not get ifindex from link, ignoring: %m");
return 0;
} else if (ifindex <= 0) {
log_warning("rtnl: received link message with invalid ifindex %d, ignoring", ifindex);
return 0;
}
r = sd_netlink_message_read_string(mm, IFLA_IFNAME, &ifname);
if (r < 0) {
log_warning_errno(r, "rtnl: Received link message without ifname, ignoring: %m");
return 0;
}
l = hashmap_get(m->links_by_index, INT_TO_PTR(ifindex));
switch (type) {
case RTM_NEWLINK:
if (!l) {
log_debug("Found link %s(%i)", ifname, ifindex);
r = link_new(m, &l, ifindex, ifname);
if (r < 0) {
log_warning_errno(r, "Failed to create link object for %s(%i), ignoring: %m", ifname, ifindex);
return 0;
}
}
r = link_update_rtnl(l, mm);
if (r < 0)
log_link_warning_errno(l, r, "Failed to process RTNL link message, ignoring: %m");
r = link_update_monitor(l);
if (r < 0)
log_link_full_errno(l, IN_SET(r, -ENODATA, -ENOENT) ? LOG_DEBUG : LOG_WARNING, r,
"Failed to update link state, ignoring: %m");
break;
case RTM_DELLINK:
if (l) {
log_link_debug(l, "Removing link");
link_free(l);
}
break;
}
return 0;
}
static int on_rtnl_event(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
Manager *m = userdata;
int r;
r = manager_process_link(rtnl, mm, m);
if (r < 0)
return r;
if (manager_configured(m))
sd_event_exit(m->event, 0);
return 1;
}
static int manager_rtnl_listen(Manager *m) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
int r;
assert(m);
/* First, subscribe to interfaces coming and going */
r = sd_netlink_open(&m->rtnl);
if (r < 0)
return r;
r = sd_netlink_attach_event(m->rtnl, m->event, 0);
if (r < 0)
return r;
r = sd_netlink_add_match(m->rtnl, NULL, RTM_NEWLINK, on_rtnl_event, NULL, m, "wait-online-on-NEWLINK");
if (r < 0)
return r;
r = sd_netlink_add_match(m->rtnl, NULL, RTM_DELLINK, on_rtnl_event, NULL, m, "wait-online-on-DELLINK");
if (r < 0)
return r;
/* Then, enumerate all links */
r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
if (r < 0)
return r;
r = sd_netlink_message_set_request_dump(req, true);
if (r < 0)
return r;
r = sd_netlink_call(m->rtnl, req, 0, &reply);
if (r < 0)
return r;
for (sd_netlink_message *i = reply; i; i = sd_netlink_message_next(i)) {
r = manager_process_link(m->rtnl, i, m);
if (r < 0)
return r;
}
return r;
}
static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
Link *l;
int r;
sd_network_monitor_flush(m->network_monitor);
HASHMAP_FOREACH(l, m->links_by_index) {
r = link_update_monitor(l);
if (r < 0)
log_link_full_errno(l, IN_SET(r, -ENODATA, -ENOENT) ? LOG_DEBUG : LOG_WARNING, r,
"Failed to update link state, ignoring: %m");
}
if (manager_configured(m))
sd_event_exit(m->event, 0);
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 < 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_monitor_event_source,
fd, events, &on_network_event, m);
if (r < 0)
return r;
return 0;
}
int manager_new(Manager **ret,
Hashmap *command_line_interfaces_by_name,
char **ignored_interfaces,
LinkOperationalStateRange required_operstate,
AddressFamily required_family,
bool any,
usec_t timeout) {
_cleanup_(manager_freep) Manager *m = NULL;
int r;
assert(ret);
m = new(Manager, 1);
if (!m)
return -ENOMEM;
*m = (Manager) {
.command_line_interfaces_by_name = command_line_interfaces_by_name,
.ignored_interfaces = ignored_interfaces,
.required_operstate = required_operstate,
.required_family = required_family,
.any = any,
};
r = sd_event_default(&m->event);
if (r < 0)
return r;
(void) sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
(void) sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
if (timeout > 0) {
r = sd_event_add_time_relative(m->event, NULL, CLOCK_BOOTTIME, timeout, 0, NULL, INT_TO_PTR(-ETIMEDOUT));
if (r < 0 && r != -EOVERFLOW)
return r;
}
sd_event_set_watchdog(m->event, true);
r = manager_network_monitor_listen(m);
if (r < 0)
return r;
r = manager_rtnl_listen(m);
if (r < 0)
return r;
*ret = TAKE_PTR(m);
return 0;
}
Manager* manager_free(Manager *m) {
if (!m)
return NULL;
hashmap_free_with_destructor(m->links_by_index, link_free);
hashmap_free(m->links_by_name);
sd_event_source_unref(m->network_monitor_event_source);
sd_network_monitor_unref(m->network_monitor);
sd_event_source_unref(m->rtnl_event_source);
sd_netlink_unref(m->rtnl);
sd_event_unref(m->event);
return mfree(m);
}
| 15,936 | 35.220455 | 127 |
c
|
null |
systemd-main/src/network/wait-online/manager.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-event.h"
#include "sd-netlink.h"
#include "sd-network.h"
#include "hashmap.h"
#include "network-util.h"
#include "time-util.h"
typedef struct Manager Manager;
typedef struct Link Link;
struct Manager {
Hashmap *links_by_index;
Hashmap *links_by_name;
/* Do not free the two members below. */
Hashmap *command_line_interfaces_by_name;
char **ignored_interfaces;
LinkOperationalStateRange required_operstate;
AddressFamily required_family;
bool any;
sd_netlink *rtnl;
sd_event_source *rtnl_event_source;
sd_network_monitor *network_monitor;
sd_event_source *network_monitor_event_source;
sd_event *event;
};
Manager* manager_free(Manager *m);
int manager_new(Manager **ret, Hashmap *command_line_interfaces_by_name, char **ignored_interfaces,
LinkOperationalStateRange required_operstate,
AddressFamily required_family,
bool any, usec_t timeout);
DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
bool manager_configured(Manager *m);
| 1,174 | 25.111111 | 99 |
h
|
null |
systemd-main/src/network/wait-online/wait-online.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <getopt.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "sd-daemon.h"
#include "build.h"
#include "daemon-util.h"
#include "main-func.h"
#include "manager.h"
#include "pretty-print.h"
#include "signal-util.h"
#include "socket-util.h"
#include "strv.h"
static bool arg_quiet = false;
static usec_t arg_timeout = 120 * USEC_PER_SEC;
static Hashmap *arg_interfaces = NULL;
static char **arg_ignore = NULL;
static LinkOperationalStateRange arg_required_operstate = { _LINK_OPERSTATE_INVALID, _LINK_OPERSTATE_INVALID };
static AddressFamily arg_required_family = ADDRESS_FAMILY_NO;
static bool arg_any = false;
STATIC_DESTRUCTOR_REGISTER(arg_interfaces, hashmap_free_free_freep);
STATIC_DESTRUCTOR_REGISTER(arg_ignore, strv_freep);
static int help(void) {
_cleanup_free_ char *link = NULL;
int r;
r = terminal_urlify_man("systemd-networkd-wait-online.service", "8", &link);
if (r < 0)
return log_oom();
printf("%s [OPTIONS...]\n\n"
"Block until network is configured.\n\n"
" -h --help Show this help\n"
" --version Print version string\n"
" -q --quiet Do not show status information\n"
" -i --interface=INTERFACE[:MIN_OPERSTATE[:MAX_OPERSTATE]]\n"
" Block until at least these interfaces have appeared\n"
" --ignore=INTERFACE Don't take these interfaces into account\n"
" -o --operational-state=MIN_OPERSTATE[:MAX_OPERSTATE]\n"
" Required operational state\n"
" -4 --ipv4 Requires at least one IPv4 address\n"
" -6 --ipv6 Requires at least one IPv6 address\n"
" --any Wait until at least one of the interfaces is online\n"
" --timeout=SECS Maximum time to wait for network connectivity\n"
"\nSee the %s for details.\n",
program_invocation_short_name,
link);
return 0;
}
static int parse_interface_with_operstate_range(const char *str) {
_cleanup_free_ char *ifname = NULL;
_cleanup_free_ LinkOperationalStateRange *range = NULL;
const char *p;
int r;
assert(str);
range = new(LinkOperationalStateRange, 1);
if (!range)
return log_oom();
p = strchr(str, ':');
if (p) {
r = parse_operational_state_range(p + 1, range);
if (r < 0)
log_error_errno(r, "Invalid operational state range '%s'", p + 1);
ifname = strndup(optarg, p - optarg);
} else {
range->min = _LINK_OPERSTATE_INVALID;
range->max = _LINK_OPERSTATE_INVALID;
ifname = strdup(str);
}
if (!ifname)
return log_oom();
if (!ifname_valid(ifname))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid interface name '%s'", ifname);
r = hashmap_ensure_put(&arg_interfaces, &string_hash_ops, ifname, TAKE_PTR(range));
if (r == -ENOMEM)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to store interface name: %m");
if (r == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Interface name %s is already specified", ifname);
TAKE_PTR(ifname);
return 0;
}
static int parse_argv(int argc, char *argv[]) {
enum {
ARG_VERSION = 0x100,
ARG_IGNORE,
ARG_ANY,
ARG_TIMEOUT,
};
static const struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, ARG_VERSION },
{ "quiet", no_argument, NULL, 'q' },
{ "interface", required_argument, NULL, 'i' },
{ "ignore", required_argument, NULL, ARG_IGNORE },
{ "operational-state", required_argument, NULL, 'o' },
{ "ipv4", no_argument, NULL, '4' },
{ "ipv6", no_argument, NULL, '6' },
{ "any", no_argument, NULL, ARG_ANY },
{ "timeout", required_argument, NULL, ARG_TIMEOUT },
{}
};
int c, r;
assert(argc >= 0);
assert(argv);
while ((c = getopt_long(argc, argv, "hi:qo:46", options, NULL)) >= 0)
switch (c) {
case 'h':
help();
return 0;
case 'q':
arg_quiet = true;
break;
case ARG_VERSION:
return version();
case 'i':
r = parse_interface_with_operstate_range(optarg);
if (r < 0)
return r;
break;
case ARG_IGNORE:
if (strv_extend(&arg_ignore, optarg) < 0)
return log_oom();
break;
case 'o': {
LinkOperationalStateRange range;
r = parse_operational_state_range(optarg, &range);
if (r < 0)
return log_error_errno(r, "Invalid operational state range '%s'", optarg);
arg_required_operstate = range;
break;
}
case '4':
arg_required_family |= ADDRESS_FAMILY_IPV4;
break;
case '6':
arg_required_family |= ADDRESS_FAMILY_IPV6;
break;
case ARG_ANY:
arg_any = true;
break;
case ARG_TIMEOUT:
r = parse_sec(optarg, &arg_timeout);
if (r < 0)
return r;
break;
case '?':
return -EINVAL;
default:
assert_not_reached();
}
return 1;
}
static int run(int argc, char *argv[]) {
_cleanup_(manager_freep) Manager *m = NULL;
_unused_ _cleanup_(notify_on_cleanup) const char *notify_message = NULL;
int r;
log_setup();
umask(0022);
r = parse_argv(argc, argv);
if (r <= 0)
return r;
if (arg_quiet)
log_set_max_level(LOG_ERR);
assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, -1) >= 0);
r = manager_new(&m, arg_interfaces, arg_ignore, arg_required_operstate, arg_required_family, arg_any, arg_timeout);
if (r < 0)
return log_error_errno(r, "Could not create manager: %m");
if (manager_configured(m))
goto success;
notify_message = notify_start("READY=1\n"
"STATUS=Waiting for network connections...",
"STATUS=Failed to wait for network connectivity...");
r = sd_event_loop(m->event);
if (r == -ETIMEDOUT)
return log_error_errno(r, "Timeout occurred while waiting for network connectivity.");
if (r < 0)
return log_error_errno(r, "Event loop failed: %m");
success:
notify_message = "STATUS=All interfaces configured...";
return 0;
}
DEFINE_MAIN_FUNCTION(run);
| 8,144 | 33.079498 | 123 |
c
|
null |
systemd-main/src/nspawn/fuzz-nspawn-oci.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "fd-util.h"
#include "fuzz.h"
#include "nspawn-oci.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_(settings_freep) Settings *s = NULL;
if (outside_size_range(size, 0, 65536))
return 0;
f = data_to_file(data, size);
assert_se(f);
/* We don't want to fill the logs with messages about parse errors.
* Disable most logging if not running standalone */
if (!getenv("SYSTEMD_LOG_LEVEL"))
log_set_max_level(LOG_CRIT);
(void) oci_load(f, "/dev/null", &s);
return 0;
}
| 724 | 25.851852 | 75 |
c
|
null |
systemd-main/src/nspawn/fuzz-nspawn-settings.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "fd-util.h"
#include "fuzz.h"
#include "nspawn-settings.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_(settings_freep) Settings *s = NULL;
if (outside_size_range(size, 0, 65536))
return 0;
f = data_to_file(data, size);
assert_se(f);
/* We don't want to fill the logs with messages about parse errors.
* Disable most logging if not running standalone */
if (!getenv("SYSTEMD_LOG_LEVEL"))
log_set_max_level(LOG_CRIT);
(void) settings_load(f, "/dev/null", &s);
return 0;
}
| 734 | 26.222222 | 75 |
c
|
null |
systemd-main/src/nspawn/nspawn-expose-ports.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-netlink.h"
#include "af-list.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "firewall-util.h"
#include "in-addr-util.h"
#include "local-addresses.h"
#include "netlink-util.h"
#include "nspawn-expose-ports.h"
#include "parse-util.h"
#include "socket-util.h"
#include "string-util.h"
int expose_port_parse(ExposePort **l, const char *s) {
const char *split, *e;
uint16_t container_port, host_port;
ExposePort *port;
int protocol;
int r;
assert(l);
assert(s);
if ((e = startswith(s, "tcp:")))
protocol = IPPROTO_TCP;
else if ((e = startswith(s, "udp:")))
protocol = IPPROTO_UDP;
else {
e = s;
protocol = IPPROTO_TCP;
}
split = strchr(e, ':');
if (split) {
char v[split - e + 1];
memcpy(v, e, split - e);
v[split - e] = 0;
r = parse_ip_port(v, &host_port);
if (r < 0)
return -EINVAL;
r = parse_ip_port(split + 1, &container_port);
} else {
r = parse_ip_port(e, &container_port);
host_port = container_port;
}
if (r < 0)
return r;
LIST_FOREACH(ports, p, *l)
if (p->protocol == protocol && p->host_port == host_port)
return -EEXIST;
port = new(ExposePort, 1);
if (!port)
return -ENOMEM;
*port = (ExposePort) {
.protocol = protocol,
.host_port = host_port,
.container_port = container_port,
};
LIST_PREPEND(ports, *l, port);
return 0;
}
void expose_port_free_all(ExposePort *p) {
while (p) {
ExposePort *q = p;
LIST_REMOVE(ports, p, q);
free(q);
}
}
int expose_port_flush(FirewallContext **fw_ctx, ExposePort* l, int af, union in_addr_union *exposed) {
int r;
assert(exposed);
if (!l)
return 0;
if (!in_addr_is_set(af, exposed))
return 0;
log_debug("Lost IP address.");
LIST_FOREACH(ports, p, l) {
r = fw_add_local_dnat(fw_ctx,
false,
af,
p->protocol,
p->host_port,
exposed,
p->container_port,
NULL);
if (r < 0)
log_warning_errno(r, "Failed to modify %s firewall: %m", af_to_name(af));
}
*exposed = IN_ADDR_NULL;
return 0;
}
int expose_port_execute(sd_netlink *rtnl, FirewallContext **fw_ctx, ExposePort *l, int af, union in_addr_union *exposed) {
_cleanup_free_ struct local_address *addresses = NULL;
union in_addr_union new_exposed;
bool add;
int r;
assert(exposed);
/* Invoked each time an address is added or removed inside the
* container */
if (!l)
return 0;
r = local_addresses(rtnl, 0, af, &addresses);
if (r < 0)
return log_error_errno(r, "Failed to enumerate local addresses: %m");
add = r > 0 &&
addresses[0].family == af &&
addresses[0].scope < RT_SCOPE_LINK;
if (!add)
return expose_port_flush(fw_ctx, l, af, exposed);
new_exposed = addresses[0].address;
if (in_addr_equal(af, exposed, &new_exposed))
return 0;
log_debug("New container IP is %s.", IN_ADDR_TO_STRING(af, &new_exposed));
LIST_FOREACH(ports, p, l) {
r = fw_add_local_dnat(fw_ctx,
true,
af,
p->protocol,
p->host_port,
&new_exposed,
p->container_port,
in_addr_is_set(af, exposed) ? exposed : NULL);
if (r < 0)
log_warning_errno(r, "Failed to modify %s firewall: %m", af_to_name(af));
}
*exposed = new_exposed;
return 0;
}
int expose_port_send_rtnl(int send_fd) {
_cleanup_close_ int fd = -EBADF;
int r;
assert(send_fd >= 0);
fd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK, NETLINK_ROUTE);
if (fd < 0)
return log_error_errno(errno, "Failed to allocate container netlink: %m");
/* Store away the fd in the socket, so that it stays open as
* long as we run the child */
r = send_one_fd(send_fd, fd, 0);
if (r < 0)
return log_error_errno(r, "Failed to send netlink fd: %m");
return 0;
}
int expose_port_watch_rtnl(
sd_event *event,
int recv_fd,
sd_netlink_message_handler_t handler,
void *userdata,
sd_netlink **ret) {
_cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
int fd, r;
assert(event);
assert(recv_fd >= 0);
assert(ret);
fd = receive_one_fd(recv_fd, 0);
if (fd < 0)
return log_error_errno(fd, "Failed to recv netlink fd: %m");
r = sd_netlink_open_fd(&rtnl, fd);
if (r < 0) {
safe_close(fd);
return log_error_errno(r, "Failed to create rtnl object: %m");
}
r = sd_netlink_add_match(rtnl, NULL, RTM_NEWADDR, handler, NULL, userdata, "nspawn-NEWADDR");
if (r < 0)
return log_error_errno(r, "Failed to subscribe to RTM_NEWADDR messages: %m");
r = sd_netlink_add_match(rtnl, NULL, RTM_DELADDR, handler, NULL, userdata, "nspawn-DELADDR");
if (r < 0)
return log_error_errno(r, "Failed to subscribe to RTM_DELADDR messages: %m");
r = sd_netlink_attach_event(rtnl, event, 0);
if (r < 0)
return log_error_errno(r, "Failed to add to event loop: %m");
*ret = TAKE_PTR(rtnl);
return 0;
}
| 6,501 | 28.554545 | 122 |
c
|
null |
systemd-main/src/nspawn/nspawn-expose-ports.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include "sd-event.h"
#include "sd-netlink.h"
#include "firewall-util.h"
#include "in-addr-util.h"
#include "list.h"
typedef struct ExposePort {
int protocol;
uint16_t host_port;
uint16_t container_port;
LIST_FIELDS(struct ExposePort, ports);
} ExposePort;
void expose_port_free_all(ExposePort *p);
int expose_port_parse(ExposePort **l, const char *s);
int expose_port_watch_rtnl(sd_event *event, int recv_fd, sd_netlink_message_handler_t handler, void *userdata, sd_netlink **ret);
int expose_port_send_rtnl(int send_fd);
int expose_port_execute(sd_netlink *rtnl, FirewallContext **fw_ctx, ExposePort *l, int af, union in_addr_union *exposed);
int expose_port_flush(FirewallContext **fw_ctx, ExposePort* l, int af, union in_addr_union *exposed);
| 870 | 30.107143 | 129 |
h
|
null |
systemd-main/src/nspawn/nspawn-network.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <net/if.h>
#include <stdbool.h>
#include <sys/types.h>
int test_network_interfaces_initialized(char **iface_pairs);
int setup_veth(const char *machine_name, pid_t pid, char iface_name[IFNAMSIZ], bool bridge);
int setup_veth_extra(const char *machine_name, pid_t pid, char **pairs);
int setup_bridge(const char *veth_name, const char *bridge_name, bool create);
int remove_bridge(const char *bridge_name);
int setup_macvlan(const char *machine_name, pid_t pid, char **iface_pairs);
int setup_ipvlan(const char *machine_name, pid_t pid, char **iface_pairs);
int move_network_interfaces(int netns_fd, char **iface_pairs);
int veth_extra_parse(char ***l, const char *p);
int remove_veth_links(const char *primary, char **pairs);
int interface_pair_parse(char ***l, const char *p);
int macvlan_pair_parse(char ***l, const char *p);
int ipvlan_pair_parse(char ***l, const char *p);
| 956 | 33.178571 | 92 |
h
|
null |
systemd-main/src/nspawn/nspawn-register.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-bus.h"
#include "bus-error.h"
#include "bus-locator.h"
#include "bus-unit-util.h"
#include "bus-util.h"
#include "bus-wait-for-jobs.h"
#include "nspawn-register.h"
#include "special.h"
#include "stat-util.h"
#include "strv.h"
static int append_machine_properties(
sd_bus_message *m,
CustomMount *mounts,
unsigned n_mounts,
int kill_signal) {
unsigned j;
int r;
assert(m);
r = sd_bus_message_append(m, "(sv)", "DevicePolicy", "s", "closed");
if (r < 0)
return bus_log_create_error(r);
/* If you make changes here, also make sure to update [email protected], to keep the device policies in
* sync regardless if we are run with or without the --keep-unit switch. */
r = sd_bus_message_append(m, "(sv)", "DeviceAllow", "a(ss)", 2,
/* Allow the container to
* access and create the API
* device nodes, so that
* PrivateDevices= in the
* container can work
* fine */
"/dev/net/tun", "rwm",
/* Allow the container
* access to ptys. However,
* do not permit the
* container to ever create
* these device nodes. */
"char-pts", "rw");
if (r < 0)
return bus_log_create_error(r);
for (j = 0; j < n_mounts; j++) {
CustomMount *cm = mounts + j;
if (cm->type != CUSTOM_MOUNT_BIND)
continue;
r = is_device_node(cm->source);
if (r == -ENOENT) {
/* The bind source might only appear as the image is put together, hence don't complain */
log_debug_errno(r, "Bind mount source %s not found, ignoring: %m", cm->source);
continue;
}
if (r < 0)
return log_error_errno(r, "Failed to stat %s: %m", cm->source);
if (r) {
r = sd_bus_message_append(m, "(sv)", "DeviceAllow", "a(ss)", 1,
cm->source, cm->read_only ? "r" : "rw");
if (r < 0)
return log_error_errno(r, "Failed to append message arguments: %m");
}
}
if (kill_signal != 0) {
r = sd_bus_message_append(m, "(sv)", "KillSignal", "i", kill_signal);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "(sv)", "KillMode", "s", "mixed");
if (r < 0)
return bus_log_create_error(r);
}
return 0;
}
static int append_controller_property(sd_bus *bus, sd_bus_message *m) {
const char *unique;
int r;
assert(bus);
assert(m);
r = sd_bus_get_unique_name(bus, &unique);
if (r < 0)
return log_error_errno(r, "Failed to get unique name: %m");
r = sd_bus_message_append(m, "(sv)", "Controller", "s", unique);
if (r < 0)
return bus_log_create_error(r);
return 0;
}
int register_machine(
sd_bus *bus,
const char *machine_name,
pid_t pid,
const char *directory,
sd_id128_t uuid,
int local_ifindex,
const char *slice,
CustomMount *mounts,
unsigned n_mounts,
int kill_signal,
char **properties,
sd_bus_message *properties_message,
bool keep_unit,
const char *service) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert(bus);
if (keep_unit) {
r = bus_call_method(
bus,
bus_machine_mgr,
"RegisterMachineWithNetwork",
&error,
NULL,
"sayssusai",
machine_name,
SD_BUS_MESSAGE_APPEND_ID128(uuid),
service,
"container",
(uint32_t) pid,
strempty(directory),
local_ifindex > 0 ? 1 : 0, local_ifindex);
} else {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_machine_mgr, "CreateMachineWithNetwork");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(
m,
"sayssusai",
machine_name,
SD_BUS_MESSAGE_APPEND_ID128(uuid),
service,
"container",
(uint32_t) pid,
strempty(directory),
local_ifindex > 0 ? 1 : 0, local_ifindex);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_open_container(m, 'a', "(sv)");
if (r < 0)
return bus_log_create_error(r);
if (!isempty(slice)) {
r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
if (r < 0)
return bus_log_create_error(r);
}
r = append_controller_property(bus, m);
if (r < 0)
return r;
r = append_machine_properties(
m,
mounts,
n_mounts,
kill_signal);
if (r < 0)
return r;
if (properties_message) {
r = sd_bus_message_copy(m, properties_message, true);
if (r < 0)
return bus_log_create_error(r);
}
r = bus_append_unit_property_assignment_many(m, UNIT_SERVICE, properties);
if (r < 0)
return r;
r = sd_bus_message_close_container(m);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, 0, &error, NULL);
}
if (r < 0)
return log_error_errno(r, "Failed to register machine: %s", bus_error_message(&error, r));
return 0;
}
int unregister_machine(
sd_bus *bus,
const char *machine_name) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert(bus);
r = bus_call_method(bus, bus_machine_mgr, "UnregisterMachine", &error, NULL, "s", machine_name);
if (r < 0)
log_debug("Failed to unregister machine: %s", bus_error_message(&error, r));
return 0;
}
int allocate_scope(
sd_bus *bus,
const char *machine_name,
pid_t pid,
const char *slice,
CustomMount *mounts,
unsigned n_mounts,
int kill_signal,
char **properties,
sd_bus_message *properties_message) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *w = NULL;
_cleanup_free_ char *scope = NULL;
const char *description, *object;
int r;
assert(bus);
r = bus_wait_for_jobs_new(bus, &w);
if (r < 0)
return log_error_errno(r, "Could not watch job: %m");
r = unit_name_mangle_with_suffix(machine_name, "as machine name", 0, ".scope", &scope);
if (r < 0)
return log_error_errno(r, "Failed to mangle scope name: %m");
r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, "StartTransientUnit");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "ss", scope, "fail");
if (r < 0)
return bus_log_create_error(r);
/* Properties */
r = sd_bus_message_open_container(m, 'a', "(sv)");
if (r < 0)
return bus_log_create_error(r);
description = strjoina("Container ", machine_name);
r = sd_bus_message_append(m, "(sv)(sv)(sv)(sv)(sv)(sv)",
"PIDs", "au", 1, pid,
"Description", "s", description,
"Delegate", "b", 1,
"CollectMode", "s", "inactive-or-failed",
"AddRef", "b", 1,
"Slice", "s", isempty(slice) ? SPECIAL_MACHINE_SLICE : slice);
if (r < 0)
return bus_log_create_error(r);
r = append_controller_property(bus, m);
if (r < 0)
return r;
if (properties_message) {
r = sd_bus_message_copy(m, properties_message, true);
if (r < 0)
return bus_log_create_error(r);
}
r = append_machine_properties(
m,
mounts,
n_mounts,
kill_signal);
if (r < 0)
return r;
r = bus_append_unit_property_assignment_many(m, UNIT_SCOPE, properties);
if (r < 0)
return r;
r = sd_bus_message_close_container(m);
if (r < 0)
return bus_log_create_error(r);
/* No auxiliary units */
r = sd_bus_message_append(
m,
"a(sa(sv))",
0);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, 0, &error, &reply);
if (r < 0)
return log_error_errno(r, "Failed to allocate scope: %s", bus_error_message(&error, r));
r = sd_bus_message_read(reply, "o", &object);
if (r < 0)
return bus_log_parse_error(r);
r = bus_wait_for_jobs_one(w, object, false, NULL);
if (r < 0)
return r;
return 0;
}
int terminate_scope(
sd_bus *bus,
const char *machine_name) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *scope = NULL;
int r;
r = unit_name_mangle_with_suffix(machine_name, "to terminate", 0, ".scope", &scope);
if (r < 0)
return log_error_errno(r, "Failed to mangle scope name: %m");
r = bus_call_method(bus, bus_systemd_mgr, "AbandonScope", &error, NULL, "s", scope);
if (r < 0) {
log_debug_errno(r, "Failed to abandon scope '%s', ignoring: %s", scope, bus_error_message(&error, r));
sd_bus_error_free(&error);
}
r = bus_call_method(
bus,
bus_systemd_mgr,
"KillUnit",
&error,
NULL,
"ssi",
scope,
"all",
(int32_t) SIGKILL);
if (r < 0) {
log_debug_errno(r, "Failed to SIGKILL scope '%s', ignoring: %s", scope, bus_error_message(&error, r));
sd_bus_error_free(&error);
}
r = bus_call_method(bus, bus_systemd_mgr, "UnrefUnit", &error, NULL, "s", scope);
if (r < 0)
log_debug_errno(r, "Failed to drop reference to scope '%s', ignoring: %s", scope, bus_error_message(&error, r));
return 0;
}
| 12,789 | 34.429363 | 128 |
c
|
null |
systemd-main/src/nspawn/nspawn-settings.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <sched.h>
#include <stdio.h>
#if HAVE_SECCOMP
#include <seccomp.h>
#endif
#include "sd-bus.h"
#include "sd-id128.h"
#include "capability-util.h"
#include "conf-parser.h"
#include "cpu-set-util.h"
#include "macro.h"
#include "missing_resource.h"
#include "nspawn-expose-ports.h"
#include "nspawn-mount.h"
#include "time-util.h"
typedef enum StartMode {
START_PID1, /* Run parameters as command line as process 1 */
START_PID2, /* Use stub init process as PID 1, run parameters as command line as process 2 */
START_BOOT, /* Search for init system, pass arguments as parameters */
_START_MODE_MAX,
_START_MODE_INVALID = -EINVAL,
} StartMode;
typedef enum UserNamespaceMode {
USER_NAMESPACE_NO,
USER_NAMESPACE_FIXED,
USER_NAMESPACE_PICK,
_USER_NAMESPACE_MODE_MAX,
_USER_NAMESPACE_MODE_INVALID = -EINVAL,
} UserNamespaceMode;
typedef enum UserNamespaceOwnership {
USER_NAMESPACE_OWNERSHIP_OFF,
USER_NAMESPACE_OWNERSHIP_CHOWN,
USER_NAMESPACE_OWNERSHIP_MAP,
USER_NAMESPACE_OWNERSHIP_AUTO,
_USER_NAMESPACE_OWNERSHIP_MAX,
_USER_NAMESPACE_OWNERSHIP_INVALID = -1,
} UserNamespaceOwnership;
typedef enum ResolvConfMode {
RESOLV_CONF_OFF,
RESOLV_CONF_COPY_HOST, /* /etc/resolv.conf */
RESOLV_CONF_COPY_STATIC, /* /usr/lib/systemd/resolv.conf */
RESOLV_CONF_COPY_UPLINK, /* /run/systemd/resolve/resolv.conf */
RESOLV_CONF_COPY_STUB, /* /run/systemd/resolve/stub-resolv.conf */
RESOLV_CONF_REPLACE_HOST,
RESOLV_CONF_REPLACE_STATIC,
RESOLV_CONF_REPLACE_UPLINK,
RESOLV_CONF_REPLACE_STUB,
RESOLV_CONF_BIND_HOST,
RESOLV_CONF_BIND_STATIC,
RESOLV_CONF_BIND_UPLINK,
RESOLV_CONF_BIND_STUB,
RESOLV_CONF_DELETE,
RESOLV_CONF_AUTO,
_RESOLV_CONF_MODE_MAX,
_RESOLV_CONF_MODE_INVALID = -EINVAL,
} ResolvConfMode;
typedef enum LinkJournal {
LINK_NO,
LINK_AUTO,
LINK_HOST,
LINK_GUEST,
_LINK_JOURNAL_MAX,
_LINK_JOURNAL_INVALID = -EINVAL,
} LinkJournal;
typedef enum TimezoneMode {
TIMEZONE_OFF,
TIMEZONE_COPY,
TIMEZONE_BIND,
TIMEZONE_SYMLINK,
TIMEZONE_DELETE,
TIMEZONE_AUTO,
_TIMEZONE_MODE_MAX,
_TIMEZONE_MODE_INVALID = -EINVAL,
} TimezoneMode;
typedef enum ConsoleMode {
CONSOLE_INTERACTIVE,
CONSOLE_READ_ONLY,
CONSOLE_PASSIVE,
CONSOLE_PIPE,
_CONSOLE_MODE_MAX,
_CONSOLE_MODE_INVALID = -EINVAL,
} ConsoleMode;
typedef enum SettingsMask {
SETTING_START_MODE = UINT64_C(1) << 0,
SETTING_ENVIRONMENT = UINT64_C(1) << 1,
SETTING_USER = UINT64_C(1) << 2,
SETTING_CAPABILITY = UINT64_C(1) << 3,
SETTING_KILL_SIGNAL = UINT64_C(1) << 4,
SETTING_PERSONALITY = UINT64_C(1) << 5,
SETTING_MACHINE_ID = UINT64_C(1) << 6,
SETTING_NETWORK = UINT64_C(1) << 7,
SETTING_EXPOSE_PORTS = UINT64_C(1) << 8,
SETTING_READ_ONLY = UINT64_C(1) << 9,
SETTING_VOLATILE_MODE = UINT64_C(1) << 10,
SETTING_CUSTOM_MOUNTS = UINT64_C(1) << 11,
SETTING_WORKING_DIRECTORY = UINT64_C(1) << 12,
SETTING_USERNS = UINT64_C(1) << 13,
SETTING_NOTIFY_READY = UINT64_C(1) << 14,
SETTING_PIVOT_ROOT = UINT64_C(1) << 15,
SETTING_SYSCALL_FILTER = UINT64_C(1) << 16,
SETTING_HOSTNAME = UINT64_C(1) << 17,
SETTING_NO_NEW_PRIVILEGES = UINT64_C(1) << 18,
SETTING_OOM_SCORE_ADJUST = UINT64_C(1) << 19,
SETTING_CPU_AFFINITY = UINT64_C(1) << 20,
SETTING_RESOLV_CONF = UINT64_C(1) << 21,
SETTING_LINK_JOURNAL = UINT64_C(1) << 22,
SETTING_TIMEZONE = UINT64_C(1) << 23,
SETTING_EPHEMERAL = UINT64_C(1) << 24,
SETTING_SLICE = UINT64_C(1) << 25,
SETTING_DIRECTORY = UINT64_C(1) << 26,
SETTING_USE_CGNS = UINT64_C(1) << 27,
SETTING_CLONE_NS_FLAGS = UINT64_C(1) << 28,
SETTING_CONSOLE_MODE = UINT64_C(1) << 29,
SETTING_CREDENTIALS = UINT64_C(1) << 30,
SETTING_BIND_USER = UINT64_C(1) << 31,
SETTING_SUPPRESS_SYNC = UINT64_C(1) << 32,
SETTING_RLIMIT_FIRST = UINT64_C(1) << 33, /* we define one bit per resource limit here */
SETTING_RLIMIT_LAST = UINT64_C(1) << (33 + _RLIMIT_MAX - 1),
_SETTINGS_MASK_ALL = (UINT64_C(1) << (33 + _RLIMIT_MAX)) -1,
_SETTING_FORCE_ENUM_WIDTH = UINT64_MAX
} SettingsMask;
/* We want to use SETTING_RLIMIT_FIRST in shifts, so make sure it is really 64 bits
* when used in expressions. */
#define SETTING_RLIMIT_FIRST ((uint64_t) SETTING_RLIMIT_FIRST)
#define SETTING_RLIMIT_LAST ((uint64_t) SETTING_RLIMIT_LAST)
assert_cc(sizeof(SettingsMask) == 8);
assert_cc(sizeof(SETTING_RLIMIT_FIRST) == 8);
assert_cc(sizeof(SETTING_RLIMIT_LAST) == 8);
typedef struct DeviceNode {
char *path;
unsigned major;
unsigned minor;
mode_t mode;
uid_t uid;
gid_t gid;
} DeviceNode;
typedef struct OciHook {
char *path;
char **args;
char **env;
usec_t timeout;
} OciHook;
typedef struct Settings {
/* [Exec] */
StartMode start_mode;
int ephemeral;
char **parameters;
char **environment;
char *user;
uint64_t capability;
uint64_t drop_capability;
uint64_t ambient_capability;
int kill_signal;
unsigned long personality;
sd_id128_t machine_id;
char *working_directory;
char *pivot_root_new;
char *pivot_root_old;
UserNamespaceMode userns_mode;
uid_t uid_shift, uid_range;
int notify_ready;
char **syscall_allow_list;
char **syscall_deny_list;
struct rlimit *rlimit[_RLIMIT_MAX];
char *hostname;
int no_new_privileges;
int oom_score_adjust;
bool oom_score_adjust_set;
CPUSet cpu_set;
ResolvConfMode resolv_conf;
LinkJournal link_journal;
bool link_journal_try;
TimezoneMode timezone;
int suppress_sync;
/* [Files] */
int read_only;
VolatileMode volatile_mode;
CustomMount *custom_mounts;
size_t n_custom_mounts;
UserNamespaceOwnership userns_ownership;
char **bind_user;
/* [Network] */
int private_network;
int network_veth;
char *network_bridge;
char *network_zone;
char **network_interfaces;
char **network_macvlan;
char **network_ipvlan;
char **network_veth_extra;
ExposePort *expose_ports;
/* Additional fields, that are specific to OCI runtime case */
char *bundle;
char *root;
OciHook *oci_hooks_prestart, *oci_hooks_poststart, *oci_hooks_poststop;
size_t n_oci_hooks_prestart, n_oci_hooks_poststart, n_oci_hooks_poststop;
char *slice;
sd_bus_message *properties;
CapabilityQuintet full_capabilities;
uid_t uid;
gid_t gid;
gid_t *supplementary_gids;
size_t n_supplementary_gids;
unsigned console_width, console_height;
ConsoleMode console_mode;
DeviceNode *extra_nodes;
size_t n_extra_nodes;
unsigned long clone_ns_flags;
char *network_namespace_path;
int use_cgns;
char **sysctl;
#if HAVE_SECCOMP
scmp_filter_ctx seccomp;
#endif
} Settings;
Settings *settings_new(void);
int settings_load(FILE *f, const char *path, Settings **ret);
Settings* settings_free(Settings *s);
bool settings_network_veth(Settings *s);
bool settings_private_network(Settings *s);
bool settings_network_configured(Settings *s);
int settings_allocate_properties(Settings *s);
DEFINE_TRIVIAL_CLEANUP_FUNC(Settings*, settings_free);
const struct ConfigPerfItem* nspawn_gperf_lookup(const char *key, GPERF_LEN_TYPE length);
CONFIG_PARSER_PROTOTYPE(config_parse_capability);
CONFIG_PARSER_PROTOTYPE(config_parse_expose_port);
CONFIG_PARSER_PROTOTYPE(config_parse_volatile_mode);
CONFIG_PARSER_PROTOTYPE(config_parse_pivot_root);
CONFIG_PARSER_PROTOTYPE(config_parse_bind);
CONFIG_PARSER_PROTOTYPE(config_parse_tmpfs);
CONFIG_PARSER_PROTOTYPE(config_parse_overlay);
CONFIG_PARSER_PROTOTYPE(config_parse_inaccessible);
CONFIG_PARSER_PROTOTYPE(config_parse_veth_extra);
CONFIG_PARSER_PROTOTYPE(config_parse_network_iface_pair);
CONFIG_PARSER_PROTOTYPE(config_parse_macvlan_iface_pair);
CONFIG_PARSER_PROTOTYPE(config_parse_ipvlan_iface_pair);
CONFIG_PARSER_PROTOTYPE(config_parse_network_zone);
CONFIG_PARSER_PROTOTYPE(config_parse_boot);
CONFIG_PARSER_PROTOTYPE(config_parse_pid2);
CONFIG_PARSER_PROTOTYPE(config_parse_private_users);
CONFIG_PARSER_PROTOTYPE(config_parse_syscall_filter);
CONFIG_PARSER_PROTOTYPE(config_parse_oom_score_adjust);
CONFIG_PARSER_PROTOTYPE(config_parse_cpu_affinity);
CONFIG_PARSER_PROTOTYPE(config_parse_resolv_conf);
CONFIG_PARSER_PROTOTYPE(config_parse_link_journal);
CONFIG_PARSER_PROTOTYPE(config_parse_timezone);
CONFIG_PARSER_PROTOTYPE(config_parse_userns_chown);
CONFIG_PARSER_PROTOTYPE(config_parse_userns_ownership);
CONFIG_PARSER_PROTOTYPE(config_parse_bind_user);
const char *resolv_conf_mode_to_string(ResolvConfMode a) _const_;
ResolvConfMode resolv_conf_mode_from_string(const char *s) _pure_;
const char *timezone_mode_to_string(TimezoneMode a) _const_;
TimezoneMode timezone_mode_from_string(const char *s) _pure_;
const char *user_namespace_ownership_to_string(UserNamespaceOwnership a) _const_;
UserNamespaceOwnership user_namespace_ownership_from_string(const char *s) _pure_;
int parse_link_journal(const char *s, LinkJournal *ret_mode, bool *ret_try);
void device_node_array_free(DeviceNode *node, size_t n);
| 10,138 | 33.841924 | 102 |
h
|
null |
systemd-main/src/nspawn/nspawn-setuid.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include "alloc-util.h"
#include "constants.h"
#include "errno.h"
#include "fd-util.h"
#include "fileio.h"
#include "mkdir.h"
#include "nspawn-setuid.h"
#include "process-util.h"
#include "signal-util.h"
#include "string-util.h"
#include "strv.h"
#include "user-util.h"
static int spawn_getent(const char *database, const char *key, pid_t *rpid) {
int pipe_fds[2], r;
pid_t pid;
assert(database);
assert(key);
assert(rpid);
if (pipe2(pipe_fds, O_CLOEXEC) < 0)
return log_error_errno(errno, "Failed to allocate pipe: %m");
r = safe_fork_full("(getent)",
(int[]) { -EBADF, pipe_fds[1], -EBADF }, NULL, 0,
FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG|FORK_REARRANGE_STDIO|FORK_LOG|FORK_RLIMIT_NOFILE_SAFE,
&pid);
if (r < 0) {
safe_close_pair(pipe_fds);
return r;
}
if (r == 0) {
execle("/usr/bin/getent", "getent", database, key, NULL, &(char*[1]){});
execle("/bin/getent", "getent", database, key, NULL, &(char*[1]){});
_exit(EXIT_FAILURE);
}
pipe_fds[1] = safe_close(pipe_fds[1]);
*rpid = pid;
return pipe_fds[0];
}
int change_uid_gid_raw(
uid_t uid,
gid_t gid,
const gid_t *supplementary_gids,
size_t n_supplementary_gids,
bool chown_stdio) {
if (!uid_is_valid(uid))
uid = 0;
if (!gid_is_valid(gid))
gid = 0;
if (chown_stdio) {
(void) fchown(STDIN_FILENO, uid, gid);
(void) fchown(STDOUT_FILENO, uid, gid);
(void) fchown(STDERR_FILENO, uid, gid);
}
if (setgroups(n_supplementary_gids, supplementary_gids) < 0)
return log_error_errno(errno, "Failed to set auxiliary groups: %m");
if (setresgid(gid, gid, gid) < 0)
return log_error_errno(errno, "setresgid() failed: %m");
if (setresuid(uid, uid, uid) < 0)
return log_error_errno(errno, "setresuid() failed: %m");
return 0;
}
int change_uid_gid(const char *user, bool chown_stdio, char **ret_home) {
char *x, *u, *g, *h;
_cleanup_free_ gid_t *gids = NULL;
_cleanup_free_ char *home = NULL, *line = NULL;
_cleanup_fclose_ FILE *f = NULL;
_cleanup_close_ int fd = -EBADF;
unsigned n_gids = 0;
uid_t uid;
gid_t gid;
pid_t pid;
int r;
assert(ret_home);
if (!user || STR_IN_SET(user, "root", "0")) {
/* Reset everything fully to 0, just in case */
r = reset_uid_gid();
if (r < 0)
return log_error_errno(r, "Failed to become root: %m");
*ret_home = NULL;
return 0;
}
/* First, get user credentials */
fd = spawn_getent("passwd", user, &pid);
if (fd < 0)
return fd;
f = take_fdopen(&fd, "r");
if (!f)
return log_oom();
r = read_line(f, LONG_LINE_MAX, &line);
if (r == 0)
return log_error_errno(SYNTHETIC_ERRNO(ESRCH),
"Failed to resolve user %s.", user);
if (r < 0)
return log_error_errno(r, "Failed to read from getent: %m");
(void) wait_for_terminate_and_check("getent passwd", pid, WAIT_LOG);
x = strchr(line, ':');
if (!x)
return log_error_errno(SYNTHETIC_ERRNO(EIO),
"/etc/passwd entry has invalid user field.");
u = strchr(x+1, ':');
if (!u)
return log_error_errno(SYNTHETIC_ERRNO(EIO),
"/etc/passwd entry has invalid password field.");
u++;
g = strchr(u, ':');
if (!g)
return log_error_errno(SYNTHETIC_ERRNO(EIO),
"/etc/passwd entry has invalid UID field.");
*g = 0;
g++;
x = strchr(g, ':');
if (!x)
return log_error_errno(SYNTHETIC_ERRNO(EIO),
"/etc/passwd entry has invalid GID field.");
*x = 0;
h = strchr(x+1, ':');
if (!h)
return log_error_errno(SYNTHETIC_ERRNO(EIO),
"/etc/passwd entry has invalid GECOS field.");
h++;
x = strchr(h, ':');
if (!x)
return log_error_errno(SYNTHETIC_ERRNO(EIO),
"/etc/passwd entry has invalid home directory field.");
*x = 0;
r = parse_uid(u, &uid);
if (r < 0)
return log_error_errno(SYNTHETIC_ERRNO(EIO),
"Failed to parse UID of user.");
r = parse_gid(g, &gid);
if (r < 0)
return log_error_errno(SYNTHETIC_ERRNO(EIO),
"Failed to parse GID of user.");
home = strdup(h);
if (!home)
return log_oom();
f = safe_fclose(f);
line = mfree(line);
/* Second, get group memberships */
fd = spawn_getent("initgroups", user, &pid);
if (fd < 0)
return fd;
f = take_fdopen(&fd, "r");
if (!f)
return log_oom();
r = read_line(f, LONG_LINE_MAX, &line);
if (r == 0)
return log_error_errno(SYNTHETIC_ERRNO(ESRCH),
"Failed to resolve user %s.", user);
if (r < 0)
return log_error_errno(r, "Failed to read from getent: %m");
(void) wait_for_terminate_and_check("getent initgroups", pid, WAIT_LOG);
/* Skip over the username and subsequent separator whitespace */
x = line;
x += strcspn(x, WHITESPACE);
x += strspn(x, WHITESPACE);
for (const char *p = x;;) {
_cleanup_free_ char *word = NULL;
r = extract_first_word(&p, &word, NULL, 0);
if (r < 0)
return log_error_errno(r, "Failed to parse group data from getent: %m");
if (r == 0)
break;
if (!GREEDY_REALLOC(gids, n_gids+1))
return log_oom();
r = parse_gid(word, &gids[n_gids++]);
if (r < 0)
return log_error_errno(r, "Failed to parse group data from getent: %m");
}
r = mkdir_parents(home, 0775);
if (r < 0)
return log_error_errno(r, "Failed to make home root directory: %m");
r = mkdir_safe(home, 0755, uid, gid, 0);
if (r < 0 && !IN_SET(r, -EEXIST, -ENOTDIR))
return log_error_errno(r, "Failed to make home directory: %m");
r = change_uid_gid_raw(uid, gid, gids, n_gids, chown_stdio);
if (r < 0)
return r;
if (ret_home)
*ret_home = TAKE_PTR(home);
return 0;
}
| 7,410 | 30.402542 | 133 |
c
|
null |
systemd-main/src/nspawn/nspawn-stub-pid1.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <sys/ioctl.h>
#include <sys/reboot.h>
#include <sys/wait.h>
#include <sys/prctl.h>
#include <unistd.h>
#include "argv-util.h"
#include "constants.h"
#include "exit-status.h"
#include "fd-util.h"
#include "log.h"
#include "nspawn-stub-pid1.h"
#include "process-util.h"
#include "signal-util.h"
#include "time-util.h"
static int reset_environ(const char *new_environment, size_t length) {
unsigned long start, end;
start = (unsigned long) new_environment;
end = start + length;
if (prctl(PR_SET_MM, PR_SET_MM_ENV_START, start, 0, 0) < 0)
return -errno;
if (prctl(PR_SET_MM, PR_SET_MM_ENV_END, end, 0, 0) < 0)
return -errno;
return 0;
}
int stub_pid1(sd_id128_t uuid) {
enum {
STATE_RUNNING,
STATE_REBOOT,
STATE_POWEROFF,
} state = STATE_RUNNING;
sigset_t fullmask, oldmask, waitmask;
usec_t quit_usec = USEC_INFINITY;
pid_t pid;
int r;
/* The new environment we set up, on the stack. */
char new_environment[] =
"container=systemd-nspawn\0"
"container_uuid=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
/* Implements a stub PID 1, that reaps all processes and processes a couple of standard signals. This is useful
* for allowing arbitrary processes run in a container, and still have all zombies reaped. */
assert_se(sigfillset(&fullmask) >= 0);
assert_se(sigprocmask(SIG_BLOCK, &fullmask, &oldmask) >= 0);
pid = fork();
if (pid < 0)
return log_error_errno(errno, "Failed to fork child pid: %m");
if (pid == 0) {
/* Return in the child */
assert_se(sigprocmask(SIG_SETMASK, &oldmask, NULL) >= 0);
if (setsid() < 0)
return log_error_errno(errno, "Failed to become session leader in payload process: %m");
return 0;
}
reset_all_signal_handlers();
log_close();
(void) close_all_fds(NULL, 0);
log_open();
if (ioctl(STDIN_FILENO, TIOCNOTTY) < 0) {
if (errno != ENOTTY)
log_warning_errno(errno, "Unexpected error from TIOCNOTTY ioctl in init stub process, ignoring: %m");
} else
log_warning("Expected TIOCNOTTY to fail, but it succeeded in init stub process, ignoring.");
/* Flush out /proc/self/environ, so that we don't leak the environment from the host into the container. Also,
* set $container= and $container_uuid= so that clients in the container that query it from /proc/1/environ
* find them set. */
sd_id128_to_string(uuid, new_environment + sizeof(new_environment) - SD_ID128_STRING_MAX);
reset_environ(new_environment, sizeof(new_environment));
(void) rename_process("(sd-stubinit)");
assert_se(sigemptyset(&waitmask) >= 0);
assert_se(sigset_add_many(&waitmask,
SIGCHLD, /* posix: process died */
SIGINT, /* sysv: ctrl-alt-del */
SIGRTMIN+3, /* systemd: halt */
SIGRTMIN+4, /* systemd: poweroff */
SIGRTMIN+5, /* systemd: reboot */
SIGRTMIN+6, /* systemd: kexec */
SIGRTMIN+13, /* systemd: halt */
SIGRTMIN+14, /* systemd: poweroff */
SIGRTMIN+15, /* systemd: reboot */
SIGRTMIN+16, /* systemd: kexec */
-1) >= 0);
/* Note that we ignore SIGTERM (sysv's reexec), SIGHUP (reload), and all other signals here, since we don't
* support reexec/reloading in this stub process. */
for (;;) {
siginfo_t si;
usec_t current_usec;
si.si_pid = 0;
r = waitid(P_ALL, 0, &si, WEXITED|WNOHANG);
if (r < 0) {
r = log_error_errno(errno, "Failed to reap children: %m");
goto finish;
}
current_usec = now(CLOCK_MONOTONIC);
if (si.si_pid == pid || current_usec >= quit_usec) {
/* The child we started ourselves died or we reached a timeout. */
if (state == STATE_REBOOT) { /* dispatch a queued reboot */
(void) reboot(RB_AUTOBOOT);
r = log_error_errno(errno, "Failed to reboot: %m");
goto finish;
} else if (state == STATE_POWEROFF)
(void) reboot(RB_POWER_OFF); /* if this fails, fall back to normal exit. */
if (si.si_pid == pid && si.si_code == CLD_EXITED)
r = si.si_status; /* pass on exit code */
else
r = EXIT_EXCEPTION; /* signal, coredump, timeout, … */
goto finish;
}
if (si.si_pid != 0)
/* We reaped something. Retry until there's nothing more to reap. */
continue;
if (quit_usec == USEC_INFINITY)
r = sigwaitinfo(&waitmask, &si);
else
r = sigtimedwait(&waitmask, &si, TIMESPEC_STORE(quit_usec - current_usec));
if (r < 0) {
if (errno == EINTR) /* strace -p attach can result in EINTR, let's handle this nicely. */
continue;
if (errno == EAGAIN) /* timeout reached */
continue;
r = log_error_errno(errno, "Failed to wait for signal: %m");
goto finish;
}
if (si.si_signo == SIGCHLD)
continue; /* Let's reap this */
if (state != STATE_RUNNING)
continue;
/* Would love to use a switch() statement here, but SIGRTMIN is actually a function call, not a
* constant… */
if (si.si_signo == SIGRTMIN+3 ||
si.si_signo == SIGRTMIN+4 ||
si.si_signo == SIGRTMIN+13 ||
si.si_signo == SIGRTMIN+14)
state = STATE_POWEROFF;
else if (si.si_signo == SIGINT ||
si.si_signo == SIGRTMIN+5 ||
si.si_signo == SIGRTMIN+6 ||
si.si_signo == SIGRTMIN+15 ||
si.si_signo == SIGRTMIN+16)
state = STATE_REBOOT;
else
assert_not_reached();
r = kill_and_sigcont(pid, SIGTERM);
/* Let's send a SIGHUP after the SIGTERM, as shells tend to ignore SIGTERM but do react to SIGHUP. We
* do it strictly in this order, so that the SIGTERM is dispatched first, and SIGHUP second for those
* processes which handle both. That's because services tend to bind configuration reload or something
* else to SIGHUP. */
if (r != -ESRCH)
(void) kill(pid, SIGHUP);
quit_usec = now(CLOCK_MONOTONIC) + DEFAULT_TIMEOUT_USEC;
}
finish:
_exit(r < 0 ? EXIT_FAILURE : r);
}
| 7,838 | 38.195 | 125 |
c
|
null |
systemd-main/src/nspawn/nspawn-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "glob-util.h"
#include "log.h"
#include "nspawn-util.h"
#include "parse-util.h"
#include "path-util.h"
#include "string-util.h"
int systemd_installation_has_version(const char *root, const char *minimal_version) {
int r;
/* Try to guess if systemd installation is later than the specified version. This
* is hacky and likely to yield false negatives, particularly if the installation
* is non-standard. False positives should be relatively rare.
*/
FOREACH_STRING(pattern,
/* /lib works for systems without usr-merge, and for systems with a sane
* usr-merge, where /lib is a symlink to /usr/lib. /usr/lib is necessary
* for Gentoo which does a merge without making /lib a symlink.
* Also support multiarch paths von Debian/Ubuntu; *-linux-* is a small
* optimization based on the naming scheme of existing multiarch tuples.
*/
"/lib/systemd/libsystemd-shared-*.so",
"/lib64/systemd/libsystemd-shared-*.so",
"/usr/lib/*-linux-*/systemd/libsystemd-shared-*.so",
"/usr/lib/systemd/libsystemd-shared-*.so",
"/usr/lib64/systemd/libsystemd-shared-*.so") {
_cleanup_strv_free_ char **names = NULL;
_cleanup_free_ char *path = NULL;
char *c;
path = path_join(root, pattern);
if (!path)
return -ENOMEM;
r = glob_extend(&names, path, 0);
if (r == -ENOENT)
continue;
if (r < 0)
return r;
assert_se(c = endswith(path, "*.so"));
*c = '\0'; /* truncate the glob part */
STRV_FOREACH(name, names) {
_cleanup_free_ char *bn = NULL;
/* This is most likely to run only once, hence let's not optimize anything. */
char *t, *t2;
if (path_extract_filename(*name, &bn) < 0)
continue;
t = startswith(bn, "libsystemd-shared-");
if (!t)
continue;
t2 = endswith(t, ".so");
if (!t2)
continue;
*t2 = '\0';
r = strverscmp_improved(t, minimal_version);
log_debug("Found libsystemd shared at \"%s.so\", version %s (%s).",
*name, t,
r >= 0 ? "OK" : "too old");
if (r >= 0)
return true;
}
}
return false;
}
| 3,043 | 38.532468 | 102 |
c
|
null |
systemd-main/src/nspawn/test-nspawn-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "nspawn-util.h"
#include "string-util.h"
#include "strv.h"
#include "tests.h"
TEST(systemd_installation_has_version) {
int r;
FOREACH_STRING(version, "0", "231", STRINGIFY(PROJECT_VERSION), "999") {
r = systemd_installation_has_version(saved_argv[1], version);
assert_se(r >= 0);
log_info("%s has systemd >= %s: %s",
saved_argv[1] ?: "Current installation", version, yes_no(r));
}
}
/* This program can be called with a path to an installation root.
* For example: build/test-nspawn-util /var/lib/machines/rawhide
*/
DEFINE_TEST_MAIN(LOG_DEBUG);
| 707 | 29.782609 | 86 |
c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.