20#include "nl-default.h"
22#include <linux/if_link.h>
24#include <linux/ethtool.h>
26#include <netlink/netlink.h>
27#include <netlink/attr.h>
28#include <netlink/utils.h>
29#include <netlink/object.h>
30#include <netlink/route/rtnl.h>
31#include <netlink/route/link/macvlan.h>
32#include <netlink/route/link/macvtap.h>
38#define MACVLAN_HAS_MODE (1<<0)
39#define MACVLAN_HAS_FLAGS (1<<1)
40#define MACVLAN_HAS_MACADDR (1<<2)
47 uint32_t mvi_maccount;
49 struct nl_addr **mvi_macaddr;
54static struct nla_policy macvlan_policy[IFLA_MACVLAN_MAX+1] = {
56 [IFLA_MACVLAN_FLAGS] = { .type =
NLA_U16 },
57 [IFLA_MACVLAN_MACADDR_MODE] = { .type =
NLA_U32 },
58 [IFLA_MACVLAN_MACADDR] = { .type =
NLA_UNSPEC },
59 [IFLA_MACVLAN_MACADDR_DATA] = { .type =
NLA_NESTED },
60 [IFLA_MACVLAN_MACADDR_COUNT] = { .type =
NLA_U32 },
63static int macvlan_alloc(
struct rtnl_link *link)
65 struct macvlan_info *mvi;
70 for (i = 0; i < mvi->mvi_maccount; i++)
72 free(mvi->mvi_macaddr);
73 memset(mvi, 0,
sizeof(*mvi));
75 if ((mvi = calloc(1,
sizeof(*mvi))) == NULL)
80 mvi->mvi_macmode = MACVLAN_MACADDR_SET;
85static int macvlan_parse(
struct rtnl_link *link,
struct nlattr *data,
86 struct nlattr *xstats)
88 struct nlattr *tb[IFLA_MACVLAN_MAX+1];
89 struct macvlan_info *mvi;
94 NL_DBG(3,
"Parsing %s link info", link->l_info_ops->
io_name);
96 if ((err =
nla_parse_nested(tb, IFLA_MACVLAN_MAX, data, macvlan_policy)) < 0)
99 if ((err = macvlan_alloc(link)) < 0)
104 if (tb[IFLA_MACVLAN_MODE]) {
105 mvi->mvi_mode =
nla_get_u32(tb[IFLA_MACVLAN_MODE]);
106 mvi->mvi_mask |= MACVLAN_HAS_MODE;
109 if (tb[IFLA_MACVLAN_FLAGS]) {
110 mvi->mvi_flags =
nla_get_u16(tb[IFLA_MACVLAN_FLAGS]);
111 mvi->mvi_mask |= MACVLAN_HAS_FLAGS;
114 if ( tb[IFLA_MACVLAN_MACADDR_COUNT]
115 && tb[IFLA_MACVLAN_MACADDR_DATA]) {
116 mvi->mvi_maccount =
nla_get_u32(tb[IFLA_MACVLAN_MACADDR_COUNT]);
117 if (mvi->mvi_maccount > 0) {
120 nla =
nla_data(tb[IFLA_MACVLAN_MACADDR_DATA]);
121 len =
nla_len(tb[IFLA_MACVLAN_MACADDR_DATA]);
123 mvi->mvi_macaddr = calloc(mvi->mvi_maccount,
124 sizeof(*(mvi->mvi_macaddr)));
125 if (mvi->mvi_macaddr == NULL) {
132 if (i >= mvi->mvi_maccount)
134 if (
nla_type(nla) != IFLA_MACVLAN_MACADDR ||
141 mvi->mvi_mask |= MACVLAN_HAS_MACADDR;
149static void macvlan_free(
struct rtnl_link *link)
151 struct macvlan_info *mvi;
158 for (i = 0; i < mvi->mvi_maccount; i++)
160 free(mvi->mvi_macaddr);
170 struct macvlan_info *mvi = link->l_info;
172 if (mvi->mvi_mask & MACVLAN_HAS_MODE) {
173 rtnl_link_macvlan_mode2str(mvi->mvi_mode, buf,
sizeof(buf));
177 if (mvi->mvi_mask & MACVLAN_HAS_FLAGS) {
178 rtnl_link_macvlan_flags2str(mvi->mvi_flags, buf,
sizeof(buf));
182 if (mvi->mvi_mask & MACVLAN_HAS_MACADDR) {
183 nl_dump(p,
" macvlan-count %u", (
unsigned) mvi->mvi_maccount);
185 if (mvi->mvi_maccount)
186 nl_dump(p,
" macvlan-sourcemac");
188 for (i = 0; i < mvi->mvi_maccount; i++) {
198 struct macvlan_info *vdst, *vsrc = src->l_info;
210 memcpy(vdst, vsrc,
sizeof(
struct macvlan_info));
212 if ( vsrc->mvi_mask & MACVLAN_HAS_MACADDR
213 && vsrc->mvi_maccount > 0) {
214 vdst->mvi_macaddr = calloc(vdst->mvi_maccount,
215 sizeof(*(vdst->mvi_macaddr)));
216 for (i = 0; i < vdst->mvi_maccount; i++)
219 vdst->mvi_macaddr = NULL;
224static int macvlan_put_attrs(
struct nl_msg *msg,
struct rtnl_link *link)
226 struct macvlan_info *mvi = link->l_info;
227 struct nlattr *data, *datamac = NULL;
235 if (mvi->mvi_mask & MACVLAN_HAS_MODE)
236 NLA_PUT_U32(msg, IFLA_MACVLAN_MODE, mvi->mvi_mode);
238 if (mvi->mvi_mask & MACVLAN_HAS_FLAGS)
239 NLA_PUT_U16(msg, IFLA_MACVLAN_FLAGS, mvi->mvi_flags);
241 if (mvi->mvi_mask & MACVLAN_HAS_MACADDR) {
242 NLA_PUT_U32(msg, IFLA_MACVLAN_MACADDR_MODE, mvi->mvi_macmode);
245 goto nla_put_failure;
247 for (i = 0; i < mvi->mvi_maccount; i++) {
249 mvi->mvi_macaddr[i]);
266 .io_alloc = macvlan_alloc,
267 .io_parse = macvlan_parse,
271 .io_clone = macvlan_clone,
272 .io_put_attrs = macvlan_put_attrs,
273 .io_free = macvlan_free,
278 .io_alloc = macvlan_alloc,
279 .io_parse = macvlan_parse,
283 .io_clone = macvlan_clone,
284 .io_put_attrs = macvlan_put_attrs,
285 .io_free = macvlan_free,
289#define IS_MACVLAN_LINK_ASSERT(link) \
290 if ((link)->l_info_ops != &macvlan_info_ops) { \
291 APPBUG("Link is not a macvlan link. set type \"macvlan\" first."); \
292 return -NLE_OPNOTSUPP; \
295#define IS_MACVTAP_LINK_ASSERT(link) \
296 if ((link)->l_info_ops != &macvtap_info_ops) { \
297 APPBUG("Link is not a macvtap link. set type \"macvtap\" first."); \
298 return -NLE_OPNOTSUPP; \
335 return link->l_info_ops && !strcmp(link->l_info_ops->
io_name,
"macvlan");
347 struct macvlan_info *mvi = link->l_info;
350 IS_MACVLAN_LINK_ASSERT(link);
352 mvi->mvi_mode = mode;
353 mvi->mvi_mask |= MACVLAN_HAS_MODE;
355 if (mode != MACVLAN_MODE_SOURCE) {
356 for (i = 0; i < mvi->mvi_maccount; i++)
358 free(mvi->mvi_macaddr);
359 mvi->mvi_maccount = 0;
360 mvi->mvi_macaddr = NULL;
361 mvi->mvi_macmode = MACVLAN_MACADDR_SET;
362 mvi->mvi_mask &= ~MACVLAN_HAS_MACADDR;
376 struct macvlan_info *mvi = link->l_info;
378 IS_MACVLAN_LINK_ASSERT(link);
380 if (mvi->mvi_mask & MACVLAN_HAS_MODE)
381 return mvi->mvi_mode;
397 struct macvlan_info *mvi = link->l_info;
399 IS_MACVLAN_LINK_ASSERT(link);
401 if (!(mvi->mvi_mask & MACVLAN_HAS_MODE) ||
402 (mvi->mvi_mode != MACVLAN_MODE_SOURCE))
405 mvi->mvi_macmode = macmode;
406 mvi->mvi_mask |= MACVLAN_HAS_MACADDR;
422 struct macvlan_info *mvi = link->l_info;
424 IS_MACVLAN_LINK_ASSERT(link);
426 if (!(mvi->mvi_mask & MACVLAN_HAS_MODE) ||
427 (mvi->mvi_mode != MACVLAN_MODE_SOURCE))
430 if (!(mvi->mvi_mask & MACVLAN_HAS_MACADDR))
433 *out_macmode = mvi->mvi_macmode;
447 struct macvlan_info *mvi = link->l_info;
449 IS_MACVLAN_LINK_ASSERT(link);
451 mvi->mvi_flags |= flags;
452 mvi->mvi_mask |= MACVLAN_HAS_FLAGS;
469 struct macvlan_info *mvi = link->l_info;
471 IS_MACVLAN_LINK_ASSERT(link);
473 mvi->mvi_flags &= ~flags;
474 mvi->mvi_mask |= MACVLAN_HAS_FLAGS;
487 struct macvlan_info *mvi = link->l_info;
489 IS_MACVLAN_LINK_ASSERT(link);
491 return mvi->mvi_flags;
503 struct macvlan_info *mvi = link->l_info;
505 IS_MACVLAN_LINK_ASSERT(link);
507 if (!(mvi->mvi_mask & MACVLAN_HAS_MODE) ||
508 (mvi->mvi_mode != MACVLAN_MODE_SOURCE))
511 if (!(mvi->mvi_mask & MACVLAN_HAS_MACADDR))
514 *out_count = mvi->mvi_maccount;
531 const struct nl_addr **out_addr)
533 struct macvlan_info *mvi = link->l_info;
535 IS_MACVLAN_LINK_ASSERT(link);
537 if (!(mvi->mvi_mask & MACVLAN_HAS_MODE) ||
538 (mvi->mvi_mode != MACVLAN_MODE_SOURCE))
541 if (!(mvi->mvi_mask & MACVLAN_HAS_MACADDR))
544 if (idx >= mvi->mvi_maccount)
547 *out_addr = mvi->mvi_macaddr[idx];
562 struct macvlan_info *mvi = link->l_info;
563 struct nl_addr **mvi_macaddr;
566 IS_MACVLAN_LINK_ASSERT(link);
571 if (!(mvi->mvi_mask & MACVLAN_HAS_MODE) ||
572 (mvi->mvi_mode != MACVLAN_MODE_SOURCE))
575 if (!(mvi->mvi_mask & MACVLAN_HAS_MACADDR))
578 if (mvi->mvi_maccount >= UINT32_MAX)
581 newsize = (mvi->mvi_maccount + 1) *
sizeof(*(mvi->mvi_macaddr));
582 mvi_macaddr = realloc(mvi->mvi_macaddr, newsize);
586 mvi->mvi_macaddr = mvi_macaddr;
590 mvi->mvi_mask |= MACVLAN_HAS_MACADDR;
607 struct macvlan_info *mvi = link->l_info;
610 IS_MACVLAN_LINK_ASSERT(link);
615 if (!(mvi->mvi_mask & MACVLAN_HAS_MODE) ||
616 (mvi->mvi_mode != MACVLAN_MODE_SOURCE))
619 if (!(mvi->mvi_mask & MACVLAN_HAS_MACADDR))
625 while (i + found < mvi->mvi_maccount) {
626 mvi->mvi_macaddr[i] = mvi->mvi_macaddr[i + found];
628 mvi->mvi_macaddr[i + found] = NULL;
631 mvi->mvi_macaddr[i] = NULL;
639 mvi->mvi_maccount -= found;
641 return found > INT_MAX ? INT_MAX : (int) found;
680 return link->l_info_ops && !strcmp(link->l_info_ops->
io_name,
"macvtap");
692 struct macvlan_info *mvi = link->l_info;
694 IS_MACVTAP_LINK_ASSERT(link);
696 mvi->mvi_mode = mode;
697 mvi->mvi_mask |= MACVLAN_HAS_MODE;
710 struct macvlan_info *mvi = link->l_info;
712 IS_MACVTAP_LINK_ASSERT(link);
714 if (mvi->mvi_mask & MACVLAN_HAS_MODE)
715 return mvi->mvi_mode;
729 struct macvlan_info *mvi = link->l_info;
731 IS_MACVTAP_LINK_ASSERT(link);
733 mvi->mvi_flags |= flags;
734 mvi->mvi_mask |= MACVLAN_HAS_FLAGS;
751 struct macvlan_info *mvi = link->l_info;
753 IS_MACVTAP_LINK_ASSERT(link);
755 mvi->mvi_flags &= ~flags;
756 mvi->mvi_mask |= MACVLAN_HAS_FLAGS;
769 struct macvlan_info *mvi = link->l_info;
771 IS_MACVTAP_LINK_ASSERT(link);
773 return mvi->mvi_flags;
779static const struct trans_tbl macvlan_flags[] = {
780 __ADD(MACVLAN_FLAG_NOPROMISC, nopromisc),
783static const struct trans_tbl macvlan_modes[] = {
784 __ADD(MACVLAN_MODE_PRIVATE,
private),
785 __ADD(MACVLAN_MODE_VEPA, vepa),
786 __ADD(MACVLAN_MODE_BRIDGE, bridge),
787 __ADD(MACVLAN_MODE_PASSTHRU, passthru),
788 __ADD(MACVLAN_MODE_SOURCE, source),
791static const struct trans_tbl macvlan_macmodes[] = {
792 __ADD(MACVLAN_MACADDR_ADD,
"add"),
793 __ADD(MACVLAN_MACADDR_DEL,
"del"),
794 __ADD(MACVLAN_MACADDR_SET,
"set"),
795 __ADD(MACVLAN_MACADDR_FLUSH,
"flush"),
803char *rtnl_link_macvlan_flags2str(
int flags,
char *buf,
size_t len)
805 return __flags2str(flags, buf, len, macvlan_flags, ARRAY_SIZE(macvlan_flags));
808int rtnl_link_macvlan_str2flags(
const char *name)
810 return __str2flags(name, macvlan_flags, ARRAY_SIZE(macvlan_flags));
813char *rtnl_link_macvtap_flags2str(
int flags,
char *buf,
size_t len)
815 return __flags2str(flags, buf, len, macvlan_flags, ARRAY_SIZE(macvlan_flags));
818int rtnl_link_macvtap_str2flags(
const char *name)
820 return __str2flags(name, macvlan_flags, ARRAY_SIZE(macvlan_flags));
830char *rtnl_link_macvlan_mode2str(
int mode,
char *buf,
size_t len)
832 return __type2str(mode, buf, len, macvlan_modes, ARRAY_SIZE(macvlan_modes));
835int rtnl_link_macvlan_str2mode(
const char *name)
837 return __str2type(name, macvlan_modes, ARRAY_SIZE(macvlan_modes));
840char *rtnl_link_macvlan_macmode2str(
int mode,
char *buf,
size_t len)
842 return __type2str(mode, buf, len, macvlan_macmodes,
843 ARRAY_SIZE(macvlan_macmodes));
846int rtnl_link_macvlan_str2macmode(
const char *name)
848 return __str2type(name, macvlan_macmodes, ARRAY_SIZE(macvlan_macmodes));
851char *rtnl_link_macvtap_mode2str(
int mode,
char *buf,
size_t len)
853 return __type2str(mode, buf, len, macvlan_modes, ARRAY_SIZE(macvlan_modes));
856int rtnl_link_macvtap_str2mode(
const char *name)
858 return __str2type(name, macvlan_modes, ARRAY_SIZE(macvlan_modes));
863static void _nl_init macvlan_init(
void)
869static void _nl_exit macvlan_exit(
void)
struct nl_addr * nl_addr_get(struct nl_addr *addr)
Increase the reference counter of an abstract address.
struct nl_addr * nl_addr_alloc_attr(const struct nlattr *nla, int family)
Allocate abstract address based on Netlink attribute.
int nl_addr_cmp(const struct nl_addr *a, const struct nl_addr *b)
Compare abstract addresses.
struct nl_addr * nl_addr_clone(const struct nl_addr *addr)
Clone existing abstract address object.
int nl_addr_get_family(const struct nl_addr *addr)
Return address family.
char * nl_addr2str(const struct nl_addr *addr, char *buf, size_t size)
Convert abstract address object to character string.
void nl_addr_put(struct nl_addr *addr)
Decrease the reference counter of an abstract address.
uint32_t nla_get_u32(const struct nlattr *nla)
Return payload of 32 bit integer attribute.
uint16_t nla_get_u16(const struct nlattr *nla)
Return payload of 16 bit integer attribute.
#define NLA_PUT_U16(msg, attrtype, value)
Add 16 bit integer attribute to netlink message.
struct nlattr * nla_next(const struct nlattr *nla, int *remaining)
Return next attribute in a stream of attributes.
int nla_type(const struct nlattr *nla)
Return type of the attribute.
#define NLA_PUT_ADDR(msg, attrtype, addr)
Add address attribute to netlink message.
int nla_ok(const struct nlattr *nla, int remaining)
Check if the attribute header and payload can be accessed safely.
void * nla_data(const struct nlattr *nla)
Return pointer to the payload section.
#define NLA_PUT_U32(msg, attrtype, value)
Add 32 bit integer attribute to netlink message.
struct nlattr * nla_nest_start(struct nl_msg *msg, int attrtype)
Start a new level of nested attributes.
int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla, const struct nla_policy *policy)
Create attribute index based on nested attribute.
int nla_len(const struct nlattr *nla)
Return length of the payload .
int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
Finalize nesting of attributes.
@ NLA_UNSPEC
Unspecified type, binary data chunk.
@ NLA_NESTED
Nested attributes.
int rtnl_link_register_info(struct rtnl_link_info_ops *ops)
Register operations for a link info type.
int rtnl_link_unregister_info(struct rtnl_link_info_ops *ops)
Unregister operations for a link info type.
struct rtnl_link * rtnl_link_alloc(void)
Allocate link object.
void rtnl_link_put(struct rtnl_link *link)
Release a link object reference.
int rtnl_link_set_type(struct rtnl_link *link, const char *type)
Set type of link object.
int rtnl_link_macvlan_get_macmode(struct rtnl_link *link, uint32_t *out_macmode)
Get MACVLAN MACMODE.
int rtnl_link_is_macvtap(struct rtnl_link *link)
Check if link is a MACVTAP link.
int rtnl_link_macvtap_set_flags(struct rtnl_link *link, uint16_t flags)
Set MACVTAP flags.
int rtnl_link_macvlan_unset_flags(struct rtnl_link *link, uint16_t flags)
Unset MACVLAN flags.
int rtnl_link_macvlan_set_mode(struct rtnl_link *link, uint32_t mode)
Set MACVLAN MODE.
uint32_t rtnl_link_macvtap_get_mode(struct rtnl_link *link)
Get MACVTAP Mode.
struct rtnl_link * rtnl_link_macvlan_alloc(void)
Allocate link object of type MACVLAN.
int rtnl_link_macvtap_set_mode(struct rtnl_link *link, uint32_t mode)
Set MACVTAP MODE.
uint16_t rtnl_link_macvtap_get_flags(struct rtnl_link *link)
Get MACVTAP flags.
uint32_t rtnl_link_macvlan_get_mode(struct rtnl_link *link)
Get MACVLAN Mode.
int rtnl_link_macvlan_set_macmode(struct rtnl_link *link, uint32_t macmode)
Set MACVLAN MACMODE.
int rtnl_link_macvtap_unset_flags(struct rtnl_link *link, uint16_t flags)
Unset MACVTAP flags.
int rtnl_link_macvlan_get_macaddr(struct rtnl_link *link, uint32_t idx, const struct nl_addr **out_addr)
Get configured remote MAC-Addr from MACVLAN device in source mode.
int rtnl_link_macvlan_set_flags(struct rtnl_link *link, uint16_t flags)
Set MACVLAN flags.
int rtnl_link_macvlan_del_macaddr(struct rtnl_link *link, struct nl_addr *addr)
Remove MAC-Addr from MACVLAN device in source mode.
uint16_t rtnl_link_macvlan_get_flags(struct rtnl_link *link)
Get MACVLAN flags.
int rtnl_link_is_macvlan(struct rtnl_link *link)
Check if link is a MACVLAN link.
int rtnl_link_macvlan_add_macaddr(struct rtnl_link *link, struct nl_addr *addr)
Add MAC-Addr to MACVLAN device in source mode.
struct rtnl_link * rtnl_link_macvtap_alloc(void)
Allocate link object of type MACVTAP.
int rtnl_link_macvlan_count_macaddr(struct rtnl_link *link, uint32_t *out_count)
Get number of MAC-Addr for MACVLAN device in source mode.
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
@ NL_DUMP_DETAILS
Dump all attributes but no statistics.
Attribute validation policy.
uint16_t type
Type of attribute or NLA_UNSPEC.
Available operations to modules implementing a link info type.
char * io_name
Name of link info type, must match name on kernel side.