void nl_bridge::update_interface(rtnl_link *old_link, rtnl_link *new_link) {
assert(rtnl_link_get_family(old_link) == AF_BRIDGE);
assert(rtnl_link_get_family(new_link) == AF_BRIDGE);
// sanity checks
if (bridge == nullptr) {
LOG(ERROR) << __FUNCTION__ << ": cannot be done without bridge";
return;
}
if (rtnl_link_get_ifindex(bridge) != rtnl_link_get_master(new_link)) {
LOG(INFO) << __FUNCTION__ << ": link " << rtnl_link_get_name(new_link)
<< " is no slave of " << rtnl_link_get_name(bridge);
return;
}
update_vlans(old_link, new_link);
}
void nl_bridge::add_interface(rtnl_link *link) {
assert(rtnl_link_get_family(link) == AF_BRIDGE);
if (bridge == nullptr) {
LOG(ERROR) << __FUNCTION__ << ": cannot be done without bridge";
return;
}
if (rtnl_link_get_ifindex(bridge) != rtnl_link_get_master(link)) {
LOG(INFO) << __FUNCTION__ << ": link " << rtnl_link_get_name(link)
<< " is no slave of " << rtnl_link_get_name(bridge);
return;
}
update_vlans(nullptr, link);
}
static void handle_class(struct nl_object *obj, void *arg)
{
struct rtnl_tc *tc = (struct rtnl_tc *) obj;
struct element *e;
struct rdata *rdata = arg;
struct rdata ndata = {
.level = rdata->level + 1,
};
if (!(e = handle_tc_obj(tc, "class", rdata)))
return;
ndata.parent = e;
if (!strcmp(rtnl_tc_get_kind(tc), "htb"))
element_set_txmax(e, rtnl_htb_get_rate((struct rtnl_class *) tc));
find_classes(rtnl_tc_get_handle(tc), &ndata);
find_qdiscs(rtnl_tc_get_handle(tc), &ndata);
}
static void find_qdiscs(uint32_t parent, struct rdata *rdata)
{
struct rtnl_qdisc *filter;
if (!(filter = rtnl_qdisc_alloc()))
return;
rtnl_tc_set_parent((struct rtnl_tc *) filter, parent);
nl_cache_foreach_filter(qdisc_cache, OBJ_CAST(filter),
handle_qdisc, rdata);
rtnl_qdisc_put(filter);
}
static void find_cls(int ifindex, uint32_t parent, struct rdata *rdata)
{
struct nl_cache *cls_cache;
if (rtnl_cls_alloc_cache(sock, ifindex, parent, &cls_cache) < 0)
return;
nl_cache_foreach(cls_cache, handle_cls, rdata);
nl_cache_free(cls_cache);
}
static void find_classes(uint32_t parent, struct rdata *rdata)
{
struct rtnl_class *filter;
if (!(filter = rtnl_class_alloc()))
return;
rtnl_tc_set_parent((struct rtnl_tc *) filter, parent);
nl_cache_foreach_filter(class_cache, OBJ_CAST(filter),
handle_class, rdata);
rtnl_class_put(filter);
}
static void handle_qdisc(struct nl_object *obj, void *arg)
{
struct rtnl_tc *tc = (struct rtnl_tc *) obj;
struct element *e;
struct rdata *rdata = arg;
struct rdata ndata = {
.level = rdata->level + 1,
};
if (!(e = handle_tc_obj(tc, "qdisc", rdata)))
return;
ndata.parent = e;
find_cls(rtnl_tc_get_ifindex(tc), rtnl_tc_get_handle(tc), &ndata);
if (rtnl_tc_get_parent(tc) == TC_H_ROOT) {
find_cls(rtnl_tc_get_ifindex(tc), TC_H_ROOT, &ndata);
find_classes(TC_H_ROOT, &ndata);
}
find_classes(rtnl_tc_get_handle(tc), &ndata);
}
static void handle_tc(struct element *e, struct rtnl_link *link)
{
struct rtnl_qdisc *qdisc;
int ifindex = rtnl_link_get_ifindex(link);
struct rdata rdata = {
.level = 1,
.parent = e,
};
if (rtnl_class_alloc_cache(sock, ifindex, &class_cache) < 0)
return;
qdisc = rtnl_qdisc_get_by_parent(qdisc_cache, ifindex, TC_H_ROOT);
if (qdisc) {
handle_qdisc(OBJ_CAST(qdisc), &rdata);
rtnl_qdisc_put(qdisc);
}
qdisc = rtnl_qdisc_get_by_parent(qdisc_cache, ifindex, 0);
if (qdisc) {
handle_qdisc(OBJ_CAST(qdisc), &rdata);
rtnl_qdisc_put(qdisc);
}
qdisc = rtnl_qdisc_get_by_parent(qdisc_cache, ifindex, TC_H_INGRESS);
if (qdisc) {
handle_qdisc(OBJ_CAST(qdisc), &rdata);
rtnl_qdisc_put(qdisc);
}
nl_cache_free(class_cache);
}
static void update_link_infos(struct element *e, struct rtnl_link *link)
{
char buf[64];
snprintf(buf, sizeof(buf), "%u", rtnl_link_get_mtu(link));
element_update_info(e, "MTU", buf);
rtnl_link_flags2str(rtnl_link_get_flags(link), buf, sizeof(buf));
element_update_info(e, "Flags", buf);
rtnl_link_operstate2str(rtnl_link_get_operstate(link),
buf, sizeof(buf));
element_update_info(e, "Operstate", buf);
snprintf(buf, sizeof(buf), "%u", rtnl_link_get_ifindex(link));
element_update_info(e, "IfIndex", buf);
nl_addr2str(rtnl_link_get_addr(link), buf, sizeof(buf));
element_update_info(e, "Address", buf);
nl_addr2str(rtnl_link_get_broadcast(link), buf, sizeof(buf));
element_update_info(e, "Broadcast", buf);
rtnl_link_mode2str(rtnl_link_get_linkmode(link),
buf, sizeof(buf));
element_update_info(e, "Mode", buf);
snprintf(buf, sizeof(buf), "%u", rtnl_link_get_txqlen(link));
element_update_info(e, "TXQlen", buf);
nl_af2str(rtnl_link_get_family(link), buf, sizeof(buf));
element_update_info(e, "Family", buf);
element_update_info(e, "Alias",
rtnl_link_get_ifalias(link) ? : "");
element_update_info(e, "Qdisc",
rtnl_link_get_qdisc(link) ? : "");
if (rtnl_link_get_link(link)) {
snprintf(buf, sizeof(buf), "%u", rtnl_link_get_link(link));
element_update_info(e, "SlaveOfIndex", buf);
}
}
static void do_link(struct nl_object *obj, void *arg)
{
struct rtnl_link *link = (struct rtnl_link *) obj;
struct element *e, *e_parent = NULL;
int i, master_ifindex;
if (!cfg_show_all && !(rtnl_link_get_flags(link) & IFF_UP)) {
/* FIXME: delete element */
return;
}
/* Check if the interface is a slave of another interface */
if ((master_ifindex = rtnl_link_get_link(link))) {
char parent[IFNAMSIZ+1];
rtnl_link_i2name(link_cache, master_ifindex,
parent, sizeof(parent));
e_parent = element_lookup(grp, parent, master_ifindex, NULL, 0);
}
if (!(e = element_lookup(grp, rtnl_link_get_name(link),
rtnl_link_get_ifindex(link), e_parent, ELEMENT_CREAT)))
return;
if (e->e_flags & ELEMENT_FLAG_CREATED) {
if (e->e_parent)
e->e_level = e->e_parent->e_level + 1;
if (element_set_key_attr(e, "bytes", "packets") ||
element_set_usage_attr(e, "bytes"))
BUG();
/* FIXME: Update link infos every 1s or so */
update_link_infos(e, link);
e->e_flags &= ~ELEMENT_FLAG_CREATED;
}
for (i = 0; i < ARRAY_SIZE(link_attrs); i++) {
struct attr_map *m = &link_attrs[i];
uint64_t c_rx = 0, c_tx = 0;
int flags = 0;
if (m->rxid >= 0) {
c_rx = rtnl_link_get_stat(link, m->rxid);
flags |= UPDATE_FLAG_RX;
}
if (m->txid >= 0) {
c_tx = rtnl_link_get_stat(link, m->txid);
flags |= UPDATE_FLAG_TX;
}
attr_update(e, m->attrid, c_rx, c_tx, flags);
}
if (!c_notc)
handle_tc(e, link);
element_notify_update(e, NULL);
element_lifesign(e, 1);
}
static void netlink_read(void)
{
int err;
if ((err = nl_cache_resync(sock, link_cache, NULL, NULL)) < 0) {
fprintf(stderr, "Unable to resync link cache: %s\n", nl_geterror(err));
goto disable;
}
if ((err = nl_cache_resync(sock, qdisc_cache, NULL, NULL)) < 0) {
fprintf(stderr, "Unable to resync qdisc cache: %s\n", nl_geterror(err));
goto disable;
}
nl_cache_foreach(link_cache, do_link, NULL);
return;
disable:
netlink_ops.m_flags &= ~BMON_MODULE_ENABLED;
}
static void netlink_shutdown(void)
{
nl_cache_free(link_cache);
nl_cache_free(qdisc_cache);
nl_socket_free(sock);
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct nl_cache *link_cache;
struct rtnl_link *link;
struct nl_dump_params params = {
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link = nl_cli_link_alloc();
for (;;) {
int c, optidx = 0;
enum {
ARG_FAMILY = 257,
ARG_MTU = 258,
ARG_TXQLEN,
ARG_WEIGHT,
ARG_DETAILS,
ARG_STATS,
};
static struct option long_opts[] = {
{ "details", 0, 0, ARG_DETAILS },
{ "stats", 0, 0, ARG_STATS },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "name", 1, 0, 'n' },
{ "index", 1, 0, 'i' },
{ "family", 1, 0, ARG_FAMILY },
{ "mtu", 1, 0, ARG_MTU },
{ "txqlen", 1, 0, ARG_TXQLEN },
{ "weight", 1, 0, ARG_WEIGHT },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "hvn:i:", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case ARG_DETAILS: params.dp_type = NL_DUMP_DETAILS; break;
case ARG_STATS: params.dp_type = NL_DUMP_STATS; break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
case 'n': nl_cli_link_parse_name(link, optarg); break;
case 'i': nl_cli_link_parse_ifindex(link, optarg); break;
case ARG_FAMILY: nl_cli_link_parse_family(link, optarg); break;
case ARG_MTU: nl_cli_link_parse_mtu(link, optarg); break;
case ARG_TXQLEN: nl_cli_link_parse_txqlen(link, optarg); break;
case ARG_WEIGHT: nl_cli_link_parse_weight(link, optarg); break;
}
}
link_cache = nl_cli_link_alloc_cache_family(sock,
rtnl_link_get_family(link));
nl_cache_dump_filter(link_cache, ¶ms, OBJ_CAST(link));
return 0;
}
int nl_bridge::learn_source_mac(rtnl_link *br_link, packet *p) {
// we still assume vlan filtering bridge
assert(rtnl_link_get_family(br_link) == AF_BRIDGE);
VLOG(2) << __FUNCTION__ << ": pkt " << p << " on link " << OBJ_CAST(br_link);
rtnl_link_bridge_vlan *br_vlan = rtnl_link_bridge_get_port_vlan(br_link);
if (br_vlan == nullptr) {
LOG(ERROR) << __FUNCTION__
<< ": only the vlan filtering bridge is supported";
return -EINVAL;
}
// parse ether frame and check for vid
vlan_hdr *hdr = reinterpret_cast<basebox::vlan_hdr *>(p->data);
uint16_t vid = 0;
// XXX TODO maybe move this to the utils to have a std lib for parsing the
// ether frame
switch (ntohs(hdr->eth.h_proto)) {
case ETH_P_8021Q:
// vid
vid = ntohs(hdr->vlan);
break;
default:
// no vid, set vid to pvid
vid = br_vlan->pvid;
LOG(WARNING) << __FUNCTION__ << ": assuming untagged for ethertype "
<< std::showbase << std::hex << ntohs(hdr->eth.h_proto);
break;
}
// verify that the vid is in use here
if (!is_vid_set(vid, br_vlan->vlan_bitmap)) {
LOG(WARNING) << __FUNCTION__ << ": got packet on unconfigured port";
return -ENOTSUP;
}
// set nl neighbour to NL
std::unique_ptr<nl_addr, decltype(&nl_addr_put)> h_src(
nl_addr_build(AF_LLC, hdr->eth.h_source, sizeof(hdr->eth.h_source)),
nl_addr_put);
if (!h_src) {
LOG(ERROR) << __FUNCTION__ << ": failed to allocate src mac";
return -ENOMEM;
}
std::unique_ptr<rtnl_neigh, decltype(&rtnl_neigh_put)> n(rtnl_neigh_alloc(),
rtnl_neigh_put);
rtnl_neigh_set_ifindex(n.get(), rtnl_link_get_ifindex(br_link));
rtnl_neigh_set_master(n.get(), rtnl_link_get_master(br_link));
rtnl_neigh_set_family(n.get(), AF_BRIDGE);
rtnl_neigh_set_vlan(n.get(), vid);
rtnl_neigh_set_lladdr(n.get(), h_src.get());
rtnl_neigh_set_flags(n.get(), NTF_MASTER | NTF_EXT_LEARNED);
rtnl_neigh_set_state(n.get(), NUD_REACHABLE);
// check if entry already exists in cache
if (is_mac_in_l2_cache(n.get())) {
return 0;
}
nl_msg *msg = nullptr;
rtnl_neigh_build_add_request(n.get(),
NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL, &msg);
assert(msg);
// send the message and create new fdb entry
if (nl->send_nl_msg(msg) < 0) {
LOG(ERROR) << __FUNCTION__ << ": failed to send netlink message";
return -EINVAL;
}
// cache the entry
if (nl_cache_add(l2_cache.get(), OBJ_CAST(n.get())) < 0) {
LOG(ERROR) << __FUNCTION__ << ": failed to add entry to l2_cache "
<< OBJ_CAST(n.get());
return -EINVAL;
}
VLOG(2) << __FUNCTION__ << ": learned new source mac " << OBJ_CAST(n.get());
return 0;
}
