Initial import

2 files changed, 540 insertions, 0 deletions

diff --git a/lib/fib_lookup/lookup.c b/lib/fib_lookup/lookup.c
new file mode 100644
index 0000000..2b0070d
--- /dev/null
+++ b/lib/fib_lookup/lookup.c
@@ -0,0 +1,353 @@
+/*
+ * lib/fib_lookup/lookup.c	FIB Lookup
+ *
+ *	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-2006 Thomas Graf <tgraf@suug.ch>
+ */
+
+/**
+ * @ingroup nlfam
+ * @defgroup fib_lookup FIB Lookup
+ * @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/route.h>
+#include <netlink/fib_lookup/request.h>
+#include <netlink/fib_lookup/lookup.h>
+
+/** @cond SKIP */
+static struct nl_cache_ops fib_lookup_ops;
+static struct nl_object_ops result_obj_ops;
+
+/* not exported so far */
+struct fib_result_nl {
+	uint32_t	fl_addr;   /* To be looked up*/ 
+	uint32_t	fl_fwmark; 
+	unsigned char	fl_tos;
+	unsigned char   fl_scope;
+	unsigned char   tb_id_in;
+
+	unsigned char   tb_id;      /* Results */
+	unsigned char	prefixlen;
+	unsigned char	nh_sel;
+	unsigned char	type;
+	unsigned char	scope;
+	int             err;      
+};
+/** @endcond */
+
+static void result_free_data(struct nl_object *obj)
+{
+	struct flnl_result *res = nl_object_priv(obj);
+
+	if (res && res->fr_req)
+		nl_object_put(OBJ_CAST(res->fr_req));
+}
+
+static int result_clone(struct nl_object *_dst, struct nl_object *_src)
+{
+	struct flnl_result *dst = nl_object_priv(_dst);
+	struct flnl_result *src = nl_object_priv(_src);
+
+	if (src->fr_req)
+		if (!(dst->fr_req = (struct flnl_request *)
+				nl_object_clone(OBJ_CAST(src->fr_req))))
+			return nl_get_errno();
+	
+	return 0;
+}
+
+static int result_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
+			     struct nlmsghdr *n, void *arg)
+{
+	struct flnl_result *res;
+	struct fib_result_nl *fr;
+	struct nl_parser_param *pp = arg;
+	struct nl_addr *addr;
+	int err = -EINVAL;
+
+	res = flnl_result_alloc();
+	if (!res)
+		goto errout;
+
+	res->ce_msgtype = n->nlmsg_type;
+
+	res->fr_req = flnl_request_alloc();
+	if (!res->fr_req)
+		goto errout;
+
+	fr = nlmsg_data(n);
+	addr = nl_addr_build(AF_INET, &fr->fl_addr, 4);
+	if (!addr)
+		goto errout;
+	err = flnl_request_set_addr(res->fr_req, addr);
+	nl_addr_put(addr);
+	if (err < 0)
+		goto errout;
+
+	flnl_request_set_fwmark(res->fr_req, fr->fl_fwmark);
+	flnl_request_set_tos(res->fr_req, fr->fl_tos);
+	flnl_request_set_scope(res->fr_req, fr->fl_scope);
+	flnl_request_set_table(res->fr_req, fr->tb_id_in);
+
+	res->fr_table_id = fr->tb_id;
+	res->fr_prefixlen = fr->prefixlen;
+	res->fr_nh_sel = fr->nh_sel;
+	res->fr_type = fr->type;
+	res->fr_scope = fr->scope;
+	res->fr_error = fr->err;
+
+	err = pp->pp_cb((struct nl_object *) res, pp);
+	if (err < 0)
+		goto errout;
+
+	/* REAL HACK, fib_lookup doesn't support ACK nor does it
+	 * send a DONE message, enforce end of message stream
+	 * after just the first message */
+	return NL_STOP;
+
+errout:
+	flnl_result_put(res);
+	return err;
+}
+
+static int result_dump_brief(struct nl_object *obj, struct nl_dump_params *p)
+{
+	struct flnl_result *res = (struct flnl_result *) obj;
+	char buf[128];
+	int line = 1;
+
+	dp_dump(p, "table %s prefixlen %u next-hop-selector %u\n",
+		rtnl_route_table2str(res->fr_table_id, buf, sizeof(buf)),
+		res->fr_prefixlen, res->fr_nh_sel);
+	dp_dump_line(p, line++, "type %s ",
+		     nl_rtntype2str(res->fr_type, buf, sizeof(buf)));
+	dp_dump(p, "scope %s error %s (%d)\n",
+		rtnl_scope2str(res->fr_scope, buf, sizeof(buf)),
+		strerror(-res->fr_error), res->fr_error);
+
+	return line;
+}
+
+static int result_dump_full(struct nl_object *obj, struct nl_dump_params *p)
+{
+	return result_dump_brief(obj, p);
+}
+
+static int result_compare(struct nl_object *_a, struct nl_object *_b,
+			uint32_t attrs, int flags)
+{
+	return 0;
+}
+
+/**
+ * @name Allocation/Freeing
+ * @{
+ */
+
+struct flnl_result *flnl_result_alloc(void)
+{
+	return (struct flnl_result *) nl_object_alloc(&result_obj_ops);
+}
+
+void flnl_result_put(struct flnl_result *res)
+{
+	nl_object_put((struct nl_object *) res);
+}
+
+/** @} */
+
+/**
+ * @name Cache Management
+ * @{
+ */
+
+/**
+ * Allocate lookup result cache.
+ *
+ * Allocates a new lookup result cache and initializes it properly.
+ *
+ * @note Free the memory after usage using nl_cache_destroy_and_free().
+ * @return Newly allocated cache or NULL if an error occured.
+ */
+struct nl_cache *flnl_result_alloc_cache(void)
+{
+	return nl_cache_alloc(&fib_lookup_ops);
+}
+
+/** @} */
+
+/**
+ * @name Lookup
+ * @{
+ */
+
+/**
+ * Builds a netlink request message to do a lookup
+ * @arg req		Requested match.
+ * @arg flags		additional netlink message flags
+ *
+ * Builds a new netlink message requesting a change of link attributes.
+ * The netlink message header isn't fully equipped with all relevant
+ * fields and must be sent out via nl_send_auto_complete() or
+ * supplemented as needed.
+ * \a old must point to a link currently configured in the kernel
+ * and \a tmpl must contain the attributes to be changed set via
+ * \c rtnl_link_set_* functions.
+ *
+ * @return New netlink message
+ * @note Not all attributes can be changed, see
+ *       \ref link_changeable "Changeable Attributes" for more details.
+ */
+struct nl_msg *flnl_lookup_build_request(struct flnl_request *req, int flags)
+{
+	struct nl_msg *msg;
+	struct nl_addr *addr;
+	uint64_t fwmark;
+	int tos, scope, table;
+	struct fib_result_nl fr = {0};
+
+	fwmark = flnl_request_get_fwmark(req);
+	tos = flnl_request_get_tos(req);
+	scope = flnl_request_get_scope(req);
+	table = flnl_request_get_table(req);
+
+	fr.fl_fwmark = fwmark != UINT_LEAST64_MAX ? fwmark : 0;
+	fr.fl_tos = tos >= 0 ? tos : 0;
+	fr.fl_scope = scope >= 0 ? scope : RT_SCOPE_UNIVERSE;
+	fr.tb_id_in = table >= 0 ? table : RT_TABLE_UNSPEC;
+
+	addr = flnl_request_get_addr(req);
+	if (!addr) {
+		nl_error(EINVAL, "Request must specify the address");
+		return NULL;
+	}
+
+	fr.fl_addr = *(uint32_t *) nl_addr_get_binary_addr(addr);
+
+	msg = nlmsg_alloc_simple(0, flags);
+	if (!msg)
+		goto errout;
+
+	if (nlmsg_append(msg, &fr, sizeof(fr), NLMSG_ALIGNTO) < 0)
+		goto errout;
+
+	return msg;
+
+errout:
+	nlmsg_free(msg);
+	return NULL;
+}
+
+/**
+ * Perform FIB Lookup
+ * @arg handle		Netlink handle.
+ * @arg req		Lookup request object.
+ * @arg cache		Cache for result.
+ *
+ * Builds a netlink message to request a FIB lookup, waits for the
+ * reply and adds the result to the specified cache.
+ *
+ * @return 0 on success or a negative error code.
+ */
+int flnl_lookup(struct nl_handle *handle, struct flnl_request *req,
+		struct nl_cache *cache)
+{
+	struct nl_msg *msg;
+	int err;
+
+	msg = flnl_lookup_build_request(req, 0);
+	if (!msg)
+		return nl_errno(ENOMEM);
+
+	err = nl_send_auto_complete(handle, msg);
+	nlmsg_free(msg);
+	if (err < 0)
+		return err;
+
+	return nl_cache_pickup(handle, cache);
+}
+
+/** @} */
+
+/**
+ * @name Attribute Access
+ * @{
+ */
+
+int flnl_result_get_table_id(struct flnl_result *res)
+{
+	return res->fr_table_id;
+}
+
+int flnl_result_get_prefixlen(struct flnl_result *res)
+{
+	return res->fr_prefixlen;
+}
+
+int flnl_result_get_nexthop_sel(struct flnl_result *res)
+{
+	return res->fr_nh_sel;
+}
+
+int flnl_result_get_type(struct flnl_result *res)
+{
+	return res->fr_type;
+}
+
+int flnl_result_get_scope(struct flnl_result *res)
+{
+	return res->fr_scope;
+}
+
+int flnl_result_get_error(struct flnl_result *res)
+{
+	return res->fr_error;
+}
+
+/** @} */
+
+static struct nl_object_ops result_obj_ops = {
+	.oo_name		= "fib_lookup/result",
+	.oo_size		= sizeof(struct flnl_result),
+	.oo_free_data		= result_free_data,
+	.oo_clone		= result_clone,
+	.oo_dump[NL_DUMP_BRIEF]	= result_dump_brief,
+	.oo_dump[NL_DUMP_FULL]	= result_dump_full,
+	.oo_compare		= result_compare,
+};
+
+static struct nl_cache_ops fib_lookup_ops = {
+	.co_name		= "fib_lookup/fib_lookup",
+	.co_hdrsize		= sizeof(struct fib_result_nl),
+	.co_msgtypes		= {
+					{ 0, NL_ACT_UNSPEC, "any" },
+					END_OF_MSGTYPES_LIST,
+				  },
+	.co_protocol		= NETLINK_FIB_LOOKUP,
+	.co_msg_parser		= result_msg_parser,
+	.co_obj_ops		= &result_obj_ops,
+};
+
+static void __init fib_lookup_init(void)
+{
+	nl_cache_mngt_register(&fib_lookup_ops);
+}
+
+static void __exit fib_lookup_exit(void)
+{
+	nl_cache_mngt_unregister(&fib_lookup_ops);
+}
+
+/** @} */
diff --git a/lib/fib_lookup/request.c b/lib/fib_lookup/request.c
new file mode 100644
index 0000000..8b00224
--- /dev/null
+++ b/lib/fib_lookup/request.c
@@ -0,0 +1,187 @@
+/*
+ * lib/fib_lookup/request.c	FIB Lookup Request
+ *
+ *	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-2006 Thomas Graf <tgraf@suug.ch>
+ */
+
+/**
+ * @ingroup fib_lookup
+ * @defgroup flreq Request
+ * @brief
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/attr.h>
+#include <netlink/utils.h>
+#include <netlink/object.h>
+#include <netlink/fib_lookup/request.h>
+
+static struct nl_object_ops request_obj_ops;
+
+/** @cond SKIP */
+#define REQUEST_ATTR_ADDR	0x01
+#define REQUEST_ATTR_FWMARK	0x02
+#define REQUEST_ATTR_TOS	0x04
+#define REQUEST_ATTR_SCOPE	0x08
+#define REQUEST_ATTR_TABLE	0x10
+/** @endcond */
+
+static void request_free_data(struct nl_object *obj)
+{
+	struct flnl_request *req = REQUEST_CAST(obj);
+
+	if (req)
+		nl_addr_put(req->lr_addr);
+}
+
+static int request_clone(struct nl_object *_dst, struct nl_object *_src)
+{
+	struct flnl_request *dst = nl_object_priv(_dst);
+	struct flnl_request *src = nl_object_priv(_src);
+
+	if (src->lr_addr)
+		if (!(dst->lr_addr = nl_addr_clone(src->lr_addr)))
+			goto errout;
+
+	return 0;
+errout:
+	return nl_get_errno();
+}
+
+static int request_compare(struct nl_object *_a, struct nl_object *_b,
+			   uint32_t attrs, int flags)
+{
+	struct flnl_request *a = (struct flnl_request *) _a;
+	struct flnl_request *b = (struct flnl_request *) _b;
+	int diff = 0;
+
+#define REQ_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, REQUEST_ATTR_##ATTR, a, b, EXPR)
+
+	diff |= REQ_DIFF(FWMARK,	a->lr_fwmark != b->lr_fwmark);
+	diff |= REQ_DIFF(TOS,		a->lr_tos != b->lr_tos);
+	diff |= REQ_DIFF(SCOPE,		a->lr_scope != b->lr_scope);
+	diff |= REQ_DIFF(TABLE,		a->lr_table != b->lr_table);
+	diff |= REQ_DIFF(ADDR,		nl_addr_cmp(a->lr_addr, b->lr_addr));
+
+#undef REQ_DIFF
+
+	return diff;
+}
+
+
+/**
+ * @name Lookup Request Creation/Deletion
+ * @{
+ */
+
+struct flnl_request *flnl_request_alloc(void)
+{
+	return REQUEST_CAST(nl_object_alloc(&request_obj_ops));
+}
+
+/** @} */
+
+/**
+ * @name Attributes
+ * @{
+ */
+
+void flnl_request_set_fwmark(struct flnl_request *req, uint64_t fwmark)
+{
+	req->lr_fwmark = fwmark;
+	req->ce_mask |= REQUEST_ATTR_FWMARK;
+}
+
+uint64_t flnl_request_get_fwmark(struct flnl_request *req)
+{
+	if (req->ce_mask & REQUEST_ATTR_FWMARK)
+		return req->lr_fwmark;
+	else
+		return UINT_LEAST64_MAX;
+}
+
+void flnl_request_set_tos(struct flnl_request *req, int tos)
+{
+	req->lr_tos = tos;
+	req->ce_mask |= REQUEST_ATTR_TOS;
+}
+
+int flnl_request_get_tos(struct flnl_request *req)
+{
+	if (req->ce_mask & REQUEST_ATTR_TOS)
+		return req->lr_tos;
+	else
+		return -1;
+}
+
+void flnl_request_set_scope(struct flnl_request *req, int scope)
+{
+	req->lr_scope = scope;
+	req->ce_mask |= REQUEST_ATTR_SCOPE;
+}
+
+int flnl_request_get_scope(struct flnl_request *req)
+{
+	if (req->ce_mask & REQUEST_ATTR_SCOPE)
+		return req->lr_scope;
+	else
+		return -1;
+}
+
+void flnl_request_set_table(struct flnl_request *req, int table)
+{
+	req->lr_table = table;
+	req->ce_mask |= REQUEST_ATTR_TABLE;
+}
+
+int flnl_request_get_table(struct flnl_request *req)
+{
+	if (req->ce_mask & REQUEST_ATTR_TABLE)
+		return req->lr_table;
+	else
+		return -1;
+}
+
+int flnl_request_set_addr(struct flnl_request *req, struct nl_addr *addr)
+{
+	if (addr->a_family != AF_INET)
+		return nl_error(EINVAL, "Address must be an IPv4 address");
+
+	if (req->lr_addr)
+		nl_addr_put(req->lr_addr);
+
+	nl_addr_get(addr);
+	req->lr_addr = addr;
+
+	req->ce_mask |= REQUEST_ATTR_ADDR;
+
+	return 0;
+}
+
+struct nl_addr *flnl_request_get_addr(struct flnl_request *req)
+{
+	if (req->ce_mask & REQUEST_ATTR_ADDR)
+		return req->lr_addr;
+	else
+		return NULL;
+}
+
+/** @} */
+
+static struct nl_object_ops request_obj_ops = {
+	.oo_name		= "fib_lookup/request",
+	.oo_size		= sizeof(struct flnl_request),
+	.oo_free_data		= request_free_data,
+	.oo_clone		= request_clone,
+	.oo_compare		= request_compare,
+	.oo_id_attrs		= ~0,
+};
+
+/** @} */