15263807472

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <linux/if_arp.h>

#include "sd-netlink.h"

#include "conf-parser.h"
#include "macvlan.h"
#include "macvlan-util.h"
#include "networkd-link.h"
#include "networkd-network.h"
#include "parse-util.h"
#include "set.h"
#include "string-util.h"

typedef enum BCQueueThreshold {
        BC_QUEUE_THRESHOLD_UNDEF   = INT32_MIN,
        BC_QUEUE_THRESHOLD_DISABLE = -1,
} BCQueueThreshold;

DEFINE_CONFIG_PARSE_ENUM(config_parse_macvlan_mode, macvlan_mode, MacVlanMode);

static int netdev_macvlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *req) {
        assert(netdev);
        assert(netdev->ifname);
        assert(link);
        assert(link->network);

        MacVlan *m = netdev->kind == NETDEV_KIND_MACVLAN ? MACVLAN(netdev) : MACVTAP(netdev);
        int r;

        if (m->mode == NETDEV_MACVLAN_MODE_SOURCE && !set_isempty(m->match_source_mac)) {
                const struct ether_addr *mac_addr;

                r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_MACADDR_MODE, MACVLAN_MACADDR_SET);
                if (r < 0)
                        return r;

                r = sd_netlink_message_open_container(req, IFLA_MACVLAN_MACADDR_DATA);
                if (r < 0)
                        return r;

                SET_FOREACH(mac_addr, m->match_source_mac) {
                        r = sd_netlink_message_append_ether_addr(req, IFLA_MACVLAN_MACADDR, mac_addr);
                        if (r < 0)
                                return r;
                }

                r = sd_netlink_message_close_container(req);
                if (r < 0)
                        return r;
        }

        if (m->mode != _NETDEV_MACVLAN_MODE_INVALID) {
                r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_MODE, m->mode);
                if (r < 0)
                        return r;
        }

        /* set the nopromisc flag if Promiscuous= of the link is explicitly set to false */
        if (m->mode == NETDEV_MACVLAN_MODE_PASSTHRU && link->network->promiscuous == 0) {
                r = sd_netlink_message_append_u16(req, IFLA_MACVLAN_FLAGS, MACVLAN_FLAG_NOPROMISC);
                if (r < 0)
                        return r;
        }

        if (m->bc_queue_length != UINT32_MAX) {
                r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_BC_QUEUE_LEN, m->bc_queue_length);
                if (r < 0)
                        return r;
        }

        if (m->bc_queue_threshold != BC_QUEUE_THRESHOLD_UNDEF) {
                r = sd_netlink_message_append_s32(req, IFLA_MACVLAN_BC_CUTOFF, m->bc_queue_threshold);
                if (r < 0)
                        return r;
        }

        return 0;
}

int config_parse_macvlan_broadcast_queue_size(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        assert(filename);
        assert(section);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        MacVlan *m = ASSERT_PTR(userdata);

        if (isempty(rvalue)) {
                m->bc_queue_length = UINT32_MAX;
                return 0;
        }

        return config_parse_uint32_bounded(
                        unit, filename, line, section, section_line, lvalue, rvalue,
                        0, UINT32_MAX - 1, true,
                        &m->bc_queue_length);
}

int config_parse_macvlan_broadcast_queue_threshold(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        assert(filename);
        assert(lvalue);
        assert(rvalue);

        int32_t v, *threshold = ASSERT_PTR(data);
        int r;

        if (isempty(rvalue)) {
                *threshold = BC_QUEUE_THRESHOLD_UNDEF;
                return 0;
        }

        if (streq(rvalue, "no")) {
                *threshold = BC_QUEUE_THRESHOLD_DISABLE;
                return 0;
        }

        r = safe_atoi32(rvalue, &v);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to parse %s=, ignoring assignment: %s",
                           lvalue, rvalue);
                return 0;
        }
        if (v < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           "Invalid %s= value specified, ignoring assignment: %s",
                           lvalue, rvalue);
                return 0;
        }

        *threshold = v;
        return 0;
}

static void macvlan_done(NetDev *netdev) {
        MacVlan *m = ASSERT_PTR(netdev)->kind == NETDEV_KIND_MACVLAN ? MACVLAN(netdev) : MACVTAP(netdev);

        set_free(m->match_source_mac);
}

