shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2025-03-28 02:50:16 +03:00
Code

Merge pull request #22014 from keszybz/networkd-reduce-append-logging

Browse Source 
Drop detailed error messages for netlink message append operations
This commit is contained in:
Yu Watanabe 2022-01-06 01:17:09 +09:00 committed by GitHub
commit defb4dd429
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
50 changed files with 847 additions and 788 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libsystemd/sd-device/test-sd-device-monitor.c
View File

@ -302,7 +302,7 @@ int main(int argc, char *argv[]) {
r = test_receive_device_fail();
if (r < 0) {
assert_se(r == -EPERM && detect_container() > 0);
return log_tests_skipped("Running in container? Skipping remaining tests");
return log_tests_skipped("Running in container");
}
assert_se(sd_device_new_from_syspath(&loopback, "/sys/class/net/lo") >= 0);

4
src/network/netdev/bareudp.c
View File

@ -33,11 +33,11 @@ static int netdev_bare_udp_fill_message_create(NetDev *netdev, Link *link, sd_ne
r = sd_netlink_message_append_u16(m, IFLA_BAREUDP_ETHERTYPE, htobe16(u->iftype));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BAREUDP_ETHERTYPE attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_BAREUDP_PORT, htobe16(u->dest_port));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BAREUDP_PORT attribute: %m");
return r;
return 0;
}

55
src/network/netdev/batadv.c
View File

@ -114,64 +114,73 @@ static int netdev_batman_set_handler(sd_netlink *rtnl, sd_netlink_message *m, Ne
return 1;
}
static int netdev_batadv_post_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
static int netdev_batadv_post_create_message(NetDev *netdev, sd_netlink_message *message) {
BatmanAdvanced *b;
int r;
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *message = NULL;
assert(netdev);
b = BATADV(netdev);
assert(b);
r = sd_genl_message_new(netdev->manager->genl, BATADV_NL_NAME, BATADV_CMD_SET_MESH, &message);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to allocate generic netlink message: %m");
assert_se(b = BATADV(netdev));
r = sd_netlink_message_append_u32(message, BATADV_ATTR_MESH_IFINDEX, netdev->ifindex);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set ifindex: %m");
return r;
r = sd_netlink_message_append_u8(message, BATADV_ATTR_GW_MODE, b->gateway_mode);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set gateway_mode: %m");
return r;
r = sd_netlink_message_append_u8(message, BATADV_ATTR_AGGREGATED_OGMS_ENABLED, b->aggregation);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set aggregation: %m");
return r;
r = sd_netlink_message_append_u8(message, BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED, b->bridge_loop_avoidance);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set bridge_loop_avoidance: %m");
return r;
r = sd_netlink_message_append_u8(message, BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED, b->distributed_arp_table);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set distributed_arp_table: %m");
return r;
r = sd_netlink_message_append_u8(message, BATADV_ATTR_FRAGMENTATION_ENABLED, b->fragmentation);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set fragmentation: %m");
return r;
r = sd_netlink_message_append_u8(message, BATADV_ATTR_HOP_PENALTY, b->hop_penalty);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set hop_penalty: %m");
return r;
r = sd_netlink_message_append_u32(message, BATADV_ATTR_ORIG_INTERVAL, DIV_ROUND_UP(b->originator_interval, USEC_PER_MSEC));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set orig_interval: %m");
return r;
r = sd_netlink_message_append_u32(message, BATADV_ATTR_GW_BANDWIDTH_DOWN, b->gateway_bandwidth_down);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set gateway_bandwidth_down: %m");
return r;
r = sd_netlink_message_append_u32(message, BATADV_ATTR_GW_BANDWIDTH_UP, b->gateway_bandwidth_up);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to set gateway_bandwidth_up: %m");
return r;
return 0;
}
static int netdev_batadv_post_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *message = NULL;
int r;
assert(netdev);
r = sd_genl_message_new(netdev->manager->genl, BATADV_NL_NAME, BATADV_CMD_SET_MESH, &message);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not allocate netlink message: %m");
r = netdev_batadv_post_create_message(netdev, message);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not create netlink message: %m");
r = netlink_call_async(netdev->manager->genl, NULL, message, netdev_batman_set_handler,
netdev_destroy_callback, netdev);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not send batman device message: %m");
return log_netdev_error_errno(netdev, r, "Could not send netlink message: %m");
netdev_ref(netdev);
@ -190,9 +199,9 @@ static int netdev_batadv_fill_message_create(NetDev *netdev, Link *link, sd_netl
r = sd_netlink_message_append_string(m, IFLA_BATADV_ALGO_NAME, batadv_routing_algorithm_kernel_to_string(b->routing_algorithm));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BATADV_ALGO_NAME attribute: %m");
return r;
return r;
return 0;
}
const NetDevVTable batadv_vtable = {

50
src/network/netdev/bond.c
View File

@ -71,50 +71,50 @@ static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_netlin
if (b->mode != _NETDEV_BOND_MODE_INVALID) {
r = sd_netlink_message_append_u8(m, IFLA_BOND_MODE, b->mode);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MODE attribute: %m");
return r;
}
if (b->xmit_hash_policy != _NETDEV_BOND_XMIT_HASH_POLICY_INVALID) {
r = sd_netlink_message_append_u8(m, IFLA_BOND_XMIT_HASH_POLICY, b->xmit_hash_policy);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_XMIT_HASH_POLICY attribute: %m");
return r;
}
if (b->lacp_rate != _NETDEV_BOND_LACP_RATE_INVALID &&
b->mode == NETDEV_BOND_MODE_802_3AD) {
r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_LACP_RATE, b->lacp_rate);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_LACP_RATE attribute: %m");
return r;
}
if (b->miimon != 0) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_MIIMON, b->miimon / USEC_PER_MSEC);
if (r < 0)
log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_BOND_MIIMON attribute: %m");
return r;
}
if (b->downdelay != 0) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_DOWNDELAY, b->downdelay / USEC_PER_MSEC);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_DOWNDELAY attribute: %m");
return r;
}
if (b->updelay != 0) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_UPDELAY, b->updelay / USEC_PER_MSEC);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_UPDELAY attribute: %m");
return r;
}
if (b->arp_interval != 0) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_INTERVAL, b->arp_interval / USEC_PER_MSEC);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_INTERVAL attribute: %m");
return r;
if (b->lp_interval >= LEARNING_PACKETS_INTERVAL_MIN_SEC &&
b->lp_interval <= LEARNING_PACKETS_INTERVAL_MAX_SEC) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_LP_INTERVAL, b->lp_interval / USEC_PER_SEC);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_LP_INTERVAL attribute: %m");
return r;
}
}
@ -122,85 +122,85 @@ static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_netlin
b->mode == NETDEV_BOND_MODE_802_3AD) {
r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_SELECT, b->ad_select);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_SELECT attribute: %m");
return r;
}
if (b->fail_over_mac != _NETDEV_BOND_FAIL_OVER_MAC_INVALID &&
b->mode == NETDEV_BOND_MODE_ACTIVE_BACKUP) {
r = sd_netlink_message_append_u8(m, IFLA_BOND_FAIL_OVER_MAC, b->fail_over_mac);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_FAIL_OVER_MAC attribute: %m");
return r;
}
if (b->arp_validate != _NETDEV_BOND_ARP_VALIDATE_INVALID) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_VALIDATE, b->arp_validate);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_VALIDATE attribute: %m");
return r;
}
if (b->arp_all_targets != _NETDEV_BOND_ARP_ALL_TARGETS_INVALID) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_ALL_TARGETS, b->arp_all_targets);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m");
return r;
}
if (b->primary_reselect != _NETDEV_BOND_PRIMARY_RESELECT_INVALID) {
r = sd_netlink_message_append_u8(m, IFLA_BOND_PRIMARY_RESELECT, b->primary_reselect);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_PRIMARY_RESELECT attribute: %m");
return r;
}
if (b->resend_igmp <= RESEND_IGMP_MAX) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_RESEND_IGMP, b->resend_igmp);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_RESEND_IGMP attribute: %m");
return r;
}
if (b->packets_per_slave <= PACKETS_PER_SLAVE_MAX &&
b->mode == NETDEV_BOND_MODE_BALANCE_RR) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_PACKETS_PER_SLAVE, b->packets_per_slave);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_PACKETS_PER_SLAVE attribute: %m");
return r;
}
if (b->num_grat_arp <= GRATUITOUS_ARP_MAX) {
r = sd_netlink_message_append_u8(m, IFLA_BOND_NUM_PEER_NOTIF, b->num_grat_arp);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_NUM_PEER_NOTIF attribute: %m");
return r;
}
if (b->min_links != 0) {
r = sd_netlink_message_append_u32(m, IFLA_BOND_MIN_LINKS, b->min_links);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MIN_LINKS attribute: %m");
return r;
}
if (b->ad_actor_sys_prio != 0) {
r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_ACTOR_SYS_PRIO, b->ad_actor_sys_prio);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_ACTOR_SYS_PRIO attribute: %m");
return r;
}
if (b->ad_user_port_key != 0) {
r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_USER_PORT_KEY, b->ad_user_port_key);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_USER_PORT_KEY attribute: %m");
return r;
}
if (!ether_addr_is_null(&b->ad_actor_system)) {
r = sd_netlink_message_append_ether_addr(m, IFLA_BOND_AD_ACTOR_SYSTEM, &b->ad_actor_system);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_ACTOR_SYSTEM attribute: %m");
return r;
}
r = sd_netlink_message_append_u8(m, IFLA_BOND_ALL_SLAVES_ACTIVE, b->all_slaves_active);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ALL_SLAVES_ACTIVE attribute: %m");
return r;
if (b->tlb_dynamic_lb >= 0) {
r = sd_netlink_message_append_u8(m, IFLA_BOND_TLB_DYNAMIC_LB, b->tlb_dynamic_lb);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_TLB_DYNAMIC_LB attribute: %m");
return r;
}
if (b->arp_interval > 0 && !ordered_set_isempty(b->arp_ip_targets)) {
@ -209,17 +209,17 @@ static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_netlin
r = sd_netlink_message_open_container(m, IFLA_BOND_ARP_IP_TARGET);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not open contaniner IFLA_BOND_ARP_IP_TARGET : %m");
return r;
ORDERED_SET_FOREACH(val, b->arp_ip_targets) {
r = sd_netlink_message_append_u32(m, n++, PTR_TO_UINT32(val));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m");
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not close contaniner IFLA_BOND_ARP_IP_TARGET : %m");
return r;
}
return 0;

74
src/network/netdev/bridge.c
View File

@ -45,124 +45,132 @@ static int netdev_bridge_set_handler(sd_netlink *rtnl, sd_netlink_message *m, Ne
return 1;
}
static int netdev_bridge_post_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
static int netdev_bridge_post_create_message(NetDev *netdev, sd_netlink_message *req) {
Bridge *b;
int r;
assert(netdev);
b = BRIDGE(netdev);
assert(b);
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 RTM_SETLINK 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 flags: %m");
assert_se(b = BRIDGE(netdev));
r = sd_netlink_message_open_container(req, IFLA_LINKINFO);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
return r;
r = sd_netlink_message_open_container_union(req, IFLA_INFO_DATA, netdev_kind_to_string(netdev->kind));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_FORWARD_DELAY attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_HELLO_TIME attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_MAX_AGE attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_AGEING_TIME attribute: %m");
return r;
}
if (b->priority > 0) {
r = sd_netlink_message_append_u16(req, IFLA_BR_PRIORITY, b->priority);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_PRIORITY attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_GROUP_FWD_MASK attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_VLAN_DEFAULT_PVID attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_MCAST_QUERIER attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_MCAST_SNOOPING attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_VLAN_FILTERING attribute: %m");
return r;
}
if (b->vlan_protocol >= 0) {
r = sd_netlink_message_append_u16(req, IFLA_BR_VLAN_PROTOCOL, b->vlan_protocol);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_VLAN_PROTOCOL attribute: %m");
return r;
}
if (b->stp >= 0) {
r = sd_netlink_message_append_u32(req, IFLA_BR_STP_STATE, b->stp);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_STP_STATE attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_MCAST_IGMP_VERSION attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
return r;
return 0;
}
static int netdev_bridge_post_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
_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 rtnetlink message: %m");
return log_netdev_error_errno(netdev, r, "Could not send netlink message: %m");
netdev_ref(netdev);

50
src/network/netdev/fou-tunnel.c
View File

@ -24,30 +24,21 @@ DEFINE_STRING_TABLE_LOOKUP(fou_encap_type, FooOverUDPEncapType);
DEFINE_CONFIG_PARSE_ENUM(config_parse_fou_encap_type, fou_encap_type, FooOverUDPEncapType,
"Failed to parse Encapsulation=");
static int netdev_fill_fou_tunnel_message(NetDev *netdev, sd_netlink_message **ret) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
static int netdev_fill_fou_tunnel_message(NetDev *netdev, sd_netlink_message *m) {
FouTunnel *t;
uint8_t encap_type;
int r;
assert(netdev);
t = FOU(netdev);
assert(t);
r = sd_genl_message_new(netdev->manager->genl, FOU_GENL_NAME, FOU_CMD_ADD, &m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to allocate generic netlink message: %m");
assert_se(t = FOU(netdev));
r = sd_netlink_message_append_u16(m, FOU_ATTR_PORT, htobe16(t->port));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append FOU_ATTR_PORT attribute: %m");
return r;
if (IN_SET(t->peer_family, AF_INET, AF_INET6)) {
r = sd_netlink_message_append_u16(m, FOU_ATTR_PEER_PORT, htobe16(t->peer_port));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append FOU_ATTR_PEER_PORT attribute: %m");
return r;
}
switch (t->fou_encap_type) {
@ -63,36 +54,53 @@ static int netdev_fill_fou_tunnel_message(NetDev *netdev, sd_netlink_message **r
r = sd_netlink_message_append_u8(m, FOU_ATTR_TYPE, encap_type);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append FOU_ATTR_TYPE attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, FOU_ATTR_AF, AF_INET);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append FOU_ATTR_AF attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, FOU_ATTR_IPPROTO, t->fou_protocol);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append FOU_ATTR_IPPROTO attribute: %m");
return r;
if (t->local_family == AF_INET) {
r = sd_netlink_message_append_in_addr(m, FOU_ATTR_LOCAL_V4, &t->local.in);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append FOU_ATTR_LOCAL_V4 attribute: %m");
return r;
} else if (t->local_family == AF_INET6) {
r = sd_netlink_message_append_in6_addr(m, FOU_ATTR_LOCAL_V6, &t->local.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append FOU_ATTR_LOCAL_V6 attribute: %m");
return r;
}
if (t->peer_family == AF_INET) {
r = sd_netlink_message_append_in_addr(m, FOU_ATTR_PEER_V4, &t->peer.in);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append FOU_ATTR_PEER_V4 attribute: %m");
return r;
} else if (t->peer_family == AF_INET6){
r = sd_netlink_message_append_in6_addr(m, FOU_ATTR_PEER_V6, &t->peer.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append FOU_ATTR_PEER_V6 attribute: %m");
return r;
}
return 0;
}
static int netdev_create_fou_tunnel_message(NetDev *netdev, sd_netlink_message **ret) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(netdev);
r = sd_genl_message_new(netdev->manager->genl, FOU_GENL_NAME, FOU_CMD_ADD, &m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not allocate netlink message: %m");
r = netdev_fill_fou_tunnel_message(netdev, m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not create netlink message: %m");
*ret = TAKE_PTR(m);
return 0;
}
@ -124,7 +132,7 @@ static int netdev_fou_tunnel_create(NetDev *netdev) {
assert(netdev);
assert(FOU(netdev));
r = netdev_fill_fou_tunnel_message(netdev, &m);
r = netdev_create_fou_tunnel_message(netdev, &m);
if (r < 0)
return r;

22
src/network/netdev/geneve.c
View File

@ -39,7 +39,7 @@ static int netdev_geneve_fill_message_create(NetDev *netdev, Link *link, sd_netl
if (v->id <= GENEVE_VID_MAX) {
r = sd_netlink_message_append_u32(m, IFLA_GENEVE_ID, v->id);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_ID attribute: %m");
return r;
}
if (in_addr_is_set(v->remote_family, &v->remote)) {
@ -48,51 +48,51 @@ static int netdev_geneve_fill_message_create(NetDev *netdev, Link *link, sd_netl
else
r = sd_netlink_message_append_in6_addr(m, IFLA_GENEVE_REMOTE6, &v->remote.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_REMOTE/IFLA_GENEVE_REMOTE6 attribute: %m");
return r;
}
if (v->inherit) {
r = sd_netlink_message_append_u8(m, IFLA_GENEVE_TTL_INHERIT, 1);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_TTL_INHERIT attribute: %m");
return r;
} else {
r = sd_netlink_message_append_u8(m, IFLA_GENEVE_TTL, v->ttl);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_TTL attribute: %m");
return r;
}
r = sd_netlink_message_append_u8(m, IFLA_GENEVE_TOS, v->tos);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_TOS attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_GENEVE_UDP_CSUM, v->udpcsum);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_UDP_CSUM attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_GENEVE_UDP_ZERO_CSUM6_TX, v->udp6zerocsumtx);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_UDP_ZERO_CSUM6_TX attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_GENEVE_UDP_ZERO_CSUM6_RX, v->udp6zerocsumrx);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_UDP_ZERO_CSUM6_RX attribute: %m");
return r;
if (v->dest_port != DEFAULT_GENEVE_DESTINATION_PORT) {
r = sd_netlink_message_append_u16(m, IFLA_GENEVE_PORT, htobe16(v->dest_port));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_PORT attribute: %m");
return r;
}
if (v->flow_label > 0) {
r = sd_netlink_message_append_u32(m, IFLA_GENEVE_LABEL, htobe32(v->flow_label));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_LABEL attribute: %m");
return r;
}
if (v->geneve_df != _NETDEV_GENEVE_DF_INVALID) {
r = sd_netlink_message_append_u8(m, IFLA_GENEVE_DF, v->geneve_df);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GENEVE_DF attribute: %m");
return r;
}
return 0;

20
src/network/netdev/ipoib.c
View File

@ -39,19 +39,19 @@ static int netdev_ipoib_fill_message_create(NetDev *netdev, Link *link, sd_netli
if (ipoib->pkey > 0) {
r = sd_netlink_message_append_u16(m, IFLA_IPOIB_PKEY, ipoib->pkey);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPOIB_PKEY attribute: %m");
return r;
}
if (ipoib->mode >= 0) {
r = sd_netlink_message_append_u16(m, IFLA_IPOIB_MODE, ipoib->mode);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPOIB_MODE attribute: %m");
return r;
}
if (ipoib->umcast >= 0) {
r = sd_netlink_message_append_u16(m, IFLA_IPOIB_UMCAST, ipoib->umcast);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPOIB_UMCAST attribute: %m");
return r;
}
return 0;
@ -66,35 +66,35 @@ int ipoib_set_netlink_message(Link *link, sd_netlink_message *m) {
r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK);
if (r < 0)
return log_link_debug_errno(link, r, "Could not set netlink flags: %m");
return r;
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to open IFLA_LINKINFO container: %m");
return r;
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind);
if (r < 0)
return log_link_debug_errno(link, r, "Could not open IFLA_INFO_DATA container: %m");
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 log_link_debug_errno(link, r, "Could not append IFLA_IPOIB_MODE attribute: %m");
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 log_link_debug_errno(link, r, "Could not append IFLA_IPOIB_UMCAST attribute: %m");
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to close IFLA_INFO_DATA container: %m");
return r;
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to close IFLA_LINKINFO container: %m");
return r;
return 0;
}

4
src/network/netdev/ipvlan.c
View File

@ -31,13 +31,13 @@ static int netdev_ipvlan_fill_message_create(NetDev *netdev, Link *link, sd_netl
if (m->mode != _NETDEV_IPVLAN_MODE_INVALID) {
r = sd_netlink_message_append_u16(req, IFLA_IPVLAN_MODE, m->mode);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPVLAN_MODE attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_IPVLAN_FLAGS attribute: %m");
return r;
}
return 0;

68
src/network/netdev/l2tp-tunnel.c
View File

@ -91,7 +91,7 @@ static int l2tp_session_new_static(L2tpTunnel *t, const char *filename, unsigned
return 0;
}
static int netdev_l2tp_fill_message_tunnel(NetDev *netdev, union in_addr_union *local_address, sd_netlink_message **ret) {
static int netdev_l2tp_create_message_tunnel(NetDev *netdev, union in_addr_union *local_address, sd_netlink_message **ret) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
uint16_t encap_type;
L2tpTunnel *t;
@ -99,26 +99,23 @@ static int netdev_l2tp_fill_message_tunnel(NetDev *netdev, union in_addr_union *
assert(netdev);
assert(local_address);
t = L2TP(netdev);
assert(t);
assert_se(t = L2TP(netdev));
r = sd_genl_message_new(netdev->manager->genl, L2TP_GENL_NAME, L2TP_CMD_TUNNEL_CREATE, &m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to create generic netlink message: %m");
return r;
r = sd_netlink_message_append_u32(m, L2TP_ATTR_CONN_ID, t->tunnel_id);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_CONN_ID attribute: %m");
return r;
r = sd_netlink_message_append_u32(m, L2TP_ATTR_PEER_CONN_ID, t->peer_tunnel_id);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_PEER_CONN_ID attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, L2TP_ATTR_PROTO_VERSION, 3);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_PROTO_VERSION attribute: %m");
return r;
switch(t->l2tp_encap_type) {
case NETDEV_L2TP_ENCAPTYPE_IP:
@ -132,51 +129,51 @@ static int netdev_l2tp_fill_message_tunnel(NetDev *netdev, union in_addr_union *
r = sd_netlink_message_append_u16(m, L2TP_ATTR_ENCAP_TYPE, encap_type);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_ENCAP_TYPE attribute: %m");
return r;
if (t->family == AF_INET) {
r = sd_netlink_message_append_in_addr(m, L2TP_ATTR_IP_SADDR, &local_address->in);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_IP_SADDR attribute: %m");
return r;
r = sd_netlink_message_append_in_addr(m, L2TP_ATTR_IP_DADDR, &t->remote.in);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_IP_DADDR attribute: %m");
return r;
} else {
r = sd_netlink_message_append_in6_addr(m, L2TP_ATTR_IP6_SADDR, &local_address->in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_IP6_SADDR attribute: %m");
return r;
r = sd_netlink_message_append_in6_addr(m, L2TP_ATTR_IP6_DADDR, &t->remote.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_IP6_DADDR attribute: %m");
return r;
}
if (encap_type == L2TP_ENCAPTYPE_UDP) {
r = sd_netlink_message_append_u16(m, L2TP_ATTR_UDP_SPORT, t->l2tp_udp_sport);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_UDP_SPORT, attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, L2TP_ATTR_UDP_DPORT, t->l2tp_udp_dport);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_UDP_DPORT attribute: %m");
return r;
if (t->udp_csum) {
r = sd_netlink_message_append_u8(m, L2TP_ATTR_UDP_CSUM, t->udp_csum);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_UDP_CSUM attribute: %m");
return r;
}
if (t->udp6_csum_tx) {
r = sd_netlink_message_append_flag(m, L2TP_ATTR_UDP_ZERO_CSUM6_TX);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_UDP_ZERO_CSUM6_TX attribute: %m");
return r;
}
if (t->udp6_csum_rx) {
r = sd_netlink_message_append_flag(m, L2TP_ATTR_UDP_ZERO_CSUM6_RX);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_UDP_ZERO_CSUM6_RX attribute: %m");
return r;
}
}
@ -185,7 +182,7 @@ static int netdev_l2tp_fill_message_tunnel(NetDev *netdev, union in_addr_union *
return 0;
}
static int netdev_l2tp_fill_message_session(NetDev *netdev, L2tpSession *session, sd_netlink_message **ret) {
static int netdev_l2tp_create_message_session(NetDev *netdev, L2tpSession *session, sd_netlink_message **ret) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
uint16_t l2_spec_len;
uint8_t l2_spec_type;
@ -197,27 +194,27 @@ static int netdev_l2tp_fill_message_session(NetDev *netdev, L2tpSession *session
r = sd_genl_message_new(netdev->manager->genl, L2TP_GENL_NAME, L2TP_CMD_SESSION_CREATE, &m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to create generic netlink message: %m");
return r;
r = sd_netlink_message_append_u32(m, L2TP_ATTR_CONN_ID, session->tunnel->tunnel_id);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_CONN_ID attribute: %m");
return r;
r = sd_netlink_message_append_u32(m, L2TP_ATTR_PEER_CONN_ID, session->tunnel->peer_tunnel_id);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_PEER_CONN_ID attribute: %m");
return r;
r = sd_netlink_message_append_u32(m, L2TP_ATTR_SESSION_ID, session->session_id);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_SESSION_ID attribute: %m");
return r;
r = sd_netlink_message_append_u32(m, L2TP_ATTR_PEER_SESSION_ID, session->peer_session_id);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_PEER_SESSION_ID attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, L2TP_ATTR_PW_TYPE, L2TP_PWTYPE_ETH);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_PW_TYPE attribute: %m");
return r;
switch (session->l2tp_l2spec_type) {
case NETDEV_L2TP_L2SPECTYPE_NONE:
@ -233,15 +230,15 @@ static int netdev_l2tp_fill_message_session(NetDev *netdev, L2tpSession *session
r = sd_netlink_message_append_u8(m, L2TP_ATTR_L2SPEC_TYPE, l2_spec_type);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_L2SPEC_TYPE attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, L2TP_ATTR_L2SPEC_LEN, l2_spec_len);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_L2SPEC_LEN attribute: %m");
return r;
r = sd_netlink_message_append_string(m, L2TP_ATTR_IFNAME, session->name);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append L2TP_ATTR_IFNAME attribute: %m");
return r;
*ret = TAKE_PTR(m);
@ -321,9 +318,9 @@ static int l2tp_create_session(NetDev *netdev, L2tpSession *session) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *n = NULL;
int r;
r = netdev_l2tp_fill_message_session(netdev, session, &n);
r = netdev_l2tp_create_message_session(netdev, session, &n);
if (r < 0)
return r;
return log_netdev_error_errno(netdev, r, "Failed to create netlink message: %m");
r = netlink_call_async(netdev->manager->genl, NULL, n, l2tp_create_session_handler,
l2tp_session_destroy_callback, session);
@ -371,10 +368,7 @@ static int l2tp_create_tunnel(NetDev *netdev, Link *link) {
int r;
assert(netdev);
t = L2TP(netdev);
assert(t);
assert_se(t = L2TP(netdev));
r = l2tp_acquire_local_address(t, link, &local_address);
if (r < 0)
@ -387,9 +381,9 @@ static int l2tp_create_tunnel(NetDev *netdev, Link *link) {
log_netdev_debug(netdev, "Local address %s acquired.", strna(str));
}
r = netdev_l2tp_fill_message_tunnel(netdev, &local_address, &m);
r = netdev_l2tp_create_message_tunnel(netdev, &local_address, &m);
if (r < 0)
return r;
return log_netdev_error_errno(netdev, r, "Failed to create netlink message: %m");
r = netlink_call_async(netdev->manager->genl, NULL, m, l2tp_create_tunnel_handler,
netdev_destroy_callback, netdev);

63
src/network/netdev/macsec.c
View File

@ -218,7 +218,7 @@ static int macsec_transmit_association_new_static(MACsec *s, const char *filenam
return 0;
}
static int netdev_macsec_fill_message(NetDev *netdev, int command, sd_netlink_message **ret) {
static int netdev_macsec_create_message(NetDev *netdev, int command, sd_netlink_message **ret) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
@ -227,11 +227,11 @@ static int netdev_macsec_fill_message(NetDev *netdev, int command, sd_netlink_me
r = sd_genl_message_new(netdev->manager->genl, MACSEC_GENL_NAME, command, &m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to create generic netlink message: %m");
return r;
r = sd_netlink_message_append_u32(m, MACSEC_ATTR_IFINDEX, netdev->ifindex);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_ATTR_IFINDEX attribute: %m");
return r;
*ret = TAKE_PTR(m);
@ -247,15 +247,15 @@ static int netdev_macsec_fill_message_sci(NetDev *netdev, MACsecSCI *sci, sd_net
r = sd_netlink_message_open_container(m, MACSEC_ATTR_RXSC_CONFIG);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_ATTR_RXSC_CONFIG attribute: %m");
return r;
r = sd_netlink_message_append_u64(m, MACSEC_RXSC_ATTR_SCI, sci->as_uint64);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_RXSC_ATTR_SCI attribute: %m");
return r;
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_ATTR_RXSC_CONFIG attribute: %m");
return r;
return 0;
}
@ -269,37 +269,37 @@ static int netdev_macsec_fill_message_sa(NetDev *netdev, SecurityAssociation *a,
r = sd_netlink_message_open_container(m, MACSEC_ATTR_SA_CONFIG);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_ATTR_SA_CONFIG attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, MACSEC_SA_ATTR_AN, a->association_number);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_SA_ATTR_AN attribute: %m");
return r;
if (a->packet_number > 0) {
r = sd_netlink_message_append_u32(m, MACSEC_SA_ATTR_PN, a->packet_number);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_SA_ATTR_PN attribute: %m");
return r;
}
if (a->key_len > 0) {
r = sd_netlink_message_append_data(m, MACSEC_SA_ATTR_KEYID, a->key_id, MACSEC_KEYID_LEN);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_SA_ATTR_KEYID attribute: %m");
return r;
r = sd_netlink_message_append_data(m, MACSEC_SA_ATTR_KEY, a->key, a->key_len);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_SA_ATTR_KEY attribute: %m");
return r;
}
if (a->activate >= 0) {
r = sd_netlink_message_append_u8(m, MACSEC_SA_ATTR_ACTIVE, a->activate);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_SA_ATTR_ACTIVE attribute: %m");
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append MACSEC_ATTR_SA_CONFIG attribute: %m");
return r;
return 0;
}
@ -313,8 +313,7 @@ static int macsec_receive_association_handler(sd_netlink *rtnl, sd_netlink_messa
r = sd_netlink_message_get_errno(m);
if (r == -EEXIST)
log_netdev_info(netdev,
"MACsec receive secure association exists, "
"using existing without changing its parameters");
"MACsec receive secure association exists, using it without changing parameters");
else if (r < 0) {
log_netdev_warning_errno(netdev, r,
"Failed to add receive secure association: %m");
@ -335,17 +334,17 @@ static int netdev_macsec_configure_receive_association(NetDev *netdev, ReceiveAs
assert(netdev);
assert(a);
r = netdev_macsec_fill_message(netdev, MACSEC_CMD_ADD_RXSA, &m);
r = netdev_macsec_create_message(netdev, MACSEC_CMD_ADD_RXSA, &m);
if (r < 0)
return r;
return log_netdev_error_errno(netdev, r, "Failed to create netlink message: %m");
r = netdev_macsec_fill_message_sa(netdev, &a->sa, m);
if (r < 0)
return r;
return log_netdev_error_errno(netdev, r, "Failed to fill netlink message: %m");
r = netdev_macsec_fill_message_sci(netdev, &a->sci, m);
if (r < 0)
return r;
return log_netdev_error_errno(netdev, r, "Failed to fill netlink message: %m");
r = netlink_call_async(netdev->manager->genl, NULL, m, macsec_receive_association_handler,
netdev_destroy_callback, netdev);
@ -371,8 +370,7 @@ static int macsec_receive_channel_handler(sd_netlink *rtnl, sd_netlink_message *
r = sd_netlink_message_get_errno(m);
if (r == -EEXIST)
log_netdev_debug(netdev,
"MACsec receive channel exists, "
"using existing without changing its parameters");
"MACsec receive channel exists, using it without changing parameters");
else if (r < 0) {
log_netdev_warning_errno(netdev, r,
"Failed to add receive secure channel: %m");
@ -410,13 +408,13 @@ static int netdev_macsec_configure_receive_channel(NetDev *netdev, ReceiveChanne
assert(netdev);
assert(c);
r = netdev_macsec_fill_message(netdev, MACSEC_CMD_ADD_RXSC, &m);
r = netdev_macsec_create_message(netdev, MACSEC_CMD_ADD_RXSC, &m);
if (r < 0)
return r;
return log_netdev_error_errno(netdev, r, "Failed to create netlink message: %m");
r = netdev_macsec_fill_message_sci(netdev, &c->sci, m);
if (r < 0)
return r;
return log_netdev_error_errno(netdev, r, "Failed to fill netlink message: %m");
r = netlink_call_async(netdev->manager->genl, NULL, m, macsec_receive_channel_handler,
receive_channel_destroy_callback, c);
@ -437,8 +435,7 @@ static int macsec_transmit_association_handler(sd_netlink *rtnl, sd_netlink_mess
r = sd_netlink_message_get_errno(m);
if (r == -EEXIST)
log_netdev_info(netdev,
"MACsec transmit secure association exists, "
"using existing without changing its parameters");
"MACsec transmit secure association exists, using it without changing parameters");
else if (r < 0) {
log_netdev_warning_errno(netdev, r,
"Failed to add transmit secure association: %m");
@ -459,13 +456,13 @@ static int netdev_macsec_configure_transmit_association(NetDev *netdev, Transmit
assert(netdev);
assert(a);
r = netdev_macsec_fill_message(netdev, MACSEC_CMD_ADD_TXSA, &m);
r = netdev_macsec_create_message(netdev, MACSEC_CMD_ADD_TXSA, &m);
if (r < 0)
return r;
return log_netdev_error_errno(netdev, r, "Failed to create netlink message: %m");
r = netdev_macsec_fill_message_sa(netdev, &a->sa, m);
if (r < 0)
return r;
return log_netdev_error_errno(netdev, r, "Failed to fill netlink message: %m");
r = netlink_call_async(netdev->manager->genl, NULL, m, macsec_transmit_association_handler,
netdev_destroy_callback, netdev);
@ -516,20 +513,20 @@ static int netdev_macsec_fill_message_create(NetDev *netdev, Link *link, sd_netl
if (v->port > 0) {
r = sd_netlink_message_append_u16(m, IFLA_MACSEC_PORT, v->port);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MACSEC_PORT attribute: %m");
return r;
}
if (v->encrypt >= 0) {
r = sd_netlink_message_append_u8(m, IFLA_MACSEC_ENCRYPT, v->encrypt);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MACSEC_ENCRYPT attribute: %m");
return r;
}
r = sd_netlink_message_append_u8(m, IFLA_MACSEC_ENCODING_SA, v->encoding_an);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MACSEC_ENCODING_SA attribute: %m");
return r;
return r;
return 0;
}
int config_parse_macsec_port(

14
src/network/netdev/macvlan.c
View File

@ -33,40 +33,40 @@ static int netdev_macvlan_fill_message_create(NetDev *netdev, Link *link, sd_net
r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_MACADDR_MODE, MACVLAN_MACADDR_SET);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MACVLAN_MACADDR_MODE attribute: %m");
return r;
r = sd_netlink_message_open_container(req, IFLA_MACVLAN_MACADDR_DATA);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not open IFLA_MACVLAN_MACADDR_DATA container: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_MACVLAN_MACADDR attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not close IFLA_MACVLAN_MACADDR_DATA container: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_MACVLAN_MODE attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_MACVLAN_FLAGS attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_MACVLAN_BC_QUEUE_LEN attribute: %m");
return r;
}
return 0;

120
src/network/netdev/netdev.c
View File

@ -478,9 +478,68 @@ finalize:
return 0;
}
static int netdev_create_message(NetDev *netdev, Link *link, sd_netlink_message *m) {
int r;
r = sd_netlink_message_append_string(m, IFLA_IFNAME, netdev->ifname);
if (r < 0)
return r;
struct hw_addr_data hw_addr;
r = netdev_generate_hw_addr(netdev, link, netdev->ifname, &netdev->hw_addr, &hw_addr);
if (r < 0)
return r;
if (hw_addr.length > 0) {
log_netdev_debug(netdev, "Using MAC address: %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;
}
if (link) {
r = sd_netlink_message_append_u32(m, IFLA_LINK, link->ifindex);
if (r < 0)
return r;
}
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
if (r < 0)
return r;
if (NETDEV_VTABLE(netdev)->fill_message_create) {
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, netdev_kind_to_string(netdev->kind));
if (r < 0)
return r;
r = NETDEV_VTABLE(netdev)->fill_message_create(netdev, link, m);
if (r < 0)
return r;
r = sd_netlink_message_close_container(m);
if (r < 0)
return r;
} else {
r = sd_netlink_message_append_string(m, IFLA_INFO_KIND, netdev_kind_to_string(netdev->kind));
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return r;
return 0;
}
static int netdev_create(NetDev *netdev, Link *link, link_netlink_message_handler_t callback) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
struct hw_addr_data hw_addr;
int r;
assert(netdev);
@ -500,73 +559,24 @@ static int netdev_create(NetDev *netdev, Link *link, link_netlink_message_handle
r = sd_rtnl_message_new_link(netdev->manager->rtnl, &m, RTM_NEWLINK, 0);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not allocate RTM_NEWLINK message: %m");
return log_netdev_error_errno(netdev, r, "Could not allocate netlink message: %m");
r = sd_netlink_message_append_string(m, IFLA_IFNAME, netdev->ifname);
r = netdev_create_message(netdev, link, m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IFNAME, attribute: %m");
r = netdev_generate_hw_addr(netdev, link, netdev->ifname, &netdev->hw_addr, &hw_addr);
if (r < 0)
return r;
if (hw_addr.length > 0) {
log_netdev_debug(netdev, "Using MAC address: %s", HW_ADDR_TO_STR(&hw_addr));
r = netlink_message_append_hw_addr(m, IFLA_ADDRESS, &hw_addr);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_ADDRESS attribute: %m");
}
if (netdev->mtu != 0) {
r = sd_netlink_message_append_u32(m, IFLA_MTU, netdev->mtu);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MTU attribute: %m");
}
if (link) {
r = sd_netlink_message_append_u32(m, IFLA_LINK, link->ifindex);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINK attribute: %m");
}
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
if (NETDEV_VTABLE(netdev)->fill_message_create) {
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, netdev_kind_to_string(netdev->kind));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
r = NETDEV_VTABLE(netdev)->fill_message_create(netdev, link, m);
if (r < 0)
return r;
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
} else {
r = sd_netlink_message_append_string(m, IFLA_INFO_KIND, netdev_kind_to_string(netdev->kind));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_KIND attribute: %m");
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
return log_netdev_error_errno(netdev, r, "Could not create netlink message: %m");
if (link) {
r = netlink_call_async(netdev->manager->rtnl, NULL, m, callback,
link_netlink_destroy_callback, link);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not send rtnetlink message: %m");
return log_netdev_error_errno(netdev, r, "Could not send netlink message: %m");
link_ref(link);
} else {
r = netlink_call_async(netdev->manager->rtnl, NULL, m, netdev_create_handler,
netdev_destroy_callback, netdev);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not send rtnetlink message: %m");
return log_netdev_error_errno(netdev, r, "Could not send netlink message: %m");
netdev_ref(netdev);
}

218
src/network/netdev/tunnel.c
View File

@ -86,10 +86,68 @@ int dhcp4_pd_create_6rd_tunnel_name(Link *link, char **ret) {
return 0;
}
static int dhcp4_pd_create_6rd_tunnel_message(
Link *link,
sd_netlink_message *m,
const struct in_addr *ipv4address,
uint8_t ipv4masklen,
const struct in6_addr *sixrd_prefix,
uint8_t sixrd_prefixlen) {
int r;
r = sd_netlink_message_append_string(m, IFLA_IFNAME, link->dhcp4_6rd_tunnel_name);
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, "sit");
if (r < 0)
return r;
r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, ipv4address);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, 64);
if (r < 0)
return r;
r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_6RD_PREFIX, sixrd_prefix);
if (r < 0)
return r;
r = sd_netlink_message_append_u16(m, IFLA_IPTUN_6RD_PREFIXLEN, sixrd_prefixlen);
if (r < 0)
return r;
struct in_addr relay_prefix = *ipv4address;
(void) in4_addr_mask(&relay_prefix, ipv4masklen);
r = sd_netlink_message_append_u32(m, IFLA_IPTUN_6RD_RELAY_PREFIX, relay_prefix.s_addr);
if (r < 0)
return r;
r = sd_netlink_message_append_u16(m, IFLA_IPTUN_6RD_RELAY_PREFIXLEN, ipv4masklen);
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;
}
int dhcp4_pd_create_6rd_tunnel(Link *link, link_netlink_message_handler_t callback) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
uint8_t ipv4masklen, sixrd_prefixlen;
struct in_addr ipv4address, relay_prefix;
struct in_addr ipv4address;
struct in6_addr sixrd_prefix;
int r;
@ -110,58 +168,18 @@ int dhcp4_pd_create_6rd_tunnel(Link *link, link_netlink_message_handler_t callba
r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_NEWLINK, 0);
if (r < 0)
return log_link_debug_errno(link, r, "Could not allocate RTM_NEWLINK message: %m");
return log_link_debug_errno(link, r, "Failed to create netlink message: %m");
r = sd_netlink_message_append_string(m, IFLA_IFNAME, link->dhcp4_6rd_tunnel_name);
r = dhcp4_pd_create_6rd_tunnel_message(link, m,
&ipv4address, ipv4masklen,
&sixrd_prefix, sixrd_prefixlen);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_IFNAME, attribute: %m");
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_LINKINFO attribute: %m");
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, "sit");
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m");
r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &ipv4address);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, 64);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_6RD_PREFIX, &sixrd_prefix);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_IPTUN_6RD_PREFIX attribute: %m");
r = sd_netlink_message_append_u16(m, IFLA_IPTUN_6RD_PREFIXLEN, sixrd_prefixlen);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_IPTUN_6RD_PREFIXLEN attribute: %m");
relay_prefix = ipv4address;
(void) in4_addr_mask(&relay_prefix, ipv4masklen);
r = sd_netlink_message_append_u32(m, IFLA_IPTUN_6RD_RELAY_PREFIX, relay_prefix.s_addr);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_IPTUN_6RD_RELAY_PREFIX attribute: %m");
r = sd_netlink_message_append_u16(m, IFLA_IPTUN_6RD_RELAY_PREFIXLEN, ipv4masklen);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_IPTUN_6RD_RELAY_PREFIXLEN attribute: %m");
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m");
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_LINKINFO attribute: %m");
return log_link_debug_errno(link, r, "Failed to fill netlink message: %m");
r = netlink_call_async(link->manager->rtnl, NULL, m, callback,
link_netlink_destroy_callback, link);
if (r < 0)
return log_link_debug_errno(link, r, "Could not send rtnetlink message: %m");
return log_link_debug_errno(link, r, "Could not send netlink message: %m");
link_ref(link);
@ -198,7 +216,7 @@ static int netdev_ipip_sit_fill_message_create(NetDev *netdev, Link *link, sd_ne
if (link || t->assign_to_loopback) {
r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link ? link->ifindex : LOOPBACK_IFINDEX);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
return r;
}
r = tunnel_get_local_address(t, link, &local);
@ -207,46 +225,46 @@ static int netdev_ipip_sit_fill_message_create(NetDev *netdev, Link *link, sd_ne
r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &local.in);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
return r;
r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PMTUDISC attribute: %m");
return r;
if (t->fou_tunnel) {
r = sd_netlink_message_append_u16(m, IFLA_IPTUN_ENCAP_TYPE, t->fou_encap_type);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_ENCAP_TYPE attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_IPTUN_ENCAP_SPORT, htobe16(t->encap_src_port));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_ENCAP_SPORT attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_IPTUN_ENCAP_DPORT, htobe16(t->fou_destination_port));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_ENCAP_DPORT attribute: %m");
return r;
}
if (netdev->kind == NETDEV_KIND_SIT) {
if (t->sixrd_prefixlen > 0) {
r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_6RD_PREFIX, &t->sixrd_prefix);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_6RD_PREFIX attribute: %m");
return r;
/* u16 is deliberate here, even though we're passing a netmask that can never be >128. The kernel is
* expecting to receive the prefixlen as a u16.
*/
r = sd_netlink_message_append_u16(m, IFLA_IPTUN_6RD_PREFIXLEN, t->sixrd_prefixlen);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_6RD_PREFIXLEN attribute: %m");
return r;
}
if (t->isatap >= 0) {
@ -256,11 +274,11 @@ static int netdev_ipip_sit_fill_message_create(NetDev *netdev, Link *link, sd_ne
r = sd_netlink_message_append_u16(m, IFLA_IPTUN_FLAGS, flags);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_FLAGS attribute: %m");
return r;
}
}
return r;
return 0;
}
static int netdev_gre_erspan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
@ -294,13 +312,13 @@ static int netdev_gre_erspan_fill_message_create(NetDev *netdev, Link *link, sd_
if (link || t->assign_to_loopback) {
r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link ? link->ifindex : LOOPBACK_IFINDEX);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");
return r;
}
if (netdev->kind == NETDEV_KIND_ERSPAN) {
r = sd_netlink_message_append_u32(m, IFLA_GRE_ERSPAN_INDEX, t->erspan_index);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_ERSPAN_INDEX attribute: %m");
return r;
}
r = tunnel_get_local_address(t, link, &local);
@ -309,23 +327,23 @@ static int netdev_gre_erspan_fill_message_create(NetDev *netdev, Link *link, sd_
r = sd_netlink_message_append_in_addr(m, IFLA_GRE_LOCAL, &local.in);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");
return r;
r = sd_netlink_message_append_in_addr(m, IFLA_GRE_REMOTE, &t->remote.in);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_GRE_TOS, t->tos);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TOS attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_GRE_PMTUDISC, t->pmtudisc);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_PMTUDISC attribute: %m");
return r;
if (t->key != 0) {
ikey = okey = htobe32(t->key);
@ -353,35 +371,35 @@ static int netdev_gre_erspan_fill_message_create(NetDev *netdev, Link *link, sd_
r = sd_netlink_message_append_u32(m, IFLA_GRE_IKEY, ikey);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_IKEY attribute: %m");
return r;
r = sd_netlink_message_append_u32(m, IFLA_GRE_OKEY, okey);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_OKEY attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_GRE_IFLAGS, iflags);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_IFLAGS attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_GRE_OFLAGS, oflags);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_OFLAGS, attribute: %m");
return r;
if (t->fou_tunnel) {
r = sd_netlink_message_append_u16(m, IFLA_GRE_ENCAP_TYPE, t->fou_encap_type);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_ENCAP_TYPE attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_GRE_ENCAP_SPORT, htobe16(t->encap_src_port));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_ENCAP_SPORT attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_GRE_ENCAP_DPORT, htobe16(t->fou_destination_port));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_ENCAP_DPORT attribute: %m");
return r;
}
return r;
return 0;
}
static int netdev_ip6gre_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
@ -406,7 +424,7 @@ static int netdev_ip6gre_fill_message_create(NetDev *netdev, Link *link, sd_netl
if (link || t->assign_to_loopback) {
r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link ? link->ifindex : LOOPBACK_IFINDEX);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");
return r;
}
r = tunnel_get_local_address(t, link, &local);
@ -415,25 +433,25 @@ static int netdev_ip6gre_fill_message_create(NetDev *netdev, Link *link, sd_netl
r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_LOCAL, &local.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");
return r;
r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_REMOTE, &t->remote.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");
return r;
if (t->ipv6_flowlabel != _NETDEV_IPV6_FLOWLABEL_INVALID) {
r = sd_netlink_message_append_u32(m, IFLA_GRE_FLOWINFO, t->ipv6_flowlabel);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_FLOWINFO attribute: %m");
return r;
}
r = sd_netlink_message_append_u32(m, IFLA_GRE_FLAGS, t->flags);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_FLAGS attribute: %m");
return r;
if (t->key != 0) {
ikey = okey = htobe32(t->key);
@ -453,21 +471,21 @@ static int netdev_ip6gre_fill_message_create(NetDev *netdev, Link *link, sd_netl
r = sd_netlink_message_append_u32(m, IFLA_GRE_IKEY, ikey);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_IKEY attribute: %m");
return r;
r = sd_netlink_message_append_u32(m, IFLA_GRE_OKEY, okey);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_OKEY attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_GRE_IFLAGS, iflags);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_IFLAGS attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_GRE_OFLAGS, oflags);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_OFLAGS, attribute: %m");
return r;
return r;
return 0;
}
static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
@ -489,7 +507,7 @@ static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_netlink
if (link || t->assign_to_loopback) {
r = sd_netlink_message_append_u32(m, IFLA_VTI_LINK, link ? link->ifindex : LOOPBACK_IFINDEX);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VTI_LINK attribute: %m");
return r;
}
if (t->key != 0)
@ -501,11 +519,11 @@ static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_netlink
r = sd_netlink_message_append_u32(m, IFLA_VTI_IKEY, ikey);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VTI_IKEY attribute: %m");
return r;
r = sd_netlink_message_append_u32(m, IFLA_VTI_OKEY, okey);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VTI_OKEY attribute: %m");
return r;
r = tunnel_get_local_address(t, link, &local);
if (r < 0)
@ -513,13 +531,13 @@ static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_netlink
r = netlink_message_append_in_addr_union(m, IFLA_VTI_LOCAL, t->family, &local);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VTI_LOCAL attribute: %m");
return r;
r = netlink_message_append_in_addr_union(m, IFLA_VTI_REMOTE, t->family, &t->remote);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VTI_REMOTE attribute: %m");
return r;
return r;
return 0;
}
static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
@ -538,7 +556,7 @@ static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_netl
if (link || t->assign_to_loopback) {
r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link ? link->ifindex : LOOPBACK_IFINDEX);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
return r;
}
r = tunnel_get_local_address(t, link, &local);
@ -547,20 +565,20 @@ static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_netl
r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_LOCAL, &local.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
return r;
r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
return r;
if (t->ipv6_flowlabel != _NETDEV_IPV6_FLOWLABEL_INVALID) {
r = sd_netlink_message_append_u32(m, IFLA_IPTUN_FLOWINFO, t->ipv6_flowlabel);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_FLOWINFO attribute: %m");
return r;
}
if (t->copy_dscp)
@ -572,12 +590,12 @@ static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_netl
if (t->encap_limit != 0) {
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_ENCAP_LIMIT, t->encap_limit);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_ENCAP_LIMIT attribute: %m");
return r;
}
r = sd_netlink_message_append_u32(m, IFLA_IPTUN_FLAGS, t->flags);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_FLAGS attribute: %m");
return r;
switch (t->ip6tnl_mode) {
case NETDEV_IP6_TNL_MODE_IP6IP6:
@ -594,9 +612,9 @@ static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_netl
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PROTO, proto);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PROTO attribute: %m");
return r;
return r;
return 0;
}
static int netdev_tunnel_is_ready_to_create(NetDev *netdev, Link *link) {

12
src/network/netdev/veth.c
View File

@ -24,12 +24,12 @@ static int netdev_veth_fill_message_create(NetDev *netdev, Link *link, sd_netlin
r = sd_netlink_message_open_container(m, VETH_INFO_PEER);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append VETH_INFO_PEER attribute: %m");
return r;
if (v->ifname_peer) {
r = sd_netlink_message_append_string(m, IFLA_IFNAME, v->ifname_peer);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to add netlink interface name: %m");
return r;
}
r = netdev_generate_hw_addr(netdev, NULL, v->ifname_peer, &v->hw_addr_peer, &hw_addr);
@ -40,20 +40,20 @@ static int netdev_veth_fill_message_create(NetDev *netdev, Link *link, sd_netlin
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_ADDRESS attribute: %m");
return r;
}
if (netdev->mtu != 0) {
r = sd_netlink_message_append_u32(m, IFLA_MTU, netdev->mtu);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MTU attribute: %m");
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
return r;
return r;
return 0;
}
static int netdev_veth_verify(NetDev *netdev, const char *filename) {

18
src/network/netdev/vlan.c
View File

@ -24,12 +24,12 @@ static int netdev_vlan_fill_message_create(NetDev *netdev, Link *link, sd_netlin
r = sd_netlink_message_append_u16(req, IFLA_VLAN_ID, v->id);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VLAN_ID attribute: %m");
return r;
if (v->protocol >= 0) {
r = sd_netlink_message_append_u16(req, IFLA_VLAN_PROTOCOL, htobe16(v->protocol));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VLAN_PROTOCOL attribute: %m");
return r;
}
if (v->gvrp != -1) {
@ -54,24 +54,24 @@ static int netdev_vlan_fill_message_create(NetDev *netdev, Link *link, sd_netlin
r = sd_netlink_message_append_data(req, IFLA_VLAN_FLAGS, &flags, sizeof(struct ifla_vlan_flags));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VLAN_FLAGS attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not open container IFLA_VLAN_EGRESS_QOS: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_VLAN_QOS_MAPPING attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not close container IFLA_VLAN_EGRESS_QOS: %m");
return r;
}
if (!set_isempty(v->ingress_qos_maps)) {
@ -79,17 +79,17 @@ static int netdev_vlan_fill_message_create(NetDev *netdev, Link *link, sd_netlin
r = sd_netlink_message_open_container(req, IFLA_VLAN_INGRESS_QOS);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not open container IFLA_VLAN_INGRESS_QOS: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_VLAN_QOS_MAPPING attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not close container IFLA_VLAN_INGRESS_QOS: %m");
return r;
}
return 0;

4
src/network/netdev/vrf.c
View File

@ -20,9 +20,9 @@ static int netdev_vrf_fill_message_create(NetDev *netdev, Link *link, sd_netlink
r = sd_netlink_message_append_u32(m, IFLA_VRF_TABLE, v->table);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VRF_TABLE attribute: %m");
return r;
return r;
return 0;
}
const NetDevVTable vrf_vtable = {

15
src/network/netdev/vxcan.c
View File

@ -19,19 +19,19 @@ static int netdev_vxcan_fill_message_create(NetDev *netdev, Link *link, sd_netli
r = sd_netlink_message_open_container(m, VXCAN_INFO_PEER);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append VXCAN_INFO_PEER attribute: %m");
return r;
if (v->ifname_peer) {
r = sd_netlink_message_append_string(m, IFLA_IFNAME, v->ifname_peer);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Failed to add vxcan netlink interface peer name: %m");
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append VXCAN_INFO_PEER attribute: %m");
return r;
return r;
return 0;
}
static int netdev_vxcan_verify(NetDev *netdev, const char *filename) {
@ -44,10 +44,9 @@ static int netdev_vxcan_verify(NetDev *netdev, const char *filename) {
assert(v);
if (!v->ifname_peer) {
log_netdev_warning(netdev, "VxCan NetDev without peer name configured in %s. Ignoring", filename);
return -EINVAL;
}
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;
}

56
src/network/netdev/vxlan.c
View File

@ -51,7 +51,7 @@ static int netdev_vxlan_fill_message_create(NetDev *netdev, Link *link, sd_netli
if (v->vni <= VXLAN_VID_MAX) {
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_ID, v->vni);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_ID attribute: %m");
return r;
}
if (in_addr_is_set(v->group_family, &v->group)) {
@ -60,19 +60,19 @@ static int netdev_vxlan_fill_message_create(NetDev *netdev, Link *link, sd_netli
else
r = sd_netlink_message_append_in6_addr(m, IFLA_VXLAN_GROUP6, &v->group.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_GROUP attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_GROUP attribute: %m");
return r;
}
r = vxlan_get_local_address(v, link, &local_family, &local);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not find local address: %m");
return r;
if (in_addr_is_set(local_family, &local)) {
if (local_family == AF_INET)
@ -80,84 +80,84 @@ static int netdev_vxlan_fill_message_create(NetDev *netdev, Link *link, sd_netli
else
r = sd_netlink_message_append_in6_addr(m, IFLA_VXLAN_LOCAL6, &local.in6);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_LOCAL attribute: %m");
return r;
}
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LINK, link ? link->ifindex : 0);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_LINK attribute: %m");
return r;
if (v->inherit) {
r = sd_netlink_message_append_flag(m, IFLA_VXLAN_TTL_INHERIT);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_TTL_INHERIT attribute: %m");
return r;
} else {
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_TTL, v->ttl);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_TTL attribute: %m");
return r;
}
if (v->tos != 0) {
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_TOS, v->tos);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_TOS attribute: %m");
return r;
}
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_LEARNING, v->learning);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_LEARNING attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_RSC, v->route_short_circuit);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_RSC attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_PROXY, v->arp_proxy);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_PROXY attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_L2MISS, v->l2miss);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_L2MISS attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_L3MISS, v->l3miss);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_L3MISS attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_AGEING attribute: %m");
return r;
}
if (v->max_fdb != 0) {
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LIMIT, v->max_fdb);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_LIMIT attribute: %m");
return r;
}
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_CSUM, v->udpcsum);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_UDP_CSUM attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_TX, v->udp6zerocsumtx);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_UDP_ZERO_CSUM6_TX attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_RX, v->udp6zerocsumrx);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_UDP_ZERO_CSUM6_RX attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_REMCSUM_TX, v->remote_csum_tx);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_REMCSUM_TX attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_REMCSUM_RX, v->remote_csum_rx);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_REMCSUM_RX attribute: %m");
return r;
r = sd_netlink_message_append_u16(m, IFLA_VXLAN_PORT, htobe16(v->dest_port));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_PORT attribute: %m");
return r;
if (v->port_range.low != 0 || v->port_range.high != 0) {
struct ifla_vxlan_port_range port_range;
@ -167,32 +167,32 @@ static int netdev_vxlan_fill_message_create(NetDev *netdev, Link *link, sd_netli
r = sd_netlink_message_append_data(m, IFLA_VXLAN_PORT_RANGE, &port_range, sizeof(port_range));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_PORT_RANGE attribute: %m");
return r;
}
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LABEL, htobe32(v->flow_label));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_LABEL attribute: %m");
return r;
if (v->group_policy) {
r = sd_netlink_message_append_flag(m, IFLA_VXLAN_GBP);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_GBP attribute: %m");
return r;
}
if (v->generic_protocol_extension) {
r = sd_netlink_message_append_flag(m, IFLA_VXLAN_GPE);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_GPE attribute: %m");
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 log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_DF attribute: %m");
return r;
}
return r;
return 0;
}
int config_parse_vxlan_address(

4
src/network/netdev/xfrm.c
View File

@ -18,11 +18,11 @@ static int xfrm_fill_message_create(NetDev *netdev, Link *link, sd_netlink_messa
r = sd_netlink_message_append_u32(message, IFLA_XFRM_LINK, link ? link->ifindex : LOOPBACK_IFINDEX);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_XFRM_LINK: %m");
return r;
r = sd_netlink_message_append_u32(message, IFLA_XFRM_IF_ID, x->if_id);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_XFRM_IF_ID: %m");
return r;
return 0;
}

62
src/network/networkd-bridge-fdb.c
View File

@ -121,68 +121,51 @@ static int bridge_fdb_configure_handler(sd_netlink *rtnl, sd_netlink_message *m,
}
/* send a request to the kernel to add a FDB entry in its static MAC table. */
static int bridge_fdb_configure(const BridgeFDB *fdb, Link *link, link_netlink_message_handler_t callback) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
static int bridge_fdb_configure_message(const BridgeFDB *fdb, Link *link, sd_netlink_message *req) {
int r;
assert(fdb);
assert(link);
assert(link->manager);
assert(link->manager->rtnl);
assert(callback);
/* create new RTM message */
r = sd_rtnl_message_new_neigh(link->manager->rtnl, &req, RTM_NEWNEIGH, link->ifindex, AF_BRIDGE);
if (r < 0)
return log_link_error_errno(link, r, "Could not create RTM_NEWNEIGH message: %m");
r = sd_rtnl_message_neigh_set_flags(req, fdb->ntf_flags);
if (r < 0)
return log_link_error_errno(link, r, "Could not set neighbor flags: %m");
return r;
/* only NUD_PERMANENT state supported. */
r = sd_rtnl_message_neigh_set_state(req, NUD_NOARP | NUD_PERMANENT);
if (r < 0)
return log_link_error_errno(link, r, "Could not set neighbor state: %m");
return r;
r = sd_netlink_message_append_data(req, NDA_LLADDR, &fdb->mac_addr, sizeof(fdb->mac_addr));
if (r < 0)
return log_link_error_errno(link, r, "Could not append NDA_LLADDR attribute: %m");
return r;
/* VLAN Id is optional. We'll add VLAN Id only if it's specified. */
if (fdb->vlan_id > 0) {
r = sd_netlink_message_append_u16(req, NDA_VLAN, fdb->vlan_id);
if (r < 0)
return log_link_error_errno(link, r, "Could not append NDA_VLAN attribute: %m");
return r;
}
if (fdb->outgoing_ifindex > 0) {
r = sd_netlink_message_append_u32(req, NDA_IFINDEX, fdb->outgoing_ifindex);
if (r < 0)
return log_link_error_errno(link, r, "Could not append NDA_IFINDEX attribute: %m");
return r;
}
if (in_addr_is_set(fdb->family, &fdb->destination_addr)) {
r = netlink_message_append_in_addr_union(req, NDA_DST, fdb->family, &fdb->destination_addr);
if (r < 0)
return log_link_error_errno(link, r, "Could not append NDA_DST attribute: %m");
return r;
}
if (fdb->vni <= VXLAN_VID_MAX) {
r = sd_netlink_message_append_u32(req, NDA_VNI, fdb->vni);
if (r < 0)
return log_link_error_errno(link, r, "Could not append NDA_VNI attribute: %m");
return r;
}
/* send message to the kernel to update its internal static MAC table. */
r = netlink_call_async(link->manager->rtnl, NULL, req, callback,
link_netlink_destroy_callback, link);
if (r < 0)
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
link_ref(link);
return 1;
return 0;
}
int link_request_static_bridge_fdb(Link *link) {
@ -238,15 +221,36 @@ static bool bridge_fdb_is_ready_to_configure(BridgeFDB *fdb, Link *link) {
}
int request_process_bridge_fdb(Request *req) {
Link *link;
int r;
assert(req);
assert(req->link);
assert(req->fdb);
assert(req->type == REQUEST_TYPE_BRIDGE_FDB);
assert_se(link = req->link);
if (!bridge_fdb_is_ready_to_configure(req->fdb, req->link))
if (!bridge_fdb_is_ready_to_configure(req->fdb, link))
return 0;
return bridge_fdb_configure(req->fdb, req->link, req->netlink_handler);
/* create new RTM message */
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
r = sd_rtnl_message_new_neigh(link->manager->rtnl, &m, RTM_NEWNEIGH, link->ifindex, AF_BRIDGE);
if (r < 0)
return log_link_error_errno(link, r, "Could not allocate netlink message: %m");
r = bridge_fdb_configure_message(req->fdb, link, m);
if (r < 0)
return log_link_error_errno(link, r, "Could not create netlink message: %m");
/* send message to the kernel to update its internal static MAC table. */
r = netlink_call_async(link->manager->rtnl, NULL, m, req->netlink_handler,
link_netlink_destroy_callback, link);
if (r < 0)
return log_link_error_errno(link, r, "Could not send netlink message: %m");
link_ref(link);
return 1;
}
void network_drop_invalid_bridge_fdb_entries(Network *network) {

12
src/network/networkd-bridge-vlan.c
View File

@ -65,11 +65,9 @@ int bridge_vlan_append_info(
for (int k = 0; k < BRIDGE_VLAN_BITMAP_LEN; k++) {
uint32_t untagged_map = br_untagged_bitmap[k];
uint32_t vid_map = br_vid_bitmap[k];
unsigned base_bit;
int i;
unsigned base_bit = k * 32;
int i = -1;
base_bit = k * 32;
i = -1;
done = false;
do {
int j = find_next_bit(i, vid_map);
@ -106,14 +104,14 @@ int bridge_vlan_append_info(
r = sd_netlink_message_append_data(req, IFLA_BRIDGE_VLAN_INFO, &br_vlan, sizeof(br_vlan));
if (r < 0)
return log_link_error_errno(link, r, "Could not append IFLA_BRIDGE_VLAN_INFO attribute: %m");
return r;
} else {
br_vlan.vid = begin;
br_vlan.flags |= BRIDGE_VLAN_INFO_RANGE_BEGIN;
r = sd_netlink_message_append_data(req, IFLA_BRIDGE_VLAN_INFO, &br_vlan, sizeof(br_vlan));
if (r < 0)
return log_link_error_errno(link, r, "Could not append IFLA_BRIDGE_VLAN_INFO attribute: %m");
return r;
br_vlan.vid = end;
br_vlan.flags &= ~BRIDGE_VLAN_INFO_RANGE_BEGIN;
@ -121,7 +119,7 @@ int bridge_vlan_append_info(
r = sd_netlink_message_append_data(req, IFLA_BRIDGE_VLAN_INFO, &br_vlan, sizeof(br_vlan));
if (r < 0)
return log_link_error_errno(link, r, "Could not append IFLA_BRIDGE_VLAN_INFO attribute: %m");
return r;
}
if (done)

24
src/network/networkd-can.c
View File

@ -21,15 +21,15 @@ int can_set_netlink_message(Link *link, sd_netlink_message *m) {
r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK);
if (r < 0)
return log_link_debug_errno(link, r, "Could not set netlink flags: %m");
return r;
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to open IFLA_LINKINFO container: %m");
return r;
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind);
if (r < 0)
return log_link_debug_errno(link, r, "Could not open IFLA_INFO_DATA container: %m");
return r;
if (link->network->can_bitrate > 0) {
struct can_bittiming bt = {
@ -46,7 +46,7 @@ int can_set_netlink_message(Link *link, sd_netlink_message *m) {
r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_CAN_BITTIMING attribute: %m");
return r;
} else if (link->network->can_time_quanta_ns > 0) {
struct can_bittiming bt = {
.tq = link->network->can_time_quanta_ns,
@ -59,7 +59,7 @@ int can_set_netlink_message(Link *link, sd_netlink_message *m) {
log_link_debug(link, "Setting time quanta = %"PRIu32" nsec", bt.tq);
r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_CAN_BITTIMING attribute: %m");
return r;
}
if (link->network->can_data_bitrate > 0) {
@ -77,7 +77,7 @@ int can_set_netlink_message(Link *link, sd_netlink_message *m) {
r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt));
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_CAN_DATA_BITTIMING attribute: %m");
return r;
} else if (link->network->can_data_time_quanta_ns > 0) {
struct can_bittiming bt = {
.tq = link->network->can_data_time_quanta_ns,
@ -90,7 +90,7 @@ int can_set_netlink_message(Link *link, sd_netlink_message *m) {
log_link_debug(link, "Setting data time quanta = %"PRIu32" nsec", bt.tq);
r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt));
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_CAN_DATA_BITTIMING attribute: %m");
return r;
}
if (link->network->can_restart_us > 0) {
@ -104,7 +104,7 @@ int can_set_netlink_message(Link *link, sd_netlink_message *m) {
log_link_debug(link, "Setting restart = %s", FORMAT_TIMESPAN(restart_ms * 1000, MSEC_PER_SEC));
r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_CAN_RESTART_MS attribute: %m");
return r;
}
if (link->network->can_control_mode_mask != 0) {
@ -115,7 +115,7 @@ int can_set_netlink_message(Link *link, sd_netlink_message *m) {
r = sd_netlink_message_append_data(m, IFLA_CAN_CTRLMODE, &cm, sizeof(cm));
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_CAN_CTRLMODE attribute: %m");
return r;
}
if (link->network->can_termination_set) {
@ -123,16 +123,16 @@ int can_set_netlink_message(Link *link, sd_netlink_message *m) {
r = sd_netlink_message_append_u16(m, IFLA_CAN_TERMINATION, link->network->can_termination);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_CAN_TERMINATION attribute: %m");
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to close IFLA_INFO_DATA container: %m");
return r;
r = sd_netlink_message_close_container(m);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to close IFLA_LINKINFO container: %m");
return r;
return 0;
}

34
src/network/networkd-neighbor.c
View File

@ -175,6 +175,24 @@ static void log_neighbor_debug(const Neighbor *neighbor, const char *str, const
HW_ADDR_TO_STR(&neighbor->ll_addr), strna(dst));
}
static int neighbor_configure_message(Neighbor *neighbor, Link *link, sd_netlink_message *req) {
int r;
r = sd_rtnl_message_neigh_set_state(req, NUD_PERMANENT);
if (r < 0)
return r;
r = netlink_message_append_hw_addr(req, NDA_LLADDR, &neighbor->ll_addr);
if (r < 0)
return r;
r = netlink_message_append_in_addr_union(req, NDA_DST, neighbor->family, &neighbor->in_addr);
if (r < 0)
return r;
return 0;
}
static int neighbor_configure(
Neighbor *neighbor,
Link *link,
@ -195,24 +213,16 @@ static int neighbor_configure(
r = sd_rtnl_message_new_neigh(link->manager->rtnl, &req, RTM_NEWNEIGH,
link->ifindex, neighbor->family);
if (r < 0)
return log_link_error_errno(link, r, "Could not allocate RTM_NEWNEIGH message: %m");
return log_link_error_errno(link, r, "Could not allocate netlink message: %m");
r = sd_rtnl_message_neigh_set_state(req, NUD_PERMANENT);
r = neighbor_configure_message(neighbor, link, req);
if (r < 0)
return log_link_error_errno(link, r, "Could not set state: %m");
r = netlink_message_append_hw_addr(req, NDA_LLADDR, &neighbor->ll_addr);
if (r < 0)
return log_link_error_errno(link, r, "Could not append NDA_LLADDR attribute: %m");
r = netlink_message_append_in_addr_union(req, NDA_DST, neighbor->family, &neighbor->in_addr);
if (r < 0)
return log_link_error_errno(link, r, "Could not append NDA_DST attribute: %m");
return log_link_error_errno(link, r, "Could not create netlink message: %m");
r = netlink_call_async(link->manager->rtnl, NULL, req, callback,
link_netlink_destroy_callback, link);
if (r < 0)
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
return log_link_error_errno(link, r, "Could not send netlink message: %m");
link_ref(link);

42
src/network/networkd-route.c
View File

@ -617,7 +617,7 @@ static int route_set_netlink_message(const Route *route, sd_netlink_message *req
if (route->gw_family == route->family) {
r = netlink_message_append_in_addr_union(req, RTA_GATEWAY, route->gw_family, &route->gw);
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_GATEWAY attribute: %m");
return r;
} else {
RouteVia rtvia = {
.family = route->gw_family,
@ -626,57 +626,57 @@ static int route_set_netlink_message(const Route *route, sd_netlink_message *req
r = sd_netlink_message_append_data(req, RTA_VIA, &rtvia, sizeof(rtvia));
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_VIA attribute: %m");
return r;
}
}
if (route->dst_prefixlen > 0) {
r = netlink_message_append_in_addr_union(req, RTA_DST, route->family, &route->dst);
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_DST attribute: %m");
return r;
r = sd_rtnl_message_route_set_dst_prefixlen(req, route->dst_prefixlen);
if (r < 0)
return log_link_error_errno(link, r, "Could not set destination prefix length: %m");
return r;
}
if (route->src_prefixlen > 0) {
r = netlink_message_append_in_addr_union(req, RTA_SRC, route->family, &route->src);
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_SRC attribute: %m");
return r;
r = sd_rtnl_message_route_set_src_prefixlen(req, route->src_prefixlen);
if (r < 0)
return log_link_error_errno(link, r, "Could not set source prefix length: %m");
return r;
}
if (in_addr_is_set(route->family, &route->prefsrc)) {
r = netlink_message_append_in_addr_union(req, RTA_PREFSRC, route->family, &route->prefsrc);
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_PREFSRC attribute: %m");
return r;
}
r = sd_rtnl_message_route_set_scope(req, route->scope);
if (r < 0)
return log_link_error_errno(link, r, "Could not set scope: %m");
return r;
r = sd_rtnl_message_route_set_flags(req, route->flags & RTNH_F_ONLINK);
if (r < 0)
return log_link_error_errno(link, r, "Could not set flags: %m");
return r;
if (route->table < 256) {
r = sd_rtnl_message_route_set_table(req, route->table);
if (r < 0)
return log_link_error_errno(link, r, "Could not set route table: %m");
return r;
} else {
r = sd_rtnl_message_route_set_table(req, RT_TABLE_UNSPEC);
if (r < 0)
return log_link_error_errno(link, r, "Could not set route table: %m");
return r;
/* Table attribute to allow more than 256. */
r = sd_netlink_message_append_u32(req, RTA_TABLE, route->table);
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_TABLE attribute: %m");
return r;
}
if (!route_type_is_reject(route) &&
@ -686,22 +686,22 @@ static int route_set_netlink_message(const Route *route, sd_netlink_message *req
r = sd_netlink_message_append_u32(req, RTA_OIF, link->ifindex);
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_OIF attribute: %m");
return r;
}
if (route->nexthop_id > 0) {
r = sd_netlink_message_append_u32(req, RTA_NH_ID, route->nexthop_id);
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_NH_ID attribute: %m");
return r;
}
r = sd_netlink_message_append_u8(req, RTA_PREF, route->pref);
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_PREF attribute: %m");
return r;
r = sd_netlink_message_append_u32(req, RTA_PRIORITY, route->priority);
if (r < 0)
return log_link_error_errno(link, r, "Could not append RTA_PRIORITY attribute: %m");
return r;
return 0;
}
@ -743,7 +743,7 @@ int route_remove(Route *route) {
RTM_DELROUTE, route->family,
route->protocol);
if (r < 0)
return log_link_error_errno(link, r, "Could not create RTM_DELROUTE message: %m");
return log_link_error_errno(link, r, "Could not create netlink message: %m");
if (route->family == AF_INET && route->nexthop_id > 0 && route->type == RTN_BLACKHOLE)
/* When IPv4 route has nexthop id and the nexthop type is blackhole, even though kernel
@ -762,12 +762,12 @@ int route_remove(Route *route) {
r = route_set_netlink_message(route, req, link);
if (r < 0)
return r;
return log_error_errno(r, "Could not fill netlink message: %m");
r = netlink_call_async(manager->rtnl, NULL, req, route_remove_handler,
link ? link_netlink_destroy_callback : NULL, link);
if (r < 0)
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
return log_link_error_errno(link, r, "Could not send netlink message: %m");
link_ref(link);
@ -1179,7 +1179,7 @@ static int route_configure(
RTM_NEWROUTE, route->family,
route->protocol);
if (r < 0)
return log_link_error_errno(link, r, "Could not create RTM_NEWROUTE message: %m");
return log_link_error_errno(link, r, "Could not create netlink message: %m");
r = sd_rtnl_message_route_set_type(req, route->type);
if (r < 0)
@ -1187,7 +1187,7 @@ static int route_configure(
r = route_set_netlink_message(route, req, link);
if (r < 0)
return r;
return log_error_errno(r, "Could not fill netlink message: %m");
if (route->lifetime_usec != USEC_INFINITY) {
r = sd_netlink_message_append_u32(req, RTA_EXPIRES,

56
src/network/networkd-routing-policy-rule.c
View File

@ -449,116 +449,116 @@ static int routing_policy_rule_set_netlink_message(const RoutingPolicyRule *rule
if (rule->from_prefixlen > 0) {
r = netlink_message_append_in_addr_union(m, FRA_SRC, rule->family, &rule->from);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_SRC attribute: %m");
return r;
r = sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen(m, rule->from_prefixlen);
if (r < 0)
return log_link_error_errno(link, r, "Could not set source prefix length: %m");
return r;
}
if (rule->to_prefixlen > 0) {
r = netlink_message_append_in_addr_union(m, FRA_DST, rule->family, &rule->to);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_DST attribute: %m");
return r;
r = sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen(m, rule->to_prefixlen);
if (r < 0)
return log_link_error_errno(link, r, "Could not set destination prefix length: %m");
return r;
}
r = sd_netlink_message_append_u32(m, FRA_PRIORITY, rule->priority);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_PRIORITY attribute: %m");
return r;
if (rule->tos > 0) {
r = sd_rtnl_message_routing_policy_rule_set_tos(m, rule->tos);
if (r < 0)
return log_link_error_errno(link, r, "Could not set IP rule TOS: %m");
return r;
}
if (rule->table < 256) {
r = sd_rtnl_message_routing_policy_rule_set_table(m, rule->table);
if (r < 0)
return log_link_error_errno(link, r, "Could not set IP rule table: %m");
return r;
} else {
r = sd_rtnl_message_routing_policy_rule_set_table(m, RT_TABLE_UNSPEC);
if (r < 0)
return log_link_error_errno(link, r, "Could not set IP rule table: %m");
return r;
r = sd_netlink_message_append_u32(m, FRA_TABLE, rule->table);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_TABLE attribute: %m");
return r;
}
if (rule->fwmark > 0) {
r = sd_netlink_message_append_u32(m, FRA_FWMARK, rule->fwmark);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_FWMARK attribute: %m");
return r;
r = sd_netlink_message_append_u32(m, FRA_FWMASK, rule->fwmask);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_FWMASK attribute: %m");
return r;
}
if (rule->iif) {
r = sd_netlink_message_append_string(m, FRA_IIFNAME, rule->iif);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_IIFNAME attribute: %m");
return r;
}
if (rule->oif) {
r = sd_netlink_message_append_string(m, FRA_OIFNAME, rule->oif);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_OIFNAME attribute: %m");
return r;
}
r = sd_netlink_message_append_u8(m, FRA_IP_PROTO, rule->ipproto);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_IP_PROTO attribute: %m");
return r;
r = sd_netlink_message_append_u8(m, FRA_PROTOCOL, rule->protocol);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_PROTOCOL attribute: %m");
return r;
if (rule->sport.start != 0 || rule->sport.end != 0) {
r = sd_netlink_message_append_data(m, FRA_SPORT_RANGE, &rule->sport, sizeof(rule->sport));
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_SPORT_RANGE attribute: %m");
return r;
}
if (rule->dport.start != 0 || rule->dport.end != 0) {
r = sd_netlink_message_append_data(m, FRA_DPORT_RANGE, &rule->dport, sizeof(rule->dport));
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_DPORT_RANGE attribute: %m");
return r;
}
if (rule->uid_range.start != UID_INVALID && rule->uid_range.end != UID_INVALID) {
r = sd_netlink_message_append_data(m, FRA_UID_RANGE, &rule->uid_range, sizeof(rule->uid_range));
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_UID_RANGE attribute: %m");
return r;
}
if (rule->invert_rule) {
r = sd_rtnl_message_routing_policy_rule_set_flags(m, FIB_RULE_INVERT);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FIB_RULE_INVERT attribute: %m");
return r;
}
if (rule->suppress_prefixlen >= 0) {
r = sd_netlink_message_append_u32(m, FRA_SUPPRESS_PREFIXLEN, (uint32_t) rule->suppress_prefixlen);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_SUPPRESS_PREFIXLEN attribute: %m");
return r;
}
if (rule->suppress_ifgroup >= 0) {
r = sd_netlink_message_append_u32(m, FRA_SUPPRESS_IFGROUP, (uint32_t) rule->suppress_ifgroup);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FRA_SUPPRESS_IFGROUP attribute: %m");
return r;
}
r = sd_rtnl_message_routing_policy_rule_set_fib_type(m, rule->type);
if (r < 0)
return log_link_error_errno(link, r, "Could not append FIB rule type attribute: %m");
return r;
return 0;
}
@ -588,17 +588,17 @@ static int routing_policy_rule_remove(RoutingPolicyRule *rule) {
r = sd_rtnl_message_new_routing_policy_rule(rule->manager->rtnl, &m, RTM_DELRULE, rule->family);
if (r < 0)
return log_error_errno(r, "Could not allocate RTM_DELRULE message: %m");
return log_error_errno(r, "Could not allocate netlink message: %m");
r = routing_policy_rule_set_netlink_message(rule, m, NULL);
if (r < 0)
return r;
return log_error_errno(r, "Could not create netlink message: %m");
r = netlink_call_async(rule->manager->rtnl, NULL, m,
routing_policy_rule_remove_handler,
NULL, NULL);
if (r < 0)
return log_error_errno(r, "Could not send rtnetlink message: %m");
return log_error_errno(r, "Could not send netlink message: %m");
routing_policy_rule_enter_removing(rule);
return 0;
@ -624,16 +624,16 @@ static int routing_policy_rule_configure(
r = sd_rtnl_message_new_routing_policy_rule(link->manager->rtnl, &m, RTM_NEWRULE, rule->family);
if (r < 0)
return log_link_error_errno(link, r, "Could not allocate RTM_NEWRULE message: %m");
return log_link_error_errno(link, r, "Could not allocate netlink message: %m");
r = routing_policy_rule_set_netlink_message(rule, m, link);
if (r < 0)
return r;
return log_error_errno(r, "Could not create netlink message: %m");
r = netlink_call_async(link->manager->rtnl, NULL, m, callback,
link_netlink_destroy_callback, link);
if (r < 0)
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
return log_link_error_errno(link, r, "Could not send netlink message: %m");
link_ref(link);

145
src/network/networkd-setlink.c
View File

@ -219,214 +219,189 @@ static int link_set_mtu_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *l
return 0;
}
static int link_configure(
static int link_configure_fill_message(
Link *link,
sd_netlink_message *req,
SetLinkOperation op,
void *userdata,
link_netlink_message_handler_t callback) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
void *userdata) {
int r;
assert(link);
assert(link->manager);
assert(link->manager->rtnl);
assert(link->network);
assert(op >= 0 && op < _SET_LINK_OPERATION_MAX);
assert(callback);
log_link_debug(link, "Setting %s", set_link_operation_to_string(op));
if (op == SET_LINK_BOND) {
r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_NEWLINK, link->master_ifindex);
if (r < 0)
return log_link_debug_errno(link, r, "Could not allocate RTM_NEWLINK message: %m");
} else if (IN_SET(op, SET_LINK_CAN, SET_LINK_IPOIB)) {
r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_NEWLINK, link->ifindex);
if (r < 0)
return log_link_debug_errno(link, r, "Could not allocate RTM_NEWLINK message: %m");
} else {
r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
if (r < 0)
return log_link_debug_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
}
switch (op) {
case SET_LINK_ADDRESS_GENERATION_MODE:
r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
if (r < 0)
return log_link_debug_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
return r;
r = sd_netlink_message_open_container(req, AF_INET6);
if (r < 0)
return log_link_debug_errno(link, r, "Could not open AF_INET6 container: %m");
return r;
r = sd_netlink_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, PTR_TO_UINT8(userdata));
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_INET6_ADDR_GEN_MODE attribute: %m");
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_debug_errno(link, r, "Could not close AF_INET6 container: %m");
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_debug_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
return r;
break;
case SET_LINK_BOND:
r = sd_netlink_message_set_flags(req, NLM_F_REQUEST | NLM_F_ACK);
if (r < 0)
return log_link_debug_errno(link, r, "Could not set netlink message flags: %m");
return r;
r = sd_netlink_message_open_container(req, IFLA_LINKINFO);
if (r < 0)
return log_link_debug_errno(link, r, "Could not open IFLA_LINKINFO container: %m");
return r;
r = sd_netlink_message_open_container_union(req, IFLA_INFO_DATA, "bond");
if (r < 0)
return log_link_debug_errno(link, r, "Could not open IFLA_INFO_DATA container: %m");
return r;
if (link->network->active_slave) {
r = sd_netlink_message_append_u32(req, IFLA_BOND_ACTIVE_SLAVE, link->ifindex);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BOND_ACTIVE_SLAVE attribute: %m");
return r;
}
if (link->network->primary_slave) {
r = sd_netlink_message_append_u32(req, IFLA_BOND_PRIMARY, link->ifindex);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BOND_PRIMARY attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_debug_errno(link, r, "Could not close IFLA_INFO_DATA container: %m");
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_debug_errno(link, r, "Could not close IFLA_LINKINFO container: %m");
return r;
break;
case SET_LINK_BRIDGE:
r = sd_rtnl_message_link_set_family(req, AF_BRIDGE);
if (r < 0)
return log_link_debug_errno(link, r, "Could not set message family: %m");
return r;
r = sd_netlink_message_open_container(req, IFLA_PROTINFO);
if (r < 0)
return log_link_debug_errno(link, r, "Could not open IFLA_PROTINFO container: %m");
return r;
if (link->network->use_bpdu >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_GUARD, link->network->use_bpdu);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_GUARD attribute: %m");
return r;
}
if (link->network->hairpin >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MODE, link->network->hairpin);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_MODE attribute: %m");
return r;
}
if (link->network->fast_leave >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_FAST_LEAVE, link->network->fast_leave);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_FAST_LEAVE attribute: %m");
return r;
}
if (link->network->allow_port_to_be_root >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROTECT, link->network->allow_port_to_be_root);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_PROTECT attribute: %m");
return r;
}
if (link->network->unicast_flood >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_UNICAST_FLOOD, link->network->unicast_flood);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_UNICAST_FLOOD attribute: %m");
return r;
}
if (link->network->multicast_flood >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MCAST_FLOOD, link->network->multicast_flood);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_MCAST_FLOOD attribute: %m");
return r;
}
if (link->network->multicast_to_unicast >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MCAST_TO_UCAST, link->network->multicast_to_unicast);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_MCAST_TO_UCAST attribute: %m");
return r;
}
if (link->network->neighbor_suppression >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_NEIGH_SUPPRESS, link->network->neighbor_suppression);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_NEIGH_SUPPRESS attribute: %m");
return r;
}
if (link->network->learning >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_LEARNING, link->network->learning);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_LEARNING attribute: %m");
return r;
}
if (link->network->bridge_proxy_arp >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROXYARP, link->network->bridge_proxy_arp);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_PROXYARP attribute: %m");
return r;
}
if (link->network->bridge_proxy_arp_wifi >= 0) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROXYARP_WIFI, link->network->bridge_proxy_arp_wifi);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_PROXYARP_WIFI attribute: %m");
return r;
}
if (link->network->cost != 0) {
r = sd_netlink_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_COST attribute: %m");
return r;
}
if (link->network->priority != LINK_BRIDGE_PORT_PRIORITY_INVALID) {
r = sd_netlink_message_append_u16(req, IFLA_BRPORT_PRIORITY, link->network->priority);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_PRIORITY attribute: %m");
return r;
}
if (link->network->multicast_router != _MULTICAST_ROUTER_INVALID) {
r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MULTICAST_ROUTER, link->network->multicast_router);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_MULTICAST_ROUTER attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_debug_errno(link, r, "Could not close IFLA_PROTINFO container: %m");
return r;
break;
case SET_LINK_BRIDGE_VLAN:
r = sd_rtnl_message_link_set_family(req, AF_BRIDGE);
if (r < 0)
return log_link_debug_errno(link, r, "Could not set message family: %m");
return r;
r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
if (r < 0)
return log_link_debug_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
return r;
if (link->master_ifindex <= 0) {
/* master needs BRIDGE_FLAGS_SELF flag */
r = sd_netlink_message_append_u16(req, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_BRIDGE_FLAGS attribute: %m");
return r;
}
r = bridge_vlan_append_info(link, req, link->network->pvid, link->network->br_vid_bitmap, link->network->br_untagged_bitmap);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append VLANs: %m");
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_debug_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
return r;
break;
case SET_LINK_CAN:
@ -459,19 +434,19 @@ static int link_configure(
r = sd_rtnl_message_link_set_flags(req, ifi_flags, ifi_change);
if (r < 0)
return log_link_debug_errno(link, r, "Could not set link flags: %m");
return r;
break;
}
case SET_LINK_GROUP:
r = sd_netlink_message_append_u32(req, IFLA_GROUP, (uint32_t) link->network->group);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_GROUP attribute: %m");
return r;
break;
case SET_LINK_MAC:
r = netlink_message_append_hw_addr(req, IFLA_ADDRESS, &link->requested_hw_addr);
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_ADDRESS attribute: %m");
return r;
break;
case SET_LINK_IPOIB:
r = ipoib_set_netlink_message(link, req);
@ -481,21 +456,55 @@ static int link_configure(
case SET_LINK_MASTER:
r = sd_netlink_message_append_u32(req, IFLA_MASTER, PTR_TO_UINT32(userdata));
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_MASTER attribute: %m");
return r;
break;
case SET_LINK_MTU:
r = sd_netlink_message_append_u32(req, IFLA_MTU, PTR_TO_UINT32(userdata));
if (r < 0)
return log_link_debug_errno(link, r, "Could not append IFLA_MTU attribute: %m");
return r;
break;
default:
assert_not_reached();
}
return 0;
}
static int link_configure(
Link *link,
SetLinkOperation op,
void *userdata,
link_netlink_message_handler_t callback) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
int r;
assert(link);
assert(link->manager);
assert(link->manager->rtnl);
assert(link->network);
assert(op >= 0 && op < _SET_LINK_OPERATION_MAX);
assert(callback);
log_link_debug(link, "Setting %s", set_link_operation_to_string(op));
if (op == SET_LINK_BOND)
r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_NEWLINK, link->master_ifindex);
else if (IN_SET(op, SET_LINK_CAN, SET_LINK_IPOIB))
r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_NEWLINK, link->ifindex);
else
r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
if (r < 0)
return log_link_debug_errno(link, r, "Could not allocate netlink message: %m");
r = link_configure_fill_message(link, req, op, userdata);
if (r < 0)
return log_link_debug_errno(link, r, "Could not create netlink message: %m");
r = netlink_call_async(link->manager->rtnl, NULL, req, callback,
link_netlink_destroy_callback, link);
if (r < 0)
return log_link_debug_errno(link, r, "Could not send RTM_SETLINK message: %m");
return log_link_debug_errno(link, r, "Could not send netlink message: %m");
link_ref(link);
return 0;

30
src/network/tc/cake.c
View File

@ -39,88 +39,88 @@ static int cake_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req)
assert(qdisc);
assert(req);
c = CAKE(qdisc);
assert_se(c = CAKE(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "cake");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
if (c->bandwidth > 0) {
r = sd_netlink_message_append_u64(req, TCA_CAKE_BASE_RATE64, c->bandwidth);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CAKE_BASE_RATE64 attribute: %m");
return r;
}
if (c->autorate >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_AUTORATE, c->autorate);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CAKE_AUTORATE attribute: %m");
return r;
}
if (c->overhead_set) {
r = sd_netlink_message_append_s32(req, TCA_CAKE_OVERHEAD, c->overhead);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CAKE_OVERHEAD attribute: %m");
return r;
}
if (c->mpu > 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_MPU, c->mpu);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CAKE_MPU attribute: %m");
return r;
}
if (c->compensation_mode >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_ATM, c->compensation_mode);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CAKE_ATM attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_CAKE_RAW attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_CAKE_FLOW_MODE attribute: %m");
return r;
}
if (c->nat >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_NAT, c->nat);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CAKE_NAT attribute: %m");
return r;
}
if (c->preset >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_DIFFSERV_MODE, c->preset);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CAKE_DIFFSERV_MODE attribute: %m");
return r;
}
if (c->fwmark > 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_FWMARK, c->fwmark);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CAKE_FWMARK attribute: %m");
return r;
}
if (c->wash >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CAKE_WASH, c->wash);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CAKE_WASH attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_CAKE_SPLIT_GSO attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

16
src/network/tc/codel.c
View File

@ -31,45 +31,45 @@ static int controlled_delay_fill_message(Link *link, QDisc *qdisc, sd_netlink_me
assert(qdisc);
assert(req);
cd = CODEL(qdisc);
assert_se(cd = CODEL(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "codel");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
if (cd->packet_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_CODEL_LIMIT, cd->packet_limit);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CODEL_LIMIT attribute: %m");
return r;
}
if (cd->interval_usec > 0) {
r = sd_netlink_message_append_u32(req, TCA_CODEL_INTERVAL, cd->interval_usec);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CODEL_INTERVAL attribute: %m");
return r;
}
if (cd->target_usec > 0) {
r = sd_netlink_message_append_u32(req, TCA_CODEL_TARGET, cd->target_usec);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CODEL_TARGET attribute: %m");
return r;
}
if (cd->ecn >= 0) {
r = sd_netlink_message_append_u32(req, TCA_CODEL_ECN, cd->ecn);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_CODEL_ECN attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_CODEL_CE_THRESHOLD attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

8
src/network/tc/drr.c
View File

@ -23,21 +23,21 @@ static int drr_class_fill_message(Link *link, TClass *tclass, sd_netlink_message
assert(tclass);
assert(req);
drr = TCLASS_TO_DRR(tclass);
assert_se(drr = TCLASS_TO_DRR(tclass));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "drr");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
if (drr->quantum > 0) {
r = sd_netlink_message_append_u32(req, TCA_DRR_QUANTUM, drr->quantum);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_DRR_QUANTUM, attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

22
src/network/tc/ets.c
View File

@ -20,57 +20,57 @@ static int enhanced_transmission_selection_fill_message(Link *link, QDisc *qdisc
assert(qdisc);
assert(req);
ets = ETS(qdisc);
assert_se(ets = ETS(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "ets");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
r = sd_netlink_message_append_u8(req, TCA_ETS_NBANDS, ets->n_bands);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_ETS_NBANDS attribute: %m");
return r;
if (ets->n_strict > 0) {
r = sd_netlink_message_append_u8(req, TCA_ETS_NSTRICT, ets->n_strict);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_ETS_NSTRICT attribute: %m");
return r;
}
if (ets->n_quanta > 0) {
r = sd_netlink_message_open_container(req, TCA_ETS_QUANTA);
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_ETS_QUANTA: %m");
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 log_link_error_errno(link, r, "Could not append TCA_ETS_QUANTA_BAND attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_ETS_QUANTA: %m");
return r;
}
if (ets->n_prio > 0) {
r = sd_netlink_message_open_container(req, TCA_ETS_PRIOMAP);
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_ETS_PRIOMAP: %m");
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 log_link_error_errno(link, r, "Could not append TCA_ETS_PRIOMAP_BAND attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_ETS_PRIOMAP: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

14
src/network/tc/fifo.c
View File

@ -11,7 +11,6 @@
#include "string-util.h"
static int fifo_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
struct tc_fifo_qopt opt = {};
FirstInFirstOut *fifo;
int r;
@ -21,23 +20,22 @@ static int fifo_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req)
switch(qdisc->kind) {
case QDISC_KIND_PFIFO:
fifo = PFIFO(qdisc);
assert_se(fifo = PFIFO(qdisc));
break;
case QDISC_KIND_BFIFO:
fifo = BFIFO(qdisc);
assert_se(fifo = BFIFO(qdisc));
break;
case QDISC_KIND_PFIFO_HEAD_DROP:
fifo = PFIFO_HEAD_DROP(qdisc);
assert_se(fifo = PFIFO_HEAD_DROP(qdisc));
break;
default:
assert_not_reached();
}
opt.limit = fifo->limit;
r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(struct tc_fifo_qopt));
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 log_link_error_errno(link, r, "Could not append TCA_OPTIONS attribute: %m");
return r;
return 0;
}

22
src/network/tc/fq-codel.c
View File

@ -33,63 +33,63 @@ static int fair_queueing_controlled_delay_fill_message(Link *link, QDisc *qdisc,
assert(qdisc);
assert(req);
fqcd = FQ_CODEL(qdisc);
assert_se(fqcd = FQ_CODEL(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "fq_codel");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_LIMIT attribute: %m");
return r;
}
if (fqcd->flows > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_FLOWS, fqcd->flows);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_FLOWS attribute: %m");
return r;
}
if (fqcd->quantum > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_QUANTUM, fqcd->quantum);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_QUANTUM attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_INTERVAL attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_TARGET attribute: %m");
return r;
}
if (fqcd->ecn >= 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_ECN, fqcd->ecn);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_ECN attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_CE_THRESHOLD attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_MEMORY_LIMIT attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

8
src/network/tc/fq-pie.c
View File

@ -18,21 +18,21 @@ static int fq_pie_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req
assert(qdisc);
assert(req);
fq_pie = FQ_PIE(qdisc);
assert_se(fq_pie = FQ_PIE(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "fq_pie");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_PIE_PLIMIT attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

24
src/network/tc/fq.c
View File

@ -32,46 +32,46 @@ static int fair_queueing_fill_message(Link *link, QDisc *qdisc, sd_netlink_messa
assert(qdisc);
assert(req);
fq = FQ(qdisc);
assert_se(fq = FQ(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "fq");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
if (fq->packet_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_PLIMIT, fq->packet_limit);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_FQ_PLIMIT attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_FLOW_PLIMIT attribute: %m");
return r;
}
if (fq->quantum > 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_QUANTUM, fq->quantum);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_FQ_QUANTUM attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_INITIAL_QUANTUM attribute: %m");
return r;
}
if (fq->pacing >= 0) {
r = sd_netlink_message_append_u32(req, TCA_FQ_RATE_ENABLE, fq->pacing);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_FQ_RATE_ENABLE attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_FLOW_MAX_RATE attribute: %m");
return r;
}
if (fq->buckets > 0) {
@ -80,24 +80,24 @@ static int fair_queueing_fill_message(Link *link, QDisc *qdisc, sd_netlink_messa
l = log2u(fq->buckets);
r = sd_netlink_message_append_u32(req, TCA_FQ_BUCKETS_LOG, l);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_FQ_BUCKETS_LOG attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_ORPHAN_MASK attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_FQ_CE_THRESHOLD attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

21
src/network/tc/gred.c
View File

@ -24,32 +24,31 @@ static int generic_random_early_detection_init(QDisc *qdisc) {
static int generic_random_early_detection_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
GenericRandomEarlyDetection *gred;
struct tc_gred_sopt opt = {};
int r;
assert(link);
assert(qdisc);
assert(req);
gred = GRED(qdisc);
assert_se(gred = GRED(qdisc));
opt.DPs = gred->virtual_queues;
opt.def_DP = gred->default_virtual_queue;
if (gred->grio >= 0)
opt.grio = gred->grio;
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 log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
r = sd_netlink_message_append_data(req, TCA_GRED_DPS, &opt, sizeof(struct tc_gred_sopt));
r = sd_netlink_message_append_data(req, TCA_GRED_DPS, &opt, sizeof(opt));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_GRED_DPS attribute: %m");
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

8
src/network/tc/hhf.c
View File

@ -19,21 +19,21 @@ static int heavy_hitter_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink
assert(qdisc);
assert(req);
hhf = HHF(qdisc);
assert_se(hhf = HHF(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "hhf");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
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 log_link_error_errno(link, r, "Could not append TCA_HHF_BACKLOG_LIMIT attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

58
src/network/tc/htb.c
View File

@ -16,31 +16,31 @@
static int hierarchy_token_bucket_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
HierarchyTokenBucket *htb;
struct tc_htb_glob opt = {
.version = 3,
};
int r;
assert(link);
assert(qdisc);
assert(req);
htb = HTB(qdisc);
assert_se(htb = HTB(qdisc));
opt.rate2quantum = htb->rate_to_quantum;
opt.defcls = htb->default_class;
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 log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
r = sd_netlink_message_append_data(req, TCA_HTB_INIT, &opt, sizeof(opt));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_HTB_INIT attribute: %m");
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}
@ -171,7 +171,6 @@ const QDiscVTable htb_vtable = {
static int hierarchy_token_bucket_class_fill_message(Link *link, TClass *tclass, sd_netlink_message *req) {
HierarchyTokenBucketClass *htb;
struct tc_htb_opt opt = {};
uint32_t rtab[256], ctab[256];
int r;
@ -179,62 +178,65 @@ static int hierarchy_token_bucket_class_fill_message(Link *link, TClass *tclass,
assert(tclass);
assert(req);
htb = TCLASS_TO_HTB(tclass);
assert_se(htb = TCLASS_TO_HTB(tclass));
opt.prio = htb->priority;
opt.quantum = htb->quantum;
opt.rate.rate = (htb->rate >= (1ULL << 32)) ? ~0U : htb->rate;
opt.ceil.rate = (htb->ceil_rate >= (1ULL << 32)) ? ~0U : htb->ceil_rate;
opt.rate.overhead = htb->overhead;
opt.ceil.overhead = htb->overhead;
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_error_errno(link, r, "Failed to calculate buffer size: %m");
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_error_errno(link, r, "Failed to calculate ceil buffer size: %m");
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_error_errno(link, r, "Failed to calculate rate table: %m");
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_error_errno(link, r, "Failed to calculate ceil rate table: %m");
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 log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
r = sd_netlink_message_append_data(req, TCA_HTB_PARMS, &opt, sizeof(opt));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_HTB_PARMS attribute: %m");
return r;
if (htb->rate >= (1ULL << 32)) {
r = sd_netlink_message_append_u64(req, TCA_HTB_RATE64, htb->rate);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_HTB_RATE64 attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_HTB_CEIL64 attribute: %m");
return r;
}
r = sd_netlink_message_append_data(req, TCA_HTB_RTAB, rtab, sizeof(rtab));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_HTB_RTAB attribute: %m");
return r;
r = sd_netlink_message_append_data(req, TCA_HTB_CTAB, ctab, sizeof(ctab));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_HTB_CTAB attribute: %m");
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

22
src/network/tc/netem.c
View File

@ -14,9 +14,6 @@
#include "tc-util.h"
static int network_emulator_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
struct tc_netem_qopt opt = {
.limit = 1000,
};
NetworkEmulator *ne;
int r;
@ -24,16 +21,13 @@ static int network_emulator_fill_message(Link *link, QDisc *qdisc, sd_netlink_me
assert(qdisc);
assert(req);
ne = NETEM(qdisc);
assert_se(ne = NETEM(qdisc));
if (ne->limit > 0)
opt.limit = ne->limit;
if (ne->loss > 0)
opt.loss = ne->loss;
if (ne->duplicate > 0)
opt.duplicate = ne->duplicate;
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);
@ -47,9 +41,9 @@ static int network_emulator_fill_message(Link *link, QDisc *qdisc, sd_netlink_me
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(struct tc_netem_qopt));
r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(opt));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_OPTION attribute: %m");
return r;
return 0;
}

8
src/network/tc/pie.c
View File

@ -18,21 +18,21 @@ static int pie_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
assert(qdisc);
assert(req);
pie = PIE(qdisc);
assert_se(pie = PIE(qdisc));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "pie");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
if (pie->packet_limit > 0) {
r = sd_netlink_message_append_u32(req, TCA_PIE_LIMIT, pie->packet_limit);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_PIE_PLIMIT attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

12
src/network/tc/qdisc.c
View File

@ -184,16 +184,16 @@ int qdisc_configure(Link *link, QDisc *qdisc) {
r = sd_rtnl_message_new_qdisc(link->manager->rtnl, &req, RTM_NEWQDISC, qdisc->family, link->ifindex);
if (r < 0)
return log_link_error_errno(link, r, "Could not create RTM_NEWQDISC message: %m");
return log_link_debug_errno(link, r, "Could not create RTM_NEWQDISC message: %m");
r = sd_rtnl_message_set_qdisc_parent(req, qdisc->parent);
if (r < 0)
return log_link_error_errno(link, r, "Could not create tcm_parent message: %m");
return r;
if (qdisc->handle != TC_H_UNSPEC) {
r = sd_rtnl_message_set_qdisc_handle(req, qdisc->handle);
if (r < 0)
return log_link_error_errno(link, r, "Could not set tcm_handle message: %m");
return r;
}
if (QDISC_VTABLE(qdisc)) {
@ -204,7 +204,7 @@ int qdisc_configure(Link *link, QDisc *qdisc) {
} else {
r = sd_netlink_message_append_string(req, TCA_KIND, QDISC_VTABLE(qdisc)->tca_kind);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_KIND attribute: %m");
return r;
}
if (QDISC_VTABLE(qdisc)->fill_message) {
@ -215,12 +215,12 @@ int qdisc_configure(Link *link, QDisc *qdisc) {
} else {
r = sd_netlink_message_append_string(req, TCA_KIND, qdisc->tca_kind);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_KIND attribute: %m");
return r;
}
r = netlink_call_async(link->manager->rtnl, NULL, req, qdisc_handler, link_netlink_destroy_callback, link);
if (r < 0)
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
return log_link_debug_errno(link, r, "Could not send netlink message: %m");
link_ref(link);
link->tc_messages++;

11
src/network/tc/qfq.c
View File

@ -25,27 +25,28 @@ static int quick_fair_queueing_class_fill_message(Link *link, TClass *tclass, sd
assert(tclass);
assert(req);
qfq = TCLASS_TO_QFQ(tclass);
assert_se(qfq = TCLASS_TO_QFQ(tclass));
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "qfq");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
if (qfq->weight > 0) {
r = sd_netlink_message_append_u32(req, TCA_QFQ_WEIGHT, qfq->weight);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_QFQ_WEIGHT attribute: %m");
return r;
}
if (qfq->max_packet > 0) {
r = sd_netlink_message_append_u32(req, TCA_QFQ_LMAX, qfq->max_packet);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_QFQ_LMAX attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

28
src/network/tc/sfb.c
View File

@ -13,7 +13,15 @@
static int stochastic_fair_blue_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
StochasticFairBlue *sfb;
struct tc_sfb_qopt opt = {
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,
@ -22,28 +30,20 @@ static int stochastic_fair_blue_fill_message(Link *link, QDisc *qdisc, sd_netlin
.decrement = (SFB_MAX_PROB + 10000) / 20000,
.max = 25,
.bin_size = 20,
.limit = sfb->packet_limit,
};
int r;
assert(link);
assert(qdisc);
assert(req);
sfb = SFB(qdisc);
opt.limit = sfb->packet_limit;
r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "sfb");
if (r < 0)
return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
r = sd_netlink_message_append_data(req, TCA_SFB_PARMS, &opt, sizeof(struct tc_sfb_qopt));
r = sd_netlink_message_append_data(req, TCA_SFB_PARMS, &opt, sizeof(opt));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_SFB_PARMS attribute: %m");
return r;
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

11
src/network/tc/sfq.c
View File

@ -13,20 +13,21 @@
static int stochastic_fairness_queueing_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
StochasticFairnessQueueing *sfq;
struct tc_sfq_qopt_v1 opt = {};
int r;
assert(link);
assert(qdisc);
assert(req);
sfq = SFQ(qdisc);
assert_se(sfq = SFQ(qdisc));
opt.v0.perturb_period = sfq->perturb_period / USEC_PER_SEC;
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(struct tc_sfq_qopt_v1));
r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(opt));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_OPTIONS attribute: %m");
return r;
return 0;
}

40
src/network/tc/tbf.c
View File

@ -17,7 +17,6 @@
static int token_bucket_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
uint32_t rtab[256], ptab[256];
struct tc_tbf_qopt opt = {};
TokenBucketFilter *tbf;
int r;
@ -25,10 +24,13 @@ static int token_bucket_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink
assert(qdisc);
assert(req);
tbf = TBF(qdisc);
assert_se(tbf = TBF(qdisc));
opt.rate.rate = tbf->rate >= (1ULL << 32) ? ~0U : tbf->rate;
opt.peakrate.rate = tbf->peak_rate >= (1ULL << 32) ? ~0U : tbf->peak_rate;
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;
@ -43,69 +45,67 @@ static int token_bucket_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink
opt.limit = lim;
}
opt.rate.mpu = tbf->mpu;
r = tc_fill_ratespec_and_table(&opt.rate, rtab, tbf->mtu);
if (r < 0)
return log_link_error_errno(link, r, "Failed to calculate ratespec: %m");
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_error_errno(link, r, "Failed to calculate buffer size: %m");
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_error_errno(link, r, "Failed to calculate ratespec: %m");
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_error_errno(link, r, "Failed to calculate mtu size: %m");
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 log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
return r;
r = sd_netlink_message_append_data(req, TCA_TBF_PARMS, &opt, sizeof(struct tc_tbf_qopt));
r = sd_netlink_message_append_data(req, TCA_TBF_PARMS, &opt, sizeof(opt));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_TBF_PARMS attribute: %m");
return r;
r = sd_netlink_message_append_data(req, TCA_TBF_BURST, &tbf->burst, sizeof(tbf->burst));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_TBF_BURST attribute: %m");
return r;
if (tbf->rate >= (1ULL << 32)) {
r = sd_netlink_message_append_u64(req, TCA_TBF_RATE64, tbf->rate);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_TBF_RATE64 attribute: %m");
return r;
}
r = sd_netlink_message_append_data(req, TCA_TBF_RTAB, rtab, sizeof(rtab));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_TBF_RTAB attribute: %m");
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 log_link_error_errno(link, r, "Could not append TCA_TBF_PRATE64 attribute: %m");
return r;
}
r = sd_netlink_message_append_u32(req, TCA_TBF_PBURST, tbf->mtu);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_TBF_PBURST attribute: %m");
return r;
r = sd_netlink_message_append_data(req, TCA_TBF_PTAB, ptab, sizeof(ptab));
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_TBF_PTAB attribute: %m");
return r;
}
r = sd_netlink_message_close_container(req);
if (r < 0)
return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
return r;
return 0;
}

2
src/network/tc/tc.c
View File

@ -52,7 +52,7 @@ int link_configure_traffic_control(Link *link) {
ORDERED_HASHMAP_FOREACH(tc, link->network->tc_by_section) {
r = traffic_control_configure(link, tc);
if (r < 0)
return r;
return log_link_error_errno(link, r, "Could not create send configuration message: %m");
}
if (link->tc_messages == 0)

10
src/network/tc/tclass.c
View File

@ -139,21 +139,21 @@ int tclass_configure(Link *link, TClass *tclass) {
r = sd_rtnl_message_new_tclass(link->manager->rtnl, &req, RTM_NEWTCLASS, AF_UNSPEC, link->ifindex);
if (r < 0)
return log_link_error_errno(link, r, "Could not create RTM_NEWTCLASS message: %m");
return log_link_debug_errno(link, r, "Could not create RTM_NEWTCLASS message: %m");
r = sd_rtnl_message_set_tclass_parent(req, tclass->parent);
if (r < 0)
return log_link_error_errno(link, r, "Could not create tcm_parent message: %m");
return r;
if (tclass->classid != TC_H_UNSPEC) {
r = sd_rtnl_message_set_tclass_handle(req, tclass->classid);
if (r < 0)
return log_link_error_errno(link, r, "Could not set tcm_handle message: %m");
return r;
}
r = sd_netlink_message_append_string(req, TCA_KIND, TCLASS_VTABLE(tclass)->tca_kind);
if (r < 0)
return log_link_error_errno(link, r, "Could not append TCA_KIND attribute: %m");
return r;
if (TCLASS_VTABLE(tclass)->fill_message) {
r = TCLASS_VTABLE(tclass)->fill_message(link, tclass, req);
@ -163,7 +163,7 @@ int tclass_configure(Link *link, TClass *tclass) {
r = netlink_call_async(link->manager->rtnl, NULL, req, tclass_handler, link_netlink_destroy_callback, link);
if (r < 0)
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
return log_link_debug_errno(link, r, "Could not send netlink message: %m");
link_ref(link);
link->tc_messages++;

4
src/test/test-bpf-foreign-programs.c
View File

@ -289,11 +289,11 @@ int main(int argc, char *argv[]) {
(void) setrlimit_closest(RLIMIT_MEMLOCK, &rl);
if (!can_memlock())
return log_tests_skipped("Can't use mlock(), skipping.");
return log_tests_skipped("Can't use mlock()");
r = cg_all_unified();
if (r <= 0)
return log_tests_skipped("Unified hierarchy is required, skipping.");
return log_tests_skipped("Unified hierarchy is required");
r = enter_cgroup_subroot(NULL);
if (r == -ENOMEDIUM)

2
src/test/test-bpf-lsm.c
View File

@ -77,7 +77,7 @@ int main(int argc, char *argv[]) {
(void) setrlimit_closest(RLIMIT_MEMLOCK, &rl);
if (!can_memlock())
return log_tests_skipped("Can't use mlock(), skipping.");
return log_tests_skipped("Can't use mlock()");
r = lsm_bpf_supported();
if (r <= 0)

6
src/test/test-socket-bind.c
View File

@ -120,14 +120,14 @@ int main(int argc, char *argv[]) {
(void) setrlimit_closest(RLIMIT_MEMLOCK, &rl);
if (!can_memlock())
return log_tests_skipped("Can't use mlock(), skipping.");
return log_tests_skipped("Can't use mlock()");
r = bpf_socket_bind_supported();
if (r <= 0)
return log_tests_skipped("socket-bind is not supported, skipping.");
return log_tests_skipped("socket-bind is not supported");
if (find_netcat_executable(&netcat_path) != 0)
return log_tests_skipped("Can not find netcat executable, skipping.");
return log_tests_skipped("Can not find netcat executable");
r = enter_cgroup_subroot(NULL);
if (r == -ENOMEDIUM)