#define IFLA_WEIGHT IFLA_WEIGHT
IFLA_OPERSTATE,
IFLA_LINKMODE,
+ IFLA_LINKINFO,
+#define IFLA_LINKINFO IFLA_LINKINFO
+ IFLA_NET_NS_PID,
__IFLA_MAX
};
__u32 retrans_time;
};
+enum
+{
+ IFLA_INFO_UNSPEC,
+ IFLA_INFO_KIND,
+ IFLA_INFO_DATA,
+ IFLA_INFO_XSTATS,
+ __IFLA_INFO_MAX,
+};
+
+#define IFLA_INFO_MAX (__IFLA_INFO_MAX - 1)
+
+/* VLAN section */
+
+enum
+{
+ IFLA_VLAN_UNSPEC,
+ IFLA_VLAN_ID,
+ IFLA_VLAN_FLAGS,
+ IFLA_VLAN_EGRESS_QOS,
+ IFLA_VLAN_INGRESS_QOS,
+ __IFLA_VLAN_MAX,
+};
+
+#define IFLA_VLAN_MAX (__IFLA_VLAN_MAX - 1)
+
+struct ifla_vlan_flags {
+ __u32 flags;
+ __u32 mask;
+};
+
+enum
+{
+ IFLA_VLAN_QOS_UNSPEC,
+ IFLA_VLAN_QOS_MAPPING,
+ __IFLA_VLAN_QOS_MAX
+};
+
+#define IFLA_VLAN_QOS_MAX (__IFLA_VLAN_QOS_MAX - 1)
+
+struct ifla_vlan_qos_mapping
+{
+ __u32 from;
+ __u32 to;
+};
+
#endif /* _LINUX_IF_LINK_H */
uint32_t l_flag_mask;
uint8_t l_operstate;
uint8_t l_linkmode;
+ /* 2 byte hole */
+ struct rtnl_link_info_ops *l_info_ops;
+ void * l_info;
};
struct rtnl_ncacheinfo
extern uint64_t rtnl_link_get_stat(struct rtnl_link *, int);
+extern int rtnl_link_set_info_type(struct rtnl_link *,
+ const char *);
+extern char * rtnl_link_get_info_type(struct rtnl_link *);
+
#ifdef __cplusplus
}
#endif
--- /dev/null
+/*
+ * netlink/route/link/info-api.h Link Info API
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef NETLINK_LINK_INFO_API_H_
+#define NETLINK_LINK_INFO_API_H_
+
+#include <netlink/netlink.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @ingroup link_info
+ *
+ * Link info operations
+ */
+struct rtnl_link_info_ops
+{
+ /** Name of operations, must match name on kernel side */
+ char * io_name;
+
+ /** Reference count (internal, do not use) */
+ int io_refcnt;
+
+ /** Called to assign an info type to a link.
+ * Has to allocate enough resources to hold attributes. Can
+ * use link->l_info to store a pointer. */
+ int (*io_alloc)(struct rtnl_link *);
+
+ /** Called to parse the link info attribute.
+ * Must parse the attribute and assign all values to the link.
+ */
+ int (*io_parse)(struct rtnl_link *,
+ struct nlattr *,
+ struct nlattr *);
+
+ /** Called when the link object is dumped.
+ * Must dump the info type specific attributes. */
+ int (*io_dump[NL_DUMP_MAX+1])(struct rtnl_link *,
+ struct nl_dump_params *, int);
+
+ /** Called when a link object is cloned.
+ * Must clone all info type specific attributes. */
+ int (*io_clone)(struct rtnl_link *, struct rtnl_link *);
+
+ /** Called when construction a link netlink message.
+ * Must append all info type specific attributes to the message. */
+ int (*io_put_attrs)(struct nl_msg *, struct rtnl_link *);
+
+ /** Called to release all resources previously allocated
+ * in either io_alloc() or io_parse(). */
+ void (*io_free)(struct rtnl_link *);
+
+ struct rtnl_link_info_ops * io_next;
+};
+
+extern struct rtnl_link_info_ops *rtnl_link_info_ops_lookup(const char *);
+
+extern int rtnl_link_register_info(struct rtnl_link_info_ops *);
+extern int rtnl_link_unregister_info(struct rtnl_link_info_ops *);
+
+#endif
--- /dev/null
+/*
+ * netlink/route/link/vlan.h VLAN interface
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef NETLINK_LINK_VLAN_H_
+#define NETLINK_LINK_VLAN_H_
+
+#include <netlink/netlink.h>
+#include <netlink/route/link.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct vlan_map
+{
+ uint32_t vm_from;
+ uint32_t vm_to;
+};
+
+#define VLAN_PRIO_MAX 7
+
+extern char * rtnl_link_vlan_flags2str(int, char *, size_t);
+extern int rtnl_link_vlan_str2flags(const char *);
+
+extern int rtnl_link_vlan_set_id(struct rtnl_link *, int);
+extern int rtnl_link_vlan_get_id(struct rtnl_link *);
+
+extern int rtnl_link_vlan_set_flags(struct rtnl_link *,
+ unsigned int);
+extern int rtnl_link_vlan_unset_flags(struct rtnl_link *,
+ unsigned int);
+extern unsigned int rtnl_link_vlan_get_flags(struct rtnl_link *);
+
+extern int rtnl_link_vlan_set_ingress_map(struct rtnl_link *,
+ int, uint32_t);
+extern uint32_t * rtnl_link_vlan_get_ingress_map(struct rtnl_link *);
+
+extern int rtnl_link_vlan_set_egress_map(struct rtnl_link *,
+ uint32_t, int);
+extern struct vlan_map *rtnl_link_vlan_get_egress_map(struct rtnl_link *,
+ int *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
CIN += $(wildcard route/sch/*.c)
# Classifiers
CIN += $(wildcard route/cls/*.c)
+# Link Info Modules
+CIN += $(wildcard route/link/*.c)
# NETLINK_GENERIC
CIN += $(wildcard genl/*.c)
# fib lookup
* // Don't forget to give back the link object ;->
* rtnl_link_put(old);
* @endcode
+ *
+ * @par 3) Link Type Specific Attributes
+ * @code
+ * // Some link types offer additional parameters and statistics specific
+ * // to their type. F.e. a VLAN link can be configured like this:
+ * //
+ * // Allocate a new link and set the info type to "vlan". This is required
+ * // to prepare the link to hold vlan specific attributes.
+ * struct rtnl_link *request = rtnl_link_alloc();
+ * rtnl_link_set_info_type(request, "vlan");
+ *
+ * // Now vlan specific attributes can be set:
+ * rtnl_link_vlan_set_id(request, 10);
+ * rtnl_link_vlan_set_ingress_map(request, 2, 8);
+ *
+ * // Of course the attributes can also be read, check the info type
+ * // to make sure you are using the right access functions:
+ * char *type = rtnl_link_get_info_type(link);
+ * if (!strcmp(type, "vlan"))
+ * int id = rtnl_link_vlan_get_id(link);
+ * @endcode
* @{
*/
#include <netlink/object.h>
#include <netlink/route/rtnl.h>
#include <netlink/route/link.h>
+#include <netlink/route/link/info-api.h>
/** @cond SKIP */
#define LINK_ATTR_MTU 0x0001
#define LINK_ATTR_CHANGE 0x8000
#define LINK_ATTR_OPERSTATE 0x10000
#define LINK_ATTR_LINKMODE 0x20000
+#define LINK_ATTR_LINKINFO 0x40000
static struct nl_cache_ops rtnl_link_ops;
static struct nl_object_ops link_obj_ops;
/** @endcond */
+static void release_link_info(struct rtnl_link *link)
+{
+ struct rtnl_link_info_ops *io = link->l_info_ops;
+
+ if (io != NULL) {
+ io->io_refcnt--;
+ io->io_free(link);
+ link->l_info_ops = NULL;
+ }
+}
+
static void link_free_data(struct nl_object *c)
{
struct rtnl_link *link = nl_object_priv(c);
if (link) {
+ struct rtnl_link_info_ops *io;
+
+ if ((io = link->l_info_ops) != NULL)
+ release_link_info(link);
+
nl_addr_put(link->l_addr);
nl_addr_put(link->l_bcast);
}
{
struct rtnl_link *dst = nl_object_priv(_dst);
struct rtnl_link *src = nl_object_priv(_src);
+ int err;
if (src->l_addr)
if (!(dst->l_addr = nl_addr_clone(src->l_addr)))
if (!(dst->l_bcast = nl_addr_clone(src->l_bcast)))
goto errout;
+ if (src->l_info_ops && src->l_info_ops->io_clone) {
+ err = src->l_info_ops->io_clone(dst, src);
+ if (err < 0)
+ goto errout;
+ }
+
return 0;
errout:
return nl_get_errno();
[IFLA_MASTER] = { .type = NLA_U32 },
[IFLA_OPERSTATE]= { .type = NLA_U8 },
[IFLA_LINKMODE] = { .type = NLA_U8 },
+ [IFLA_LINKINFO] = { .type = NLA_NESTED },
[IFLA_QDISC] = { .type = NLA_STRING,
.maxlen = IFQDISCSIZ },
[IFLA_STATS] = { .minlen = sizeof(struct rtnl_link_stats) },
[IFLA_MAP] = { .minlen = sizeof(struct rtnl_link_ifmap) },
};
+static struct nla_policy link_info_policy[IFLA_INFO_MAX+1] = {
+ [IFLA_INFO_KIND] = { .type = NLA_STRING },
+ [IFLA_INFO_DATA] = { .type = NLA_NESTED },
+ [IFLA_INFO_XSTATS] = { .type = NLA_NESTED },
+};
+
static int link_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
struct nlmsghdr *n, struct nl_parser_param *pp)
{
link->ce_mask |= LINK_ATTR_LINKMODE;
}
+ if (tb[IFLA_LINKINFO]) {
+ struct nlattr *li[IFLA_INFO_MAX+1];
+
+ err = nla_parse_nested(li, IFLA_INFO_MAX, tb[IFLA_LINKINFO],
+ link_info_policy);
+ if (err < 0)
+ goto errout;
+
+ if (li[IFLA_INFO_KIND] &&
+ (li[IFLA_INFO_DATA] || li[IFLA_INFO_XSTATS])) {
+ struct rtnl_link_info_ops *ops;
+ char *kind;
+
+ kind = nla_get_string(li[IFLA_INFO_KIND]);
+ ops = rtnl_link_info_ops_lookup(kind);
+ if (ops != NULL) {
+ ops->io_refcnt++;
+ link->l_info_ops = ops;
+ err = ops->io_parse(link, li[IFLA_INFO_DATA],
+ li[IFLA_INFO_XSTATS]);
+ if (err < 0)
+ goto errout;
+ } else {
+ /* XXX: Warn about unparsed info? */
+ }
+ }
+ }
+
err = pp->pp_cb((struct nl_object *) link, pp);
if (err < 0)
goto errout;
struct rtnl_link *link = (struct rtnl_link *) obj;
int line = 1;
- dp_dump(p, "%s ", link->l_name);
-
- if (link->ce_mask & LINK_ATTR_LINK) {
- struct rtnl_link *ll = rtnl_link_get(cache, link->l_link);
- dp_dump(p, "@%s", ll ? ll->l_name : "NONE");
- if (ll)
- rtnl_link_put(ll);
- }
-
- dp_dump(p, "%s ", nl_llproto2str(link->l_arptype, buf, sizeof(buf)));
+ dp_dump(p, "%s %s ", link->l_name,
+ nl_llproto2str(link->l_arptype, buf, sizeof(buf)));
if (link->l_addr && !nl_addr_iszero(link->l_addr))
dp_dump(p, "%s ", nl_addr2str(link->l_addr, buf, sizeof(buf)));
rtnl_link_flags2str(link->l_flags, buf, sizeof(buf));
if (buf[0])
- dp_dump(p, "<%s>", buf);
+ dp_dump(p, "<%s> ", buf);
+
+ if (link->ce_mask & LINK_ATTR_LINK) {
+ struct rtnl_link *ll = rtnl_link_get(cache, link->l_link);
+ dp_dump(p, "slave-of %s ", ll ? ll->l_name : "NONE");
+ if (ll)
+ rtnl_link_put(ll);
+ }
+
+ if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_BRIEF])
+ line = link->l_info_ops->io_dump[NL_DUMP_BRIEF](link, p, line);
dp_dump(p, "\n");
dp_dump(p, "mode %s\n",
rtnl_link_mode2str(link->l_linkmode, buf, sizeof(buf)));
+ if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_FULL])
+ line = link->l_info_ops->io_dump[NL_DUMP_FULL](link, p, line);
+
return line;
}
link->l_stats[RTNL_LINK_TX_WIN_ERR],
link->l_stats[RTNL_LINK_TX_COLLISIONS]);
+ if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_STATS])
+ line = link->l_info_ops->io_dump[NL_DUMP_STATS](link, p, line);
+
return line;
}
dp_dump_line(p, line++, " </stats>\n");
}
+ if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_XML]) {
+ dp_dump_line(p, line++, " <info>\n");
+ line = link->l_info_ops->io_dump[NL_DUMP_XML](link, p, line);
+ dp_dump_line(p, line++, " </info>\n");
+ }
+
dp_dump_line(p, line++, "</link>\n");
#if 0
}
}
+ if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_ENV])
+ line = link->l_info_ops->io_dump[NL_DUMP_ENV](link, p, line);
+
return line;
}
if (tmpl->ce_mask & LINK_ATTR_LINKMODE)
NLA_PUT_U8(msg, IFLA_LINKMODE, tmpl->l_linkmode);
+ if ((tmpl->ce_mask & LINK_ATTR_LINKINFO) && tmpl->l_info_ops &&
+ tmpl->l_info_ops->io_put_attrs) {
+ struct nlattr *info;
+
+ if (!(info = nla_nest_start(msg, IFLA_LINKINFO)))
+ goto nla_put_failure;
+
+ NLA_PUT_STRING(msg, IFLA_INFO_KIND, tmpl->l_info_ops->io_name);
+
+ if (tmpl->l_info_ops->io_put_attrs(msg, tmpl) < 0)
+ goto nla_put_failure;
+
+ nla_nest_end(msg, info);
+ }
+
return msg;
nla_put_failure:
return link->l_stats[id];
}
+/**
+ * Specify the info type of a link
+ * @arg link link object
+ * @arg type info type
+ *
+ * Looks up the info type and prepares the link to store info type
+ * specific attributes. If an info type has been assigned already
+ * it will be released with all changes lost.
+ *
+ * @return 0 on success or a negative errror code.
+ */
+int rtnl_link_set_info_type(struct rtnl_link *link, const char *type)
+{
+ struct rtnl_link_info_ops *io;
+ int err;
+
+ if ((io = rtnl_link_info_ops_lookup(type)) == NULL)
+ return nl_error(ENOENT, "No such link info type exists");
+
+ if (link->l_info_ops)
+ release_link_info(link);
+
+ if ((err = io->io_alloc(link)) < 0)
+ return err;
+
+ link->l_info_ops = io;
+
+ return 0;
+}
+
+/**
+ * Return info type of a link
+ * @arg link link object
+ *
+ * @note The returned pointer is only valid as long as the link exists
+ * @return Info type name or NULL if unknown.
+ */
+char *rtnl_link_get_info_type(struct rtnl_link *link)
+{
+ if (link->l_info_ops)
+ return link->l_info_ops->io_name;
+ else
+ return NULL;
+}
+
/** @} */
static struct nl_object_ops link_obj_ops = {
--- /dev/null
+/*
+ * lib/route/link/api.c Link Info API
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
+ */
+
+/**
+ * @ingroup link
+ * @defgroup link_info Link Info API
+ * @brief
+ *
+ * @par 1) Registering/Unregistering a new link info type
+ * @code
+ * static struct rtnl_link_info_ops vlan_info_ops = {
+ * .io_name = "vlan",
+ * .io_alloc = vlan_alloc,
+ * .io_parse = vlan_parse,
+ * .io_dump[NL_DUMP_BRIEF] = vlan_dump_brief,
+ * .io_dump[NL_DUMP_FULL] = vlan_dump_full,
+ * .io_free = vlan_free,
+ * };
+ *
+ * static void __init vlan_init(void)
+ * {
+ * rtnl_link_register_info(&vlan_info_ops);
+ * }
+ *
+ * static void __exit vlan_exit(void)
+ * {
+ * rtnl_link_unregister_info(&vlan_info_ops);
+ * }
+ * @endcode
+ *
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/utils.h>
+#include <netlink/route/link.h>
+#include <netlink/route/link/info-api.h>
+
+static struct rtnl_link_info_ops *info_ops;
+
+struct rtnl_link_info_ops *rtnl_link_info_ops_lookup(const char *name)
+{
+ struct rtnl_link_info_ops *ops;
+
+ for (ops = info_ops; ops; ops = ops->io_next)
+ if (!strcmp(ops->io_name, name))
+ return ops;
+
+ return NULL;
+}
+
+int rtnl_link_register_info(struct rtnl_link_info_ops *ops)
+{
+ if (ops->io_name == NULL)
+ return nl_error(EINVAL, "No name specified");
+
+ if (rtnl_link_info_ops_lookup(ops->io_name))
+ return nl_error(EEXIST, "Link info operations already exist");
+
+ NL_DBG(1, "Registered link info operations %s\n", ops->io_name);
+
+ ops->io_next = info_ops;
+ info_ops = ops;
+
+ return 0;
+}
+
+int rtnl_link_unregister_info(struct rtnl_link_info_ops *ops)
+{
+ struct rtnl_link_info_ops *t, **tp;
+
+ for (tp = &info_ops; (t=*tp) != NULL; tp = &t->io_next)
+ if (t == ops)
+ break;
+
+ if (!t)
+ return nl_error(ENOENT, "No such link info operations");
+
+ if (t->io_refcnt > 0)
+ return nl_error(EBUSY, "Info operations in use");
+
+ NL_DBG(1, "Unregistered link info perations %s\n", ops->io_name);
+
+ *tp = t->io_next;
+ return 0;
+}
+
+/** @} */
+
--- /dev/null
+/*
+ * lib/route/link/vlan.c VLAN Link Info
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * Copyright (c) 2003-2007 Thomas Graf <tgraf@suug.ch>
+ */
+
+/**
+ * @ingroup link_info
+ * @defgroup vlan VLAN
+ * @brief
+ *
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/attr.h>
+#include <netlink/utils.h>
+#include <netlink/object.h>
+#include <netlink/route/rtnl.h>
+#include <netlink/route/link/info-api.h>
+#include <netlink/route/link/vlan.h>
+
+#include <linux/if_vlan.h>
+
+/** @cond SKIP */
+#define VLAN_HAS_ID (1<<0)
+#define VLAN_HAS_FLAGS (1<<1)
+#define VLAN_HAS_INGRESS_QOS (1<<2)
+#define VLAN_HAS_EGRESS_QOS (1<<3)
+
+struct vlan_info
+{
+ uint16_t vi_vlan_id;
+ uint32_t vi_flags;
+ uint32_t vi_flags_mask;
+ uint32_t vi_ingress_qos[VLAN_PRIO_MAX+1];
+ uint32_t vi_negress;
+ uint32_t vi_egress_size;
+ struct vlan_map * vi_egress_qos;
+ uint32_t vi_mask;
+};
+/** @endcond */
+
+static struct trans_tbl vlan_flags[] = {
+ __ADD(VLAN_FLAG_REORDER_HDR, reorder_hdr)
+};
+
+char *rtnl_link_vlan_flags2str(int flags, char *buf, size_t len)
+{
+ return __flags2str(flags, buf, len, vlan_flags, ARRAY_SIZE(vlan_flags));
+}
+
+int rtnl_link_vlan_str2flags(const char *name)
+{
+ return __str2flags(name, vlan_flags, ARRAY_SIZE(vlan_flags));
+}
+
+static struct nla_policy vlan_policy[IFLA_VLAN_MAX+1] = {
+ [IFLA_VLAN_ID] = { .type = NLA_U16 },
+ [IFLA_VLAN_FLAGS] = { .minlen = sizeof(struct ifla_vlan_flags) },
+ [IFLA_VLAN_INGRESS_QOS] = { .type = NLA_NESTED },
+ [IFLA_VLAN_EGRESS_QOS] = { .type = NLA_NESTED },
+};
+
+static int vlan_alloc(struct rtnl_link *link)
+{
+ struct vlan_info *vi;
+
+ if ((vi = calloc(1, sizeof(*vi))) == NULL)
+ return nl_errno(ENOMEM);
+
+ link->l_info = vi;
+
+ return 0;
+}
+
+static int vlan_parse(struct rtnl_link *link, struct nlattr *data,
+ struct nlattr *xstats)
+{
+ struct nlattr *tb[IFLA_VLAN_MAX+1];
+ struct vlan_info *vi;
+ int err;
+
+ NL_DBG(3, "Parsing VLAN link info");
+
+ if ((err = nla_parse_nested(tb, IFLA_VLAN_MAX, data, vlan_policy)) < 0)
+ goto errout;
+
+ if ((err = vlan_alloc(link)) < 0)
+ goto errout;
+
+ vi = link->l_info;
+
+ if (tb[IFLA_VLAN_ID]) {
+ vi->vi_vlan_id = nla_get_u16(tb[IFLA_VLAN_ID]);
+ vi->vi_mask |= VLAN_HAS_ID;
+ }
+
+ if (tb[IFLA_VLAN_FLAGS]) {
+ struct ifla_vlan_flags flags;
+ nla_memcpy(&flags, tb[IFLA_VLAN_FLAGS], sizeof(flags));
+
+ vi->vi_flags = flags.flags;
+ vi->vi_mask |= VLAN_HAS_FLAGS;
+ }
+
+ if (tb[IFLA_VLAN_INGRESS_QOS]) {
+ struct ifla_vlan_qos_mapping *map;
+ struct nlattr *nla;
+ int remaining;
+
+ memset(vi->vi_ingress_qos, 0, sizeof(vi->vi_ingress_qos));
+
+ nla_for_each_nested(nla, tb[IFLA_VLAN_INGRESS_QOS], remaining) {
+ if (nla_len(nla) < sizeof(*map))
+ return nl_error(EINVAL, "Malformed mapping");
+
+ map = nla_data(nla);
+ if (map->from < 0 || map->from > VLAN_PRIO_MAX) {
+ return nl_error(EINVAL, "VLAN prio %d out of "
+ "range", map->from);
+ }
+
+ vi->vi_ingress_qos[map->from] = map->to;
+ }
+
+ vi->vi_mask |= VLAN_HAS_INGRESS_QOS;
+ }
+
+ if (tb[IFLA_VLAN_EGRESS_QOS]) {
+ struct ifla_vlan_qos_mapping *map;
+ struct nlattr *nla;
+ int remaining, i = 0;
+
+ nla_for_each_nested(nla, tb[IFLA_VLAN_EGRESS_QOS], remaining) {
+ if (nla_len(nla) < sizeof(*map))
+ return nl_error(EINVAL, "Malformed mapping");
+ i++;
+ }
+
+ /* align to have a little reserve */
+ vi->vi_egress_size = (i + 32) & ~31;
+ vi->vi_egress_qos = calloc(vi->vi_egress_size, sizeof(*map));
+ if (vi->vi_egress_qos == NULL)
+ return nl_errno(ENOMEM);
+
+ i = 0;
+ nla_for_each_nested(nla, tb[IFLA_VLAN_EGRESS_QOS], remaining) {
+ map = nla_data(nla);
+ NL_DBG(4, "Assigning egress qos mapping %d\n", i);
+ vi->vi_egress_qos[i].vm_from = map->from;
+ vi->vi_egress_qos[i++].vm_to = map->to;
+ }
+
+ vi->vi_negress = i;
+ vi->vi_mask |= VLAN_HAS_EGRESS_QOS;
+ }
+
+ err = 0;
+errout:
+ return err;
+}
+
+static void vlan_free(struct rtnl_link *link)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (vi) {
+ free(vi->vi_egress_qos);
+ vi->vi_egress_qos = NULL;
+ }
+
+ free(vi);
+ link->l_info = NULL;
+}
+
+static int vlan_dump_brief(struct rtnl_link *link, struct nl_dump_params *p,
+ int line)
+{
+ struct vlan_info *vi = link->l_info;
+
+ dp_dump(p, "vlan-id %d", vi->vi_vlan_id);
+
+ return line;
+}
+
+static int vlan_dump_full(struct rtnl_link *link, struct nl_dump_params *p,
+ int line)
+{
+ struct vlan_info *vi = link->l_info;
+ int i, printed;
+ char buf[64];
+
+ rtnl_link_vlan_flags2str(vi->vi_flags, buf, sizeof(buf));
+ dp_dump_line(p, line++, " vlan-info id %d <%s>\n",
+ vi->vi_vlan_id, buf);
+
+ if (vi->vi_mask & VLAN_HAS_INGRESS_QOS) {
+ dp_dump_line(p, line++,
+ " ingress vlan prio -> qos/socket prio mapping:\n");
+ for (i = 0, printed = 0; i <= VLAN_PRIO_MAX; i++) {
+ if (vi->vi_ingress_qos[i]) {
+ if (printed == 0) {
+ dp_new_line(p, line);
+ dp_dump(p, " ");
+ }
+ dp_dump(p, "%x -> %#08x, ",
+ i, vi->vi_ingress_qos[i]);
+ if (printed++ == 3) {
+ dp_dump(p, "\n");
+ printed = 0;
+ }
+ }
+ }
+
+ if (printed > 0 && printed != 4)
+ dp_dump(p, "\n");
+ }
+
+ if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
+ dp_dump_line(p, line++,
+ " egress qos/socket prio -> vlan prio mapping:\n");
+ for (i = 0, printed = 0; i < vi->vi_negress; i++) {
+ if (printed == 0) {
+ dp_new_line(p, line);
+ dp_dump(p, " ");
+ }
+ dp_dump(p, "%#08x -> %x, ",
+ vi->vi_egress_qos[i].vm_from,
+ vi->vi_egress_qos[i].vm_to);
+ if (printed++ == 3) {
+ dp_dump(p, "\n");
+ printed = 0;
+ }
+ }
+
+ if (printed > 0 && printed != 4)
+ dp_dump(p, "\n");
+ }
+
+ return line;
+}
+
+static int vlan_clone(struct rtnl_link *dst, struct rtnl_link *src)
+{
+ struct vlan_info *vdst, *vsrc = src->l_info;
+ int err;
+
+ dst->l_info = NULL;
+ if ((err = rtnl_link_set_info_type(dst, "vlan")) < 0)
+ return err;
+ vdst = dst->l_info;
+
+ vdst->vi_egress_qos = calloc(vsrc->vi_egress_size,
+ sizeof(struct vlan_map));
+ if (!vdst->vi_egress_qos)
+ return nl_errno(ENOMEM);
+
+ memcpy(vdst->vi_egress_qos, vsrc->vi_egress_qos,
+ vsrc->vi_egress_size * sizeof(struct vlan_map));
+
+ return 0;
+}
+
+static int vlan_put_attrs(struct nl_msg *msg, struct rtnl_link *link)
+{
+ struct vlan_info *vi = link->l_info;
+ struct nlattr *data;
+
+ if (!(data = nla_nest_start(msg, IFLA_INFO_DATA)))
+ return nl_errno(ENOBUFS);
+
+ if (vi->vi_mask & VLAN_HAS_ID)
+ NLA_PUT_U16(msg, IFLA_VLAN_ID, vi->vi_vlan_id);
+
+ if (vi->vi_mask & VLAN_HAS_FLAGS) {
+ struct ifla_vlan_flags flags = {
+ .flags = vi->vi_flags,
+ .mask = vi->vi_flags_mask,
+ };
+
+ NLA_PUT(msg, IFLA_VLAN_FLAGS, sizeof(flags), &flags);
+ }
+
+ if (vi->vi_mask & VLAN_HAS_INGRESS_QOS) {
+ struct ifla_vlan_qos_mapping map;
+ struct nlattr *qos;
+ int i;
+
+ if (!(qos = nla_nest_start(msg, IFLA_VLAN_INGRESS_QOS)))
+ goto nla_put_failure;
+
+ for (i = 0; i <= VLAN_PRIO_MAX; i++) {
+ if (vi->vi_ingress_qos[i]) {
+ map.from = i;
+ map.to = vi->vi_ingress_qos[i];
+
+ NLA_PUT(msg, i, sizeof(map), &map);
+ }
+ }
+
+ nla_nest_end(msg, qos);
+ }
+
+ if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
+ struct ifla_vlan_qos_mapping map;
+ struct nlattr *qos;
+ int i;
+
+ if (!(qos = nla_nest_start(msg, IFLA_VLAN_EGRESS_QOS)))
+ goto nla_put_failure;
+
+ for (i = 0; i < vi->vi_negress; i++) {
+ map.from = vi->vi_egress_qos[i].vm_from;
+ map.to = vi->vi_egress_qos[i].vm_to;
+
+ NLA_PUT(msg, i, sizeof(map), &map);
+ }
+
+ nla_nest_end(msg, qos);
+ }
+
+ nla_nest_end(msg, data);
+
+nla_put_failure:
+
+ return 0;
+}
+
+static struct rtnl_link_info_ops vlan_info_ops = {
+ .io_name = "vlan",
+ .io_alloc = vlan_alloc,
+ .io_parse = vlan_parse,
+ .io_dump[NL_DUMP_BRIEF] = vlan_dump_brief,
+ .io_dump[NL_DUMP_FULL] = vlan_dump_full,
+ .io_clone = vlan_clone,
+ .io_free = vlan_free,
+};
+
+int rtnl_link_vlan_set_id(struct rtnl_link *link, int id)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
+ return nl_error(EOPNOTSUPP, "Not a VLAN link");
+
+ vi->vi_vlan_id = id;
+ vi->vi_mask |= VLAN_HAS_ID;
+
+ return 0;
+}
+
+int rtnl_link_vlan_get_id(struct rtnl_link *link)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
+ return nl_error(EOPNOTSUPP, "Not a VLAN link");
+
+ if (vi->vi_mask & VLAN_HAS_ID)
+ return vi->vi_vlan_id;
+ else
+ return 0;
+}
+
+int rtnl_link_vlan_set_flags(struct rtnl_link *link, unsigned int flags)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
+ return nl_error(EOPNOTSUPP, "Not a VLAN link");
+
+ vi->vi_flags_mask |= flags;
+ vi->vi_flags |= flags;
+ vi->vi_mask |= VLAN_HAS_FLAGS;
+
+ return 0;
+}
+
+int rtnl_link_vlan_unset_flags(struct rtnl_link *link, unsigned int flags)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
+ return nl_error(EOPNOTSUPP, "Not a VLAN link");
+
+ vi->vi_flags_mask |= flags;
+ vi->vi_flags &= ~flags;
+ vi->vi_mask |= VLAN_HAS_FLAGS;
+
+ return 0;
+}
+
+unsigned int rtnl_link_vlan_get_flags(struct rtnl_link *link)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
+ return nl_error(EOPNOTSUPP, "Not a VLAN link");
+
+ return vi->vi_flags;
+}
+
+int rtnl_link_vlan_set_ingress_map(struct rtnl_link *link, int from,
+ uint32_t to)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
+ return nl_error(EOPNOTSUPP, "Not a VLAN link");
+
+ if (from < 0 || from > VLAN_PRIO_MAX)
+ return nl_error(EINVAL, "Invalid vlan prio 0..%d",
+ VLAN_PRIO_MAX);
+
+ vi->vi_ingress_qos[from] = to;
+ vi->vi_mask |= VLAN_HAS_INGRESS_QOS;
+
+ return 0;
+}
+
+uint32_t *rtnl_link_vlan_get_ingress_map(struct rtnl_link *link)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops) {
+ nl_error(EOPNOTSUPP, "Not a VLAN link");
+ return NULL;
+ }
+
+ if (vi->vi_mask & VLAN_HAS_INGRESS_QOS)
+ return vi->vi_ingress_qos;
+ else
+ return NULL;
+}
+
+int rtnl_link_vlan_set_egress_map(struct rtnl_link *link, uint32_t from, int to)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops)
+ return nl_error(EOPNOTSUPP, "Not a VLAN link");
+
+ if (to < 0 || to > VLAN_PRIO_MAX)
+ return nl_error(EINVAL, "Invalid vlan prio 0..%d",
+ VLAN_PRIO_MAX);
+
+ if (vi->vi_negress >= vi->vi_egress_size) {
+ int new_size = vi->vi_egress_size + 32;
+ void *ptr;
+
+ ptr = realloc(vi->vi_egress_qos, new_size);
+ if (!ptr)
+ return nl_errno(ENOMEM);
+
+ vi->vi_egress_qos = ptr;
+ vi->vi_egress_size = new_size;
+ }
+
+ vi->vi_egress_qos[vi->vi_negress].vm_from = from;
+ vi->vi_egress_qos[vi->vi_negress].vm_to = to;
+ vi->vi_negress++;
+ vi->vi_mask |= VLAN_HAS_EGRESS_QOS;
+
+ return 0;
+}
+
+struct vlan_map *rtnl_link_vlan_get_egress_map(struct rtnl_link *link,
+ int *negress)
+{
+ struct vlan_info *vi = link->l_info;
+
+ if (link->l_info_ops != &vlan_info_ops || !link->l_info_ops) {
+ nl_error(EOPNOTSUPP, "Not a VLAN link");
+ return NULL;
+ }
+
+ if (negress == NULL) {
+ nl_error(EINVAL, "Require pointer to store negress");
+ return NULL;
+ }
+
+ if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
+ *negress = vi->vi_negress;
+ return vi->vi_egress_qos;
+ } else {
+ *negress = 0;
+ return NULL;
+ }
+}
+
+static void __init vlan_init(void)
+{
+ rtnl_link_register_info(&vlan_info_ops);
+}
+
+static void __exit vlan_exit(void)
+{
+ rtnl_link_unregister_info(&vlan_info_ops);
+}
+
+/** @} */
projects / thirdparty / libnl.git / commitdiff