static void macvlan_init(NetDev *netdev) {
        MacVlan *m = ASSERT_PTR(netdev)->kind == NETDEV_KIND_MACVLAN ? MACVLAN(netdev) : MACVTAP(netdev);

        m->mode = _NETDEV_MACVLAN_MODE_INVALID;
        m->bc_queue_length = UINT32_MAX;
        m->bc_queue_threshold = BC_QUEUE_THRESHOLD_UNDEF;
}

const NetDevVTable macvtap_vtable = {
        .object_size = sizeof(MacVlan),
        .init = macvlan_init,
        .done = macvlan_done,
        .sections = NETDEV_COMMON_SECTIONS "MACVTAP\0",
        .fill_message_create = netdev_macvlan_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .iftype = ARPHRD_ETHER,
        .generate_mac = true,
        .keep_existing = true,
};

const NetDevVTable macvlan_vtable = {
        .object_size = sizeof(MacVlan),
        .init = macvlan_init,
        .done = macvlan_done,
        .sections = NETDEV_COMMON_SECTIONS "MACVLAN\0",
        .fill_message_create = netdev_macvlan_fill_message_create,
        .create_type = NETDEV_CREATE_STACKED,
        .iftype = ARPHRD_ETHER,
        .generate_mac = true,
        .keep_existing = true,
};

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <linux/if_arp.h>
4
5	#include "sd-netlink.h"
6
7	#include "conf-parser.h"
8	#include "macvlan.h"
9	#include "macvlan-util.h"
10	#include "networkd-link.h"
11	#include "networkd-network.h"
12	#include "parse-util.h"
13	#include "set.h"
14	#include "string-util.h"
15
16	typedef enum BCQueueThreshold {
17	BC_QUEUE_THRESHOLD_UNDEF = INT32_MIN,
18	BC_QUEUE_THRESHOLD_DISABLE = -1,
19	} BCQueueThreshold;
20
21	DEFINE_CONFIG_PARSE_ENUM(config_parse_macvlan_mode, macvlan_mode, MacVlanMode);	16✔
22
23	static int netdev_macvlan_fill_message_create(NetDev netdev, Link link, sd_netlink_message *req) {	12✔
24	assert(netdev);	12✔
25	assert(netdev->ifname);	12✔
26	assert(link);	12✔
27	assert(link->network);	12✔
28
29	MacVlan *m = netdev->kind == NETDEV_KIND_MACVLAN ? MACVLAN(netdev) : MACVTAP(netdev);	12✔
30	int r;	12✔
31
32	if (m->mode == NETDEV_MACVLAN_MODE_SOURCE && !set_isempty(m->match_source_mac)) {	12✔
UNCOV 33	const struct ether_addr *mac_addr;	×
34
35	r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_MACADDR_MODE, MACVLAN_MACADDR_SET);	×
36	if (r < 0)	×
UNCOV 37	return r;	×
38
39	r = sd_netlink_message_open_container(req, IFLA_MACVLAN_MACADDR_DATA);	×
UNCOV 40	if (r < 0)	×
41	return r;
42
43	SET_FOREACH(mac_addr, m->match_source_mac) {	×
44	r = sd_netlink_message_append_ether_addr(req, IFLA_MACVLAN_MACADDR, mac_addr);	×
45	if (r < 0)	×
UNCOV 46	return r;	×
47	}
48
49	r = sd_netlink_message_close_container(req);	×
UNCOV 50	if (r < 0)	×
51	return r;
52	}
53
54	if (m->mode != _NETDEV_MACVLAN_MODE_INVALID) {	12✔
55	r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_MODE, m->mode);	12✔
56	if (r < 0)	12✔
57	return r;
58	}
59
60	/* set the nopromisc flag if Promiscuous= of the link is explicitly set to false */
61	if (m->mode == NETDEV_MACVLAN_MODE_PASSTHRU && link->network->promiscuous == 0) {	12✔
62	r = sd_netlink_message_append_u16(req, IFLA_MACVLAN_FLAGS, MACVLAN_FLAG_NOPROMISC);	×
UNCOV 63	if (r < 0)	×
64	return r;
65	}
66
67	if (m->bc_queue_length != UINT32_MAX) {	12✔
68	r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_BC_QUEUE_LEN, m->bc_queue_length);	8✔
69	if (r < 0)	8✔
70	return r;
71	}
72
73	if (m->bc_queue_threshold != BC_QUEUE_THRESHOLD_UNDEF) {	12✔
74	r = sd_netlink_message_append_s32(req, IFLA_MACVLAN_BC_CUTOFF, m->bc_queue_threshold);	8✔
75	if (r < 0)	8✔
UNCOV 76	return r;	×
77	}
78
79	return 0;
80	}
81
82	int config_parse_macvlan_broadcast_queue_size(	8✔
83	const char *unit,
84	const char *filename,
85	unsigned line,
86	const char *section,
87	unsigned section_line,
88	const char *lvalue,
89	int ltype,
90	const char *rvalue,
91	void *data,
92	void *userdata) {
93
94	assert(filename);	8✔
95	assert(section);	8✔
96	assert(lvalue);	8✔
97	assert(rvalue);	8✔
98	assert(data);	8✔
99
100	MacVlan *m = ASSERT_PTR(userdata);	8✔
101
102	if (isempty(rvalue)) {	8✔
103	m->bc_queue_length = UINT32_MAX;	×
UNCOV 104	return 0;	×
105	}
106
107	return config_parse_uint32_bounded(	8✔
108	unit, filename, line, section, section_line, lvalue, rvalue,
109	0, UINT32_MAX - 1, true,
110	&m->bc_queue_length);
111	}
112
113	int config_parse_macvlan_broadcast_queue_threshold(	8✔
114	const char *unit,
115	const char *filename,
116	unsigned line,
117	const char *section,
118	unsigned section_line,
119	const char *lvalue,
120	int ltype,
121	const char *rvalue,
122	void *data,
123	void *userdata) {
124
125	assert(filename);	8✔
126	assert(lvalue);	8✔
127	assert(rvalue);	8✔
128
129	int32_t v, *threshold = ASSERT_PTR(data);	8✔
130	int r;	8✔
131
132	if (isempty(rvalue)) {	8✔
133	*threshold = BC_QUEUE_THRESHOLD_UNDEF;	×
UNCOV 134	return 0;	×
135	}
136
137	if (streq(rvalue, "no")) {	8✔
138	*threshold = BC_QUEUE_THRESHOLD_DISABLE;	×
UNCOV 139	return 0;	×
140	}
141
142	r = safe_atoi32(rvalue, &v);	8✔
143	if (r < 0) {	8✔
UNCOV 144	log_syntax(unit, LOG_WARNING, filename, line, r,	×
145	"Failed to parse %s=, ignoring assignment: %s",
146	lvalue, rvalue);
UNCOV 147	return 0;	×
148	}
149	if (v < 0) {	8✔
UNCOV 150	log_syntax(unit, LOG_WARNING, filename, line, 0,	×
151	"Invalid %s= value specified, ignoring assignment: %s",
152	lvalue, rvalue);
UNCOV 153	return 0;	×
154	}
155
156	*threshold = v;	8✔
157	return 0;	8✔
158	}
159
160	static void macvlan_done(NetDev *netdev) {	16✔
161	MacVlan *m = ASSERT_PTR(netdev)->kind == NETDEV_KIND_MACVLAN ? MACVLAN(netdev) : MACVTAP(netdev);	16✔
162
163	set_free(m->match_source_mac);	16✔
164	}	16✔
165
166	static void macvlan_init(NetDev *netdev) {	16✔
167	MacVlan *m = ASSERT_PTR(netdev)->kind == NETDEV_KIND_MACVLAN ? MACVLAN(netdev) : MACVTAP(netdev);	16✔
168
169	m->mode = _NETDEV_MACVLAN_MODE_INVALID;	16✔
170	m->bc_queue_length = UINT32_MAX;	16✔
171	m->bc_queue_threshold = BC_QUEUE_THRESHOLD_UNDEF;	16✔
172	}	16✔
173
174	const NetDevVTable macvtap_vtable = {
175	.object_size = sizeof(MacVlan),
176	.init = macvlan_init,
177	.done = macvlan_done,
178	.sections = NETDEV_COMMON_SECTIONS "MACVTAP\0",
179	.fill_message_create = netdev_macvlan_fill_message_create,
180	.create_type = NETDEV_CREATE_STACKED,
181	.iftype = ARPHRD_ETHER,
182	.generate_mac = true,
183	.keep_existing = true,
184	};
185
186	const NetDevVTable macvlan_vtable = {
187	.object_size = sizeof(MacVlan),
188	.init = macvlan_init,
189	.done = macvlan_done,
190	.sections = NETDEV_COMMON_SECTIONS "MACVLAN\0",
191	.fill_message_create = netdev_macvlan_fill_message_create,
192	.create_type = NETDEV_CREATE_STACKED,
193	.iftype = ARPHRD_ETHER,
194	.generate_mac = true,
195	.keep_existing = true,
196	};

systemd / systemd / 15263807472

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous