From d28e2bf3222ef4c58bebebd9c118818bfccedb8c Mon Sep 17 00:00:00 2001 From: laforge Date: Fri, 4 Nov 2005 13:50:25 +0000 Subject: implement ifindex to interface name filter plugin --- filter/Makefile.am | 2 +- filter/iftable.c | 259 ++++++++++++++++++++++++++++++++++++++++++ filter/iftable.h | 11 ++ filter/rtnl.c | 246 +++++++++++++++++++++++++++++++++++++++ filter/rtnl.h | 29 +++++ filter/ulogd_filter_IFINDEX.c | 82 ++++++++++++- 6 files changed, 626 insertions(+), 3 deletions(-) create mode 100644 filter/iftable.c create mode 100644 filter/iftable.h create mode 100644 filter/rtnl.c create mode 100644 filter/rtnl.h (limited to 'filter') diff --git a/filter/Makefile.am b/filter/Makefile.am index 6d0cd43..29daea1 100644 --- a/filter/Makefile.am +++ b/filter/Makefile.am @@ -4,5 +4,5 @@ INCLUDES = $(all_includes) -I$(top_srcdir)/include pkglib_LTLIBRARIES = ulogd_filter_IFINDEX.la -ulogd_filter_IFINDEX_la_SOURCES = ulogd_filter_IFINDEX.c +ulogd_filter_IFINDEX_la_SOURCES = ulogd_filter_IFINDEX.c rtnl.c iftable.c ulogd_filter_IFINDEX_la_LDFLAGS = -module diff --git a/filter/iftable.c b/filter/iftable.c new file mode 100644 index 0000000..f293ed4 --- /dev/null +++ b/filter/iftable.c @@ -0,0 +1,259 @@ +/* iftable - table of network interfaces + * + * (C) 2004 by Astaro AG, written by Harald Welte + * + * This software is Free Software and licensed under GNU GPLv2. + * + */ + +/* IFINDEX handling */ + +#include +#include +#include +#include +#include + +#include +#include + +#include + +#include "rtnl.h" + +#define iftb_log(x, ...) + +struct ifindex_map { + struct ifindex_map *next; + + u_int32_t index; + u_int32_t type; + u_int32_t alen; + u_int32_t flags; + char addr[8]; + char name[16]; +}; + +static struct ifindex_map *ifindex_map[16]; + +/* iftable_dump - Dump the interface table to a given file stream + * @outfd: file stream to which table should be dumped + */ +int iftable_dump(FILE *outfd) +{ + int i; + + for (i = 0; i < 16; i++) { + struct ifindex_map *im; + for (im = ifindex_map[i]; im; im = im->next) { + fprintf(outfd, "%u %s", im->index, im->name); + if (!(im->flags & IFF_UP)) + fputs(" DOWN", outfd); + fputc('\n', outfd); + } + } + fflush(outfd); + return 0; +} + +/* iftable_add - Add/Update an entry to/in the interface table + * @n: netlink message header of a RTM_NEWLINK message + * @arg: not used + * + * This function adds/updates an entry in the intrface table. + * Returns -1 on error, 1 on success. + */ +static int iftable_add(struct nlmsghdr *n, void *arg) +{ + unsigned int hash; + struct ifinfomsg *ifi_msg = NLMSG_DATA(n); + struct ifindex_map *im, **imp; + struct rtattr *cb[IFLA_MAX+1]; + + if (n->nlmsg_type != RTM_NEWLINK) + return -1; + + if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifi_msg))) { + iftb_log(LOG_ERROR, "short message (%u < %u)", + n->nlmsg_len, NLMSG_LENGTH(sizeof(ifi_msg))); + return -1; + } + + memset(&cb, 0, sizeof(cb)); + rtnl_parse_rtattr(cb, IFLA_MAX, IFLA_RTA(ifi_msg), IFLA_PAYLOAD(n)); + if (!cb[IFLA_IFNAME]) { + iftb_log(LOG_ERROR, "interface without name?"); + return -1; + } + + hash = ifi_msg->ifi_index&0xF; + for (imp = &ifindex_map[hash]; (im=*imp)!=NULL; imp = &im->next) { + if (im->index == ifi_msg->ifi_index) { + iftb_log(LOG_DEBUG, + "updating iftable (ifindex=%u)", im->index); + break; + } + } + + if (!im) { + im = malloc(sizeof(*im)); + if (!im) { + iftb_log(LOG_ERROR, + "ENOMEM while allocating ifindex_map"); + return 0; + } + im->next = *imp; + im->index = ifi_msg->ifi_index; + *imp = im; + iftb_log(LOG_DEBUG, "creating new iftable (ifindex=%u)", + im->index); + } + + im->type = ifi_msg->ifi_type; + im->flags = ifi_msg->ifi_flags; + if (cb[IFLA_ADDRESS]) { + unsigned int alen; + im->alen = alen = RTA_PAYLOAD(cb[IFLA_ADDRESS]); + if (alen > sizeof(im->addr)) + alen = sizeof(im->addr); + memcpy(im->addr, RTA_DATA(cb[IFLA_ADDRESS]), alen); + } else { + im->alen = 0; + memset(im->addr, 0, sizeof(im->addr)); + } + strcpy(im->name, RTA_DATA(cb[IFLA_IFNAME])); + return 1; +} + +/* iftable_del - Delete an entry from the interface table + * @n: netlink message header of a RTM_DELLINK nlmsg + * @arg: not used + * + * Delete an entry from the interface table. + * Returns -1 on error, 0 if no matching entry was found or 1 on success. + */ +static int iftable_del(struct nlmsghdr *n, void *arg) +{ + struct ifinfomsg *ifi_msg = NLMSG_DATA(n); + struct rtattr *cb[IFLA_MAX+1]; + struct ifindex_map *im; + + if (n->nlmsg_type != RTM_DELLINK) { + iftb_log(LOG_ERROR, + "called with wrong nlmsg_type %u", n->nlmsg_type); + return -1; + } + + if (n->nlmsg_len < NLMSG_LENGTH(sizeof(ifi_msg))) { + iftb_log(LOG_ERROR, "short message (%u < %u)", + n->nlmsg_len, NLMSG_LENGTH(sizeof(ifi_msg))); + return -1; + } + + memset(&cb, 0, sizeof(cb)); + rtnl_parse_rtattr(cb, IFLA_MAX, IFLA_RTA(ifi_msg), IFLA_PAYLOAD(n)); + + /* FIXME */ + + return 1; +} + +/* ifindex_2name - get the name for an ifindex + * @index: ifindex to be resolved + * + * Return value: character string containing name of interface + */ +char *ifindex_2name(unsigned int index) +{ + struct ifindex_map *im; + + if (index == 0) + return "*"; + for (im = ifindex_map[index&0xF]; im; im = im->next) + if (im->index == index) + return im->name; + + return NULL; +} + +/* iftable_up - Determine whether a given interface is UP + * @index: ifindex of interface + * + * Return value: -1 if interface unknown, 1 if interface up, 0 if not. + */ +int iftable_up(unsigned int index) +{ + struct ifindex_map *im; + + for (im = ifindex_map[index&0xF]; im; im = im->next) { + if (im->index == index) { + if (im->flags & IFF_UP) + return 1; + else + return 0; + } + } + return -1; +} + +static struct rtnl_handler handlers[] = { + { .nlmsg_type = RTM_NEWLINK, .handlefn = &iftable_add }, + { .nlmsg_type = RTM_DELLINK, .handlefn = &iftable_del }, +}; + +static int init_or_fini(int fini) +{ + int ret = 0; + + if (fini) + goto cleanup; + + if (rtnl_handler_register(&handlers[0]) < 0) { + ret = -1; + goto cleanup_none; + } + + if (rtnl_handler_register(&handlers[1]) < 0) { + ret = -1; + goto cleanup_0; + } + + if (rtnl_dump_type(RTM_GETLINK) < 0) { + ret = -1; + goto cleanup_1; + } + + return 0; + +#if 0 + if (rtnl_wilddump_requet(rtnl_fd, AF_UNSPEC, RTM_GETLINK) < 0) { + iftb_log(LOG_ERROR, "unable to send dump request"); + return -1; + } + +#endif + +cleanup: + +cleanup_1: + rtnl_handler_unregister(&handlers[1]); +cleanup_0: + rtnl_handler_unregister(&handlers[0]); +cleanup_none: + return ret; +} + +/* iftable_init - Initialize interface table + */ +int iftable_init(void) +{ + iftb_log(LOG_DEBUG, "%s", __FUNCTION__); + return init_or_fini(0); +} + +/* iftable_fini - Destructor of interface table + */ +void iftable_fini(void) +{ + init_or_fini(1); +} diff --git a/filter/iftable.h b/filter/iftable.h new file mode 100644 index 0000000..6725d67 --- /dev/null +++ b/filter/iftable.h @@ -0,0 +1,11 @@ +#ifndef _IFTABLE_H +#define _IFTABLE_H + +extern char *ifindex_2name(unsigned int index); +extern int iftable_up(unsigned int index); + +extern int iftable_init(void); +extern void iftable_fini(void); + +extern int iftable_dump(FILE *outfd); +#endif diff --git a/filter/rtnl.c b/filter/rtnl.c new file mode 100644 index 0000000..50c3d42 --- /dev/null +++ b/filter/rtnl.c @@ -0,0 +1,246 @@ +/* rtnl - rtnetlink utility functions + * + * (C) 2004 by Astaro AG, written by Harald Welte + * + * This software is free software and licensed under GNU GPLv2. + * + */ + +/* rtnetlink - routing table netlink interface */ + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +#include "rtnl.h" + +#define rtnl_log(x, ...) + +static int rtnl_fd; +static int rtnl_seq = 0; +static int rtnl_dump; +static struct sockaddr_nl rtnl_local; + +static struct rtnl_handler *handlers = NULL; + +static inline struct rtnl_handler *find_handler(u_int16_t type) +{ + struct rtnl_handler *h; + for (h = handlers; h; h = h->next) { + if (h->nlmsg_type == type) + return h; + } + return NULL; +} + +static int call_handler(u_int16_t type, struct nlmsghdr *hdr) +{ + struct rtnl_handler *h = find_handler(type); + + if (!h) { + rtnl_log(LOG_DEBUG, "no registered handler for type %u", + type); + return 0; + } + + return (h->handlefn)(hdr, h->arg); +} + +/* rtnl_handler_register - register handler for given nlmsg type + * @hdlr: handler structure + */ +int rtnl_handler_register(struct rtnl_handler *hdlr) +{ + rtnl_log(LOG_DEBUG, "registering handler for type %u", + hdlr->nlmsg_type); + hdlr->next = handlers; + handlers = hdlr; + return 1; +} + +/* rtnl_handler_unregister - unregister handler for given nlmst type + * @hdlr: handler structure + */ +int rtnl_handler_unregister(struct rtnl_handler *hdlr) +{ + struct rtnl_handler *h, *prev = NULL; + + rtnl_log(LOG_DEBUG, "unregistering handler for type %u", + hdlr->nlmsg_type); + + for (h = handlers; h; h = h->next) { + if (h == hdlr) { + if (prev) + prev->next = h->next; + else + handlers = h->next; + return 1; + } + prev = h; + } + return 0; +} + +/* rtnl_arse_rtattr - parse rtattr */ +int rtnl_parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len) +{ + while (RTA_OK(rta, len)) { + if (rta->rta_type <= max) + tb[rta->rta_type] = rta; + rta = RTA_NEXT(rta,len); + } + if (len) + return -1; + return 0; +} + +/* rtnl_dump_type - ask rtnetlink to dump a specific table + * @type: type of table to be dumped + */ +int rtnl_dump_type(unsigned int type) +{ + struct { + struct nlmsghdr nlh; + struct rtgenmsg g; + } req; + struct sockaddr_nl nladdr; + + memset(&nladdr, 0, sizeof(nladdr)); + memset(&req, 0, sizeof(req)); + nladdr.nl_family = AF_NETLINK; + + req.nlh.nlmsg_len = sizeof(req); + req.nlh.nlmsg_type = type; + req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST; + req.nlh.nlmsg_pid = 0; + req.nlh.nlmsg_seq = rtnl_dump = ++rtnl_seq; + req.g.rtgen_family = AF_INET; + + return sendto(rtnl_fd, (void*)&req, sizeof(req), 0, + (struct sockaddr*)&nladdr, sizeof(nladdr)); +} + +/* rtnl_receive - receive netlink packets from rtnetlink socket */ +int rtnl_receive() +{ + int status; + char buf[8192]; + struct sockaddr_nl nladdr; + struct iovec iov = { buf, sizeof(buf) }; + struct nlmsghdr *h; + + struct msghdr msg = { + (void *)&nladdr, sizeof(nladdr), + &iov, 1, + NULL, 0, + 0 + }; + + status = recvmsg(rtnl_fd, &msg, 0); + if (status < 0) { + if (errno == EINTR) + return 0; + rtnl_log(LOG_NOTICE, "OVERRUN on rtnl socket"); + return -1; + } + if (status == 0) { + rtnl_log(LOG_ERROR, "EOF on rtnl socket"); + return -1; + } + if (msg.msg_namelen != sizeof(nladdr)) { + rtnl_log(LOG_ERROR, "invalid address size"); + return -1; + } + + h = (struct nlmsghdr *) buf; + while (NLMSG_OK(h, status)) { +#if 0 + if (h->nlmsg_pid != rtnl_local.nl_pid || + h->nlmsg_seq != rtnl_dump) { + goto skip; + } +#endif + + if (h->nlmsg_type == NLMSG_DONE) { + rtnl_log(LOG_NOTICE, "NLMSG_DONE"); + return 0; + } + if (h->nlmsg_type == NLMSG_ERROR) { + struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(h); + if (h->nlmsg_len>=NLMSG_LENGTH(sizeof(struct nlmsgerr))) + errno = -err->error; + rtnl_log(LOG_ERROR, "NLMSG_ERROR, errnp=%d", + errno); + return -1; + } + + if (call_handler(h->nlmsg_type, h) == 0) + rtnl_log(LOG_NOTICE, "unhandled nlmsg_type %u", + h->nlmsg_type); + h = NLMSG_NEXT(h, status); + } + return 1; +} + +/* rtnl_init - constructor of rtnetlink module */ +int rtnl_init(void) +{ + int addr_len; + + rtnl_local.nl_pid = getpid(); + rtnl_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); + if (rtnl_fd < 0) { + rtnl_log(LOG_ERROR, "unable to create rtnetlink socket"); + return -1; + } + + memset(&rtnl_local, 0, sizeof(rtnl_local)); + rtnl_local.nl_family = AF_NETLINK; + rtnl_local.nl_groups = RTMGRP_IPV4_ROUTE|RTMGRP_IPV4_IFADDR|RTMGRP_LINK; + + if (bind(rtnl_fd, (struct sockaddr *)&rtnl_local, sizeof(rtnl_local)) < 0) { + rtnl_log(LOG_ERROR, "unable to bind rtnetlink socket"); + return -1; + } + + addr_len = sizeof(rtnl_local); + if (getsockname(rtnl_fd, (struct sockaddr *)&rtnl_local, + &addr_len) < 0) { + rtnl_log(LOG_ERROR, "cannot gescockname(rtnl_socket)"); + return -1; + } + + if (addr_len != sizeof(rtnl_local)) { + rtnl_log(LOG_ERROR, "invalid address size %u", addr_len); + return -1; + } + + if (rtnl_local.nl_family != AF_NETLINK) { + rtnl_log(LOG_ERROR, "invalid AF %u", rtnl_local.nl_family); + return -1; + } + + rtnl_seq = time(NULL); + + return rtnl_fd; +} + +/* rtnl_fini - destructor of rtnetlink module */ +void rtnl_fini(void) +{ + close(rtnl_fd); + return; +} + + + diff --git a/filter/rtnl.h b/filter/rtnl.h new file mode 100644 index 0000000..18f0963 --- /dev/null +++ b/filter/rtnl.h @@ -0,0 +1,29 @@ +#ifndef _RTNL_H +#define _RTNL_H + +#include +#include +#include + +struct rtnl_handler { + struct rtnl_handler *next; + + u_int16_t nlmsg_type; + int (*handlefn)(struct nlmsghdr *h, void *arg); + void *arg; +}; + + +/* api for handler plugins */ +int rtnl_handler_register(struct rtnl_handler *hdlr); +int rtnl_handler_unregister(struct rtnl_handler *hdlr); +int rtnl_parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len); +int rtnl_dump_type(unsigned int type); + +/* api for core program */ +int rtnl_init(void); +void rtnl_fini(void); +int rtnl_receive(); + + +#endif diff --git a/filter/ulogd_filter_IFINDEX.c b/filter/ulogd_filter_IFINDEX.c index 7fc39de..fbe8ccf 100644 --- a/filter/ulogd_filter_IFINDEX.c +++ b/filter/ulogd_filter_IFINDEX.c @@ -1,7 +1,33 @@ +/* ulogd_filter_IFINDEX.c, Version $Revision: 1500 $ + * + * ulogd interpreter plugin for ifindex to ifname conversion + * + * (C) 2005 by Harald Welte + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * $Id: ulogd_filter_IFINDEX.c 1500 2005-10-03 16:54:02Z laforge $ + * + */ + #include #include #include +#include "rtnl.h" +#include "iftable.h" + static struct ulogd_key ifindex_keys[] = { { .type = ULOGD_RET_STRING, @@ -29,23 +55,75 @@ static struct ulogd_key ifindex_inp[] = { static int interp_ifindex(struct ulogd_pluginstance *pi) { struct ulogd_key *ret = pi->output; + struct ulogd_key *inp = pi->input; - ret[0].u.value.ptr = "eth_in_FIXME"; + ret[0].u.value.ptr = ifindex_2name(inp[0].u.source->u.value.ui32); ret[0].flags |= ULOGD_RETF_VALID; - ret[1].u.value.ptr = "eth_out_FIXME"; + ret[1].u.value.ptr = ifindex_2name(inp[1].u.source->u.value.ui32); ret[1].flags |= ULOGD_RETF_VALID; return 0; } +/* we only need one global static cache of ifindex to ifname mappings, + * so all state is global (as opposed to per-instance local state in almost + * all other plugins */ +static struct ulogd_fd rtnl_fd = { .fd = -1 }; +static int rtnl_users; + +static int rtnl_read_cb(int fd, unsigned int what, void *param) +{ + if (!(what & ULOGD_FD_READ)) + return 0; + + rtnl_receive(); +} static int ifindex_start(struct ulogd_pluginstance *upi) { + int rc; + + /* if we're already initialized, inc usage count and exit */ + if (rtnl_fd.fd >= 0) { + rtnl_users++; + return 0; + } + + /* if we reach here, we need to initialize */ + rtnl_fd.fd = rtnl_init(); + if (rtnl_fd.fd < 0) + return rtnl_fd.fd; + + rc = iftable_init(); + if (rc < 0) + goto out_rtnl; + + rtnl_fd.when = ULOGD_FD_READ; + rtnl_fd.cb = &rtnl_read_cb; + rc = ulogd_register_fd(&rtnl_fd); + if (rc < 0) + goto out_iftable; + + rtnl_users++; return 0; + +out_iftable: + iftable_fini(); +out_rtnl: + rtnl_fini(); + rtnl_fd.fd = -1; + return rc; } static int ifindex_fini(struct ulogd_pluginstance *upi) { + if (--rtnl_users == 0) { + ulogd_unregister_fd(&rtnl_fd); + iftable_fini(); + rtnl_fini(); + rtnl_fd.fd = -1; + } + return 0; } -- cgit v1.2.3