backport libnl-tiny, wprobe, madwifi
authorFelix Fietkau <nbd@openwrt.org>
Fri, 8 May 2009 22:48:17 +0000 (22:48 +0000)
committerFelix Fietkau <nbd@openwrt.org>
Fri, 8 May 2009 22:48:17 +0000 (22:48 +0000)
SVN-Revision: 15719

74 files changed:
package/libnl-tiny/Makefile [new file with mode: 0644]
package/libnl-tiny/files/libnl-tiny.pc [new file with mode: 0644]
package/libnl-tiny/src/Makefile [new file with mode: 0644]
package/libnl-tiny/src/attr.c [new file with mode: 0644]
package/libnl-tiny/src/cache.c [new file with mode: 0644]
package/libnl-tiny/src/cache_mngt.c [new file with mode: 0644]
package/libnl-tiny/src/error.c [new file with mode: 0644]
package/libnl-tiny/src/genl.c [new file with mode: 0644]
package/libnl-tiny/src/genl_ctrl.c [new file with mode: 0644]
package/libnl-tiny/src/genl_family.c [new file with mode: 0644]
package/libnl-tiny/src/genl_mngt.c [new file with mode: 0644]
package/libnl-tiny/src/handlers.c [new file with mode: 0644]
package/libnl-tiny/src/include/linux/genetlink.h [new file with mode: 0644]
package/libnl-tiny/src/include/linux/if.h [new file with mode: 0644]
package/libnl-tiny/src/include/linux/if_addr.h [new file with mode: 0644]
package/libnl-tiny/src/include/linux/netlink.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink-generic.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink-local.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink-types.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/addr.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/attr.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/cache-api.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/cache.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/data.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/errno.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/genl/ctrl.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/genl/family.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/genl/genl.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/genl/mngt.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/handlers.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/list.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/msg.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/netlink-compat.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/netlink-kernel.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/netlink.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/object-api.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/object.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/socket.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/types.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/utils.h [new file with mode: 0644]
package/libnl-tiny/src/include/netlink/version.h [new file with mode: 0644]
package/libnl-tiny/src/msg.c [new file with mode: 0644]
package/libnl-tiny/src/nl.c [new file with mode: 0644]
package/libnl-tiny/src/object.c [new file with mode: 0644]
package/libnl-tiny/src/socket.c [new file with mode: 0644]
package/libnl/Makefile
package/madwifi/Config.in
package/madwifi/Makefile
package/madwifi/files/lib/wifi/madwifi.sh
package/madwifi/patches-upstream/104-autocreate_none.patch [deleted file]
package/madwifi/patches-upstream/111-minstrel_crash.patch [deleted file]
package/madwifi/patches/123-ccmp_checks.patch
package/madwifi/patches/351-scanlist.patch
package/madwifi/patches/389-autochannel.patch
package/madwifi/patches/411-autochannel_multi.patch
package/madwifi/patches/416-wprobe.patch [new file with mode: 0644]
package/madwifi/patches/418-turbo.patch [deleted file]
package/madwifi/patches/420-diversity_fix.patch
package/madwifi/patches/421-channel_handling.patch [new file with mode: 0644]
package/madwifi/patches/422-confchange_reset.patch [new file with mode: 0644]
package/wprobe/Makefile [new file with mode: 0644]
package/wprobe/files/wprobe.init [new file with mode: 0755]
package/wprobe/src/exporter/Makefile [new file with mode: 0644]
package/wprobe/src/exporter/wprobe-export.c [new file with mode: 0644]
package/wprobe/src/exporter/wprobe-export.h [new file with mode: 0644]
package/wprobe/src/kernel/Makefile [new file with mode: 0644]
package/wprobe/src/kernel/linux/wprobe.h [new file with mode: 0644]
package/wprobe/src/kernel/wprobe-core.c [new file with mode: 0644]
package/wprobe/src/kernel/wprobe-dummy.c [new file with mode: 0644]
package/wprobe/src/user/Makefile [new file with mode: 0644]
package/wprobe/src/user/list.h [new file with mode: 0644]
package/wprobe/src/user/wprobe-info.c [new file with mode: 0644]
package/wprobe/src/user/wprobe.c [new file with mode: 0644]
package/wprobe/src/user/wprobe.h [new file with mode: 0644]

diff --git a/package/libnl-tiny/Makefile b/package/libnl-tiny/Makefile
new file mode 100644 (file)
index 0000000..4b02ef1
--- /dev/null
@@ -0,0 +1,52 @@
+#
+# Copyright (C) 2006-2009 OpenWrt.org
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=libnl-tiny
+PKG_VERSION:=0.1
+PKG_RELEASE:=1
+
+include $(INCLUDE_DIR)/package.mk
+
+define Package/libnl-tiny
+  SECTION:=libs
+  CATEGORY:=Libraries
+  TITLE:=netlink socket library
+endef
+
+define Package/libnl-tiny/description
+ This package contains a stripped down version of libnl
+endef
+
+define Build/Prepare
+       mkdir -p $(PKG_BUILD_DIR)
+       $(CP) ./src/* $(PKG_BUILD_DIR)/
+endef
+
+TARGET_CFLAGS += $(FPIC)
+
+define Build/Compile
+       $(MAKE) -C $(PKG_BUILD_DIR) \
+               $(TARGET_CONFIGURE_OPTS) \
+               CFLAGS="$(TARGET_CFLAGS)" \
+               all
+endef
+
+define Build/InstallDev
+       $(INSTALL_DIR) $(1)/usr/lib/pkgconfig $(1)/usr/include/libnl-tiny
+       $(CP) $(PKG_BUILD_DIR)/include/* $(1)/usr/include/libnl-tiny
+       $(CP) $(PKG_BUILD_DIR)/libnl-tiny.so $(1)/usr/lib/
+       $(CP) ./files/libnl-tiny.pc $(1)/usr/lib/pkgconfig
+endef
+
+define Package/libnl-tiny/install
+       $(INSTALL_DIR) $(1)/usr/lib
+       $(CP) $(PKG_BUILD_DIR)/libnl-tiny.so $(1)/usr/lib/
+endef
+
+$(eval $(call BuildPackage,libnl-tiny))
diff --git a/package/libnl-tiny/files/libnl-tiny.pc b/package/libnl-tiny/files/libnl-tiny.pc
new file mode 100644 (file)
index 0000000..8c1bf6f
--- /dev/null
@@ -0,0 +1,10 @@
+prefix=/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include/libnl-tiny
+
+Name: libnl-tiny
+Description: Convenience library for netlink sockets
+Version: 2.0
+Libs: -L${libdir} -lnl-tiny
+Cflags:
diff --git a/package/libnl-tiny/src/Makefile b/package/libnl-tiny/src/Makefile
new file mode 100644 (file)
index 0000000..f684155
--- /dev/null
@@ -0,0 +1,17 @@
+CC=gcc
+WFLAGS=-Wall
+CFLAGS=-O2
+INCLUDES=-Iinclude
+
+LIBNAME=libnl-tiny.so
+
+all: $(LIBNAME)
+
+%.o: %.c
+       $(CC) $(WFLAGS) -c -o $@ $(INCLUDES) $(CFLAGS) $<
+
+LIBNL_OBJ=nl.o handlers.o msg.o attr.o cache.o cache_mngt.o object.o socket.o error.o
+GENL_OBJ=genl.o genl_family.o genl_ctrl.o genl_mngt.o
+
+$(LIBNAME): $(LIBNL_OBJ) $(GENL_OBJ)
+       $(CC) -shared -o $@ $^
diff --git a/package/libnl-tiny/src/attr.c b/package/libnl-tiny/src/attr.c
new file mode 100644 (file)
index 0000000..e0f5061
--- /dev/null
@@ -0,0 +1,668 @@
+/*
+ * lib/attr.c          Netlink Attributes
+ *
+ *     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>
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/utils.h>
+#include <netlink/addr.h>
+#include <netlink/attr.h>
+#include <netlink/msg.h>
+#include <linux/socket.h>
+
+/**
+ * @ingroup msg
+ * @defgroup attr Attributes
+ * Netlink Attributes Construction/Parsing Interface
+ *
+ * \section attr_sec Netlink Attributes
+ * Netlink attributes allow for data chunks of arbitary length to be
+ * attached to a netlink message. Each attribute is encoded with a
+ * type and length field, both 16 bits, stored in the attribute header
+ * preceding the attribute data. The main advantage of using attributes
+ * over packing everything into the family header is that the interface
+ * stays extendable as new attributes can supersede old attributes while
+ * remaining backwards compatible. Also attributes can be defined optional
+ * thus avoiding the transmission of unnecessary empty data blocks.
+ * Special nested attributes allow for more complex data structures to
+ * be transmitted, e.g. trees, lists, etc.
+ *
+ * While not required, netlink attributes typically follow the family
+ * header of a netlink message and must be properly aligned to NLA_ALIGNTO:
+ * @code
+ *   +----------------+- - -+---------------+- - -+------------+- - -+
+ *   | Netlink Header | Pad | Family Header | Pad | Attributes | Pad |
+ *   +----------------+- - -+---------------+- - -+------------+- - -+
+ * @endcode
+ *
+ * The actual attributes are chained together each separately aligned to
+ * NLA_ALIGNTO. The position of an attribute is defined based on the
+ * length field of the preceding attributes:
+ * @code
+ *   +-------------+- - -+-------------+- - -+------
+ *   | Attribute 1 | Pad | Attribute 2 | Pad | ...
+ *   +-------------+- - -+-------------+- - -+------
+ *   nla_next(attr1)------^
+ * @endcode
+ *
+ * The attribute itself consists of the attribute header followed by
+ * the actual payload also aligned to NLA_ALIGNTO. The function nla_data()
+ * returns a pointer to the start of the payload while nla_len() returns
+ * the length of the payload in bytes.
+ *
+ * \b Note: Be aware, NLA_ALIGNTO equals to 4 bytes, therefore it is not
+ * safe to dereference any 64 bit data types directly.
+ *
+ * @code
+ *    <----------- nla_total_size(payload) ----------->
+ *    <-------- nla_attr_size(payload) --------->
+ *   +------------------+- - -+- - - - - - - - - +- - -+
+ *   | Attribute Header | Pad |     Payload      | Pad |
+ *   +------------------+- - -+- - - - - - - - - +- - -+
+ *   nla_data(nla)-------------^
+ *                             <- nla_len(nla) ->
+ * @endcode
+ *
+ * @subsection attr_datatypes Attribute Data Types
+ * A number of basic data types are supported to simplify access and
+ * validation of netlink attributes. This data type information is
+ * not encoded in the attribute, both the kernel and userspace part
+ * are required to share this information on their own.
+ *
+ * One of the major advantages of these basic types is the automatic
+ * validation of each attribute based on an attribute policy. The
+ * validation covers most of the checks required to safely use
+ * attributes and thus keeps the individual sanity check to a minimum.
+ *
+ * Never access attribute payload without ensuring basic validation
+ * first, attributes may:
+ * - not be present even though required
+ * - contain less actual payload than expected
+ * - fake a attribute length which exceeds the end of the message
+ * - contain unterminated character strings
+ *
+ * Policies are defined as array of the struct nla_policy. The array is
+ * indexed with the attribute type, therefore the array must be sized
+ * accordingly.
+ * @code
+ * static struct nla_policy my_policy[ATTR_MAX+1] = {
+ *     [ATTR_FOO] = { .type = ..., .minlen = ..., .maxlen = ... },
+ * };
+ *
+ * err = nla_validate(attrs, attrlen, ATTR_MAX, &my_policy);
+ * @endcode
+ *
+ * Some basic validations are performed on every attribute, regardless of type.
+ * - If the attribute type exceeds the maximum attribute type specified or
+ *   the attribute type is lesser-or-equal than zero, the attribute will
+ *   be silently ignored.
+ * - If the payload length falls below the \a minlen value the attribute
+ *   will be rejected.
+ * - If \a maxlen is non-zero and the payload length exceeds the \a maxlen
+ *   value the attribute will be rejected.
+ *
+ *
+ * @par Unspecific Attribute (NLA_UNSPEC)
+ * This is the standard type if no type is specified. It is used for
+ * binary data of arbitary length. Typically this attribute carries
+ * a binary structure or a stream of bytes.
+ * @par
+ * @code
+ * // In this example, we will assume a binary structure requires to
+ * // be transmitted. The definition of the structure will typically
+ * // go into a header file available to both the kernel and userspace
+ * // side.
+ * //
+ * // Note: Be careful when putting 64 bit data types into a structure.
+ * // The attribute payload is only aligned to 4 bytes, dereferencing
+ * // the member may fail.
+ * struct my_struct {
+ *     int a;
+ *     int b;
+ * };
+ *
+ * // The validation function will not enforce an exact length match to
+ * // allow structures to grow as required. Note: While it is allowed
+ * // to add members to the end of the structure, changing the order or
+ * // inserting members in the middle of the structure will break your
+ * // binary interface.
+ * static struct nla_policy my_policy[ATTR_MAX+1] = {
+ *     [ATTR_MY_STRICT] = { .type = NLA_UNSPEC,
+ *                          .minlen = sizeof(struct my_struct) },
+ *
+ * // The binary structure is appened to the message using nla_put()
+ * struct my_struct foo = { .a = 1, .b = 2 };
+ * nla_put(msg, ATTR_MY_STRUCT, sizeof(foo), &foo);
+ *
+ * // On the receiving side, a pointer to the structure pointing inside
+ * // the message payload is returned by nla_get().
+ * if (attrs[ATTR_MY_STRUCT])
+ *     struct my_struct *foo = nla_get(attrs[ATTR_MY_STRUCT]);
+ * @endcode
+ *
+ * @par Integers (NLA_U8, NLA_U16, NLA_U32, NLA_U64)
+ * Integers come in different sizes from 8 bit to 64 bit. However, since the
+ * payload length is aligned to 4 bytes, integers smaller than 32 bit are
+ * only useful to enforce the maximum range of values.
+ * @par
+ * \b Note: There is no difference made between signed and unsigned integers.
+ * The validation only enforces the minimal payload length required to store
+ * an integer of specified type.
+ * @par
+ * @code
+ * // Even though possible, it does not make sense to specify .minlen or
+ * // .maxlen for integer types. The data types implies the corresponding
+ * // minimal payload length.
+ * static struct nla_policy my_policy[ATTR_MAX+1] = {
+ *     [ATTR_FOO] = { .type = NLA_U32 },
+ *
+ * // Numeric values can be appended directly using the respective
+ * // nla_put_uxxx() function
+ * nla_put_u32(msg, ATTR_FOO, 123);
+ *
+ * // Same for the receiving side.
+ * if (attrs[ATTR_FOO])
+ *     uint32_t foo = nla_get_u32(attrs[ATTR_FOO]);
+ * @endcode
+ *
+ * @par Character string (NLA_STRING)
+ * This data type represents a NUL terminated character string of variable
+ * length. For binary data streams the type NLA_UNSPEC is recommended.
+ * @par
+ * @code
+ * // Enforce a NUL terminated character string of at most 4 characters
+ * // including the NUL termination.
+ * static struct nla_policy my_policy[ATTR_MAX+1] = {
+ *     [ATTR_BAR] = { .type = NLA_STRING, maxlen = 4 },
+ *
+ * // nla_put_string() creates a string attribute of the necessary length
+ * // and appends it to the message including the NUL termination.
+ * nla_put_string(msg, ATTR_BAR, "some text");
+ *
+ * // It is safe to use the returned character string directly if the
+ * // attribute has been validated as the validation enforces the proper
+ * // termination of the string.
+ * if (attrs[ATTR_BAR])
+ *     char *text = nla_get_string(attrs[ATTR_BAR]);
+ * @endcode
+ *
+ * @par Flag (NLA_FLAG)
+ * This attribute type may be used to indicate the presence of a flag. The
+ * attribute is only valid if the payload length is zero. The presence of
+ * the attribute header indicates the presence of the flag.
+ * @par
+ * @code
+ * // This attribute type is special as .minlen and .maxlen have no effect.
+ * static struct nla_policy my_policy[ATTR_MAX+1] = {
+ *     [ATTR_FLAG] = { .type = NLA_FLAG },
+ *
+ * // nla_put_flag() appends a zero sized attribute to the message.
+ * nla_put_flag(msg, ATTR_FLAG);
+ *
+ * // There is no need for a receival function, the presence is the value.
+ * if (attrs[ATTR_FLAG])
+ *     // flag is present
+ * @endcode
+ *
+ * @par Micro Seconds (NLA_MSECS)
+ *
+ * @par Nested Attribute (NLA_NESTED)
+ * Attributes can be nested and put into a container to create groups, lists
+ * or to construct trees of attributes. Nested attributes are often used to
+ * pass attributes to a subsystem where the top layer has no knowledge of the
+ * configuration possibilities of each subsystem.
+ * @par
+ * \b Note: When validating the attributes using nlmsg_validate() or
+ * nlmsg_parse() it will only affect the top level attributes. Each
+ * level of nested attributes must be validated seperately using
+ * nla_parse_nested() or nla_validate().
+ * @par
+ * @code
+ * // The minimal length policy may be used to enforce the presence of at
+ * // least one attribute.
+ * static struct nla_policy my_policy[ATTR_MAX+1] = {
+ *     [ATTR_OPTS] = { .type = NLA_NESTED, minlen = NLA_HDRLEN },
+ *
+ * // Nested attributes are constructed by enclosing the attributes
+ * // to be nested with calls to nla_nest_start() respetively nla_nest_end().
+ * struct nlattr *opts = nla_nest_start(msg, ATTR_OPTS);
+ * nla_put_u32(msg, ATTR_FOO, 123);
+ * nla_put_string(msg, ATTR_BAR, "some text");
+ * nla_nest_end(msg, opts);
+ *
+ * // Various methods exist to parse nested attributes, the easiest being
+ * // nla_parse_nested() which also allows validation in the same step.
+ * if (attrs[ATTR_OPTS]) {
+ *     struct nlattr *nested[ATTR_MAX+1];
+ *
+ *     nla_parse_nested(nested, ATTR_MAX, attrs[ATTR_OPTS], &policy);
+ *
+ *     if (nested[ATTR_FOO])
+ *         uint32_t foo = nla_get_u32(nested[ATTR_FOO]);
+ * }
+ * @endcode
+ *
+ * @subsection attr_exceptions Exception Based Attribute Construction
+ * Often a large number of attributes are added to a message in a single
+ * function. In order to simplify error handling, a second set of
+ * construction functions exist which jump to a error label when they
+ * fail instead of returning an error code. This second set consists
+ * of macros which are named after their error code based counterpart
+ * except that the name is written all uppercase.
+ *
+ * All of the macros jump to the target \c nla_put_failure if they fail.
+ * @code
+ * void my_func(struct nl_msg *msg)
+ * {
+ *     NLA_PUT_U32(msg, ATTR_FOO, 10);
+ *     NLA_PUT_STRING(msg, ATTR_BAR, "bar");
+ *
+ *     return 0;
+ *
+ * nla_put_failure:
+ *     return -NLE_NOMEM;
+ * }
+ * @endcode
+ *
+ * @subsection attr_examples Examples
+ * @par Example 1.1 Constructing a netlink message with attributes.
+ * @code
+ * struct nl_msg *build_msg(int ifindex, struct nl_addr *lladdr, int mtu)
+ * {
+ *     struct nl_msg *msg;
+ *     struct nlattr *info, *vlan;
+ *     struct ifinfomsg ifi = {
+ *         .ifi_family = AF_INET,
+ *         .ifi_index = ifindex,
+ *     };
+ *
+ *     // Allocate a new netlink message, type=RTM_SETLINK, flags=NLM_F_ECHO
+ *     if (!(msg = nlmsg_alloc_simple(RTM_SETLINK, NLM_F_ECHO)))
+ *         return NULL;
+ *
+ *     // Append the family specific header (struct ifinfomsg)
+ *     if (nlmsg_append(msg, &ifi, sizeof(ifi), NLMSG_ALIGNTO) < 0)
+ *         goto nla_put_failure
+ *
+ *     // Append a 32 bit integer attribute to carry the MTU
+ *     NLA_PUT_U32(msg, IFLA_MTU, mtu);
+ *
+ *     // Append a unspecific attribute to carry the link layer address
+ *     NLA_PUT_ADDR(msg, IFLA_ADDRESS, lladdr);
+ *
+ *     // Append a container for nested attributes to carry link information
+ *     if (!(info = nla_nest_start(msg, IFLA_LINKINFO)))
+ *         goto nla_put_failure;
+ *
+ *     // Put a string attribute into the container
+ *     NLA_PUT_STRING(msg, IFLA_INFO_KIND, "vlan");
+ *
+ *     // Append another container inside the open container to carry
+ *     // vlan specific attributes
+ *     if (!(vlan = nla_nest_start(msg, IFLA_INFO_DATA)))
+ *         goto nla_put_failure;
+ *
+ *     // add vlan specific info attributes here...
+ *
+ *     // Finish nesting the vlan attributes and close the second container.
+ *     nla_nest_end(msg, vlan);
+ *
+ *     // Finish nesting the link info attribute and close the first container.
+ *     nla_nest_end(msg, info);
+ *
+ *     return msg;
+ *
+ * // If any of the construction macros fails, we end up here.
+ * nla_put_failure:
+ *     nlmsg_free(msg);
+ *     return NULL;
+ * }
+ * @endcode
+ *
+ * @par Example 2.1 Parsing a netlink message with attributes.
+ * @code
+ * int parse_message(struct nl_msg *msg)
+ * {
+ *     // The policy defines two attributes: a 32 bit integer and a container
+ *     // for nested attributes.
+ *     struct nla_policy attr_policy[ATTR_MAX+1] = {
+ *         [ATTR_FOO] = { .type = NLA_U32 },
+ *         [ATTR_BAR] = { .type = NLA_NESTED },
+ *     };
+ *     struct nlattr *attrs[ATTR_MAX+1];
+ *     int err;
+ *
+ *     // The nlmsg_parse() function will make sure that the message contains
+ *     // enough payload to hold the header (struct my_hdr), validates any
+ *     // attributes attached to the messages and stores a pointer to each
+ *     // attribute in the attrs[] array accessable by attribute type.
+ *     if ((err = nlmsg_parse(nlmsg_hdr(msg), sizeof(struct my_hdr), attrs,
+ *                            ATTR_MAX, attr_policy)) < 0)
+ *         goto errout;
+ *
+ *     if (attrs[ATTR_FOO]) {
+ *         // It is safe to directly access the attribute payload without
+ *         // any further checks since nlmsg_parse() enforced the policy.
+ *         uint32_t foo = nla_get_u32(attrs[ATTR_FOO]);
+ *     }
+ *
+ *     if (attrs[ATTR_BAR]) {
+ *         struct nlattr *nested[NESTED_MAX+1];
+ *
+ *         // Attributes nested in a container can be parsed the same way
+ *         // as top level attributes.
+ *         if ((err = nla_parse_nested(nested, NESTED_MAX, attrs[ATTR_BAR],
+ *                                     nested_policy)) < 0)
+ *             goto errout;
+ *
+ *         // Process nested attributes here.
+ *     }
+ *
+ *     err = 0;
+ * errout:
+ *     return err;
+ * }
+ * @endcode
+ *
+ * @{
+ */
+
+/**
+ * @name Attribute Size Calculation
+ * @{
+ */
+
+/** @} */
+
+/**
+ * @name Parsing Attributes
+ * @{
+ */
+
+/**
+ * Check if the attribute header and payload can be accessed safely.
+ * @arg nla            Attribute of any kind.
+ * @arg remaining      Number of bytes remaining in attribute stream.
+ *
+ * Verifies that the header and payload do not exceed the number of
+ * bytes left in the attribute stream. This function must be called
+ * before access the attribute header or payload when iterating over
+ * the attribute stream using nla_next().
+ *
+ * @return True if the attribute can be accessed safely, false otherwise.
+ */
+int nla_ok(const struct nlattr *nla, int remaining)
+{
+       return remaining >= sizeof(*nla) &&
+              nla->nla_len >= sizeof(*nla) &&
+              nla->nla_len <= remaining;
+}
+
+/**
+ * Return next attribute in a stream of attributes.
+ * @arg nla            Attribute of any kind.
+ * @arg remaining      Variable to count remaining bytes in stream.
+ *
+ * Calculates the offset to the next attribute based on the attribute
+ * given. The attribute provided is assumed to be accessible, the
+ * caller is responsible to use nla_ok() beforehand. The offset (length
+ * of specified attribute including padding) is then subtracted from
+ * the remaining bytes variable and a pointer to the next attribute is
+ * returned.
+ *
+ * nla_next() can be called as long as remainig is >0.
+ *
+ * @return Pointer to next attribute.
+ */
+struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
+{
+       int totlen = NLA_ALIGN(nla->nla_len);
+
+       *remaining -= totlen;
+       return (struct nlattr *) ((char *) nla + totlen);
+}
+
+static uint16_t nla_attr_minlen[NLA_TYPE_MAX+1] = {
+       [NLA_U8]        = sizeof(uint8_t),
+       [NLA_U16]       = sizeof(uint16_t),
+       [NLA_U32]       = sizeof(uint32_t),
+       [NLA_U64]       = sizeof(uint64_t),
+       [NLA_STRING]    = 1,
+};
+
+static int validate_nla(struct nlattr *nla, int maxtype,
+                       struct nla_policy *policy)
+{
+       struct nla_policy *pt;
+       int minlen = 0, type = nla_type(nla);
+
+       if (type <= 0 || type > maxtype)
+               return 0;
+
+       pt = &policy[type];
+
+       if (pt->type > NLA_TYPE_MAX)
+               BUG();
+
+       if (pt->minlen)
+               minlen = pt->minlen;
+       else if (pt->type != NLA_UNSPEC)
+               minlen = nla_attr_minlen[pt->type];
+
+       if (pt->type == NLA_FLAG && nla_len(nla) > 0)
+               return -NLE_RANGE;
+
+       if (nla_len(nla) < minlen)
+               return -NLE_RANGE;
+
+       if (pt->maxlen && nla_len(nla) > pt->maxlen)
+               return -NLE_RANGE;
+
+       if (pt->type == NLA_STRING) {
+               char *data = nla_data(nla);
+               if (data[nla_len(nla) - 1] != '\0')
+                       return -NLE_INVAL;
+       }
+
+       return 0;
+}
+
+
+/**
+ * Create attribute index based on a stream of attributes.
+ * @arg tb             Index array to be filled (maxtype+1 elements).
+ * @arg maxtype                Maximum attribute type expected and accepted.
+ * @arg head           Head of attribute stream.
+ * @arg len            Length of attribute stream.
+ * @arg policy         Attribute validation policy.
+ *
+ * Iterates over the stream of attributes and stores a pointer to each
+ * attribute in the index array using the attribute type as index to
+ * the array. Attribute with a type greater than the maximum type
+ * specified will be silently ignored in order to maintain backwards
+ * compatibility. If \a policy is not NULL, the attribute will be
+ * validated using the specified policy.
+ *
+ * @see nla_validate
+ * @return 0 on success or a negative error code.
+ */
+int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
+             struct nla_policy *policy)
+{
+       struct nlattr *nla;
+       int rem, err;
+
+       memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));
+
+       nla_for_each_attr(nla, head, len, rem) {
+               int type = nla_type(nla);
+
+               if (type == 0) {
+                       fprintf(stderr, "Illegal nla->nla_type == 0\n");
+                       continue;
+               }
+
+               if (type <= maxtype) {
+                       if (policy) {
+                               err = validate_nla(nla, maxtype, policy);
+                               if (err < 0)
+                                       goto errout;
+                       }
+
+                       tb[type] = nla;
+               }
+       }
+
+       if (rem > 0)
+               fprintf(stderr, "netlink: %d bytes leftover after parsing "
+                      "attributes.\n", rem);
+
+       err = 0;
+errout:
+       return err;
+}
+
+/**
+ * Validate a stream of attributes.
+ * @arg head           Head of attributes stream.
+ * @arg len            Length of attributes stream.
+ * @arg maxtype                Maximum attribute type expected and accepted.
+ * @arg policy         Validation policy.
+ *
+ * Iterates over the stream of attributes and validates each attribute
+ * one by one using the specified policy. Attributes with a type greater
+ * than the maximum type specified will be silently ignored in order to
+ * maintain backwards compatibility.
+ *
+ * See \ref attr_datatypes for more details on what kind of validation
+ * checks are performed on each attribute data type.
+ *
+ * @return 0 on success or a negative error code.
+ */
+int nla_validate(struct nlattr *head, int len, int maxtype,
+                struct nla_policy *policy)
+{
+       struct nlattr *nla;
+       int rem, err;
+
+       nla_for_each_attr(nla, head, len, rem) {
+               err = validate_nla(nla, maxtype, policy);
+               if (err < 0)
+                       goto errout;
+       }
+
+       err = 0;
+errout:
+       return err;
+}
+
+/**
+ * Find a single attribute in a stream of attributes.
+ * @arg head           Head of attributes stream.
+ * @arg len            Length of attributes stream.
+ * @arg attrtype       Attribute type to look for.
+ *
+ * Iterates over the stream of attributes and compares each type with
+ * the type specified. Returns the first attribute which matches the
+ * type.
+ *
+ * @return Pointer to attribute found or NULL.
+ */
+struct nlattr *nla_find(struct nlattr *head, int len, int attrtype)
+{
+       struct nlattr *nla;
+       int rem;
+
+       nla_for_each_attr(nla, head, len, rem)
+               if (nla_type(nla) == attrtype)
+                       return nla;
+
+       return NULL;
+}
+
+/** @} */
+
+/**
+ * @name Unspecific Attribute
+ * @{
+ */
+
+/**
+ * Reserve space for a attribute.
+ * @arg msg            Netlink Message.
+ * @arg attrtype       Attribute Type.
+ * @arg attrlen                Length of payload.
+ *
+ * Reserves room for a attribute in the specified netlink message and
+ * fills in the attribute header (type, length). Returns NULL if there
+ * is unsuficient space for the attribute.
+ *
+ * Any padding between payload and the start of the next attribute is
+ * zeroed out.
+ *
+ * @return Pointer to start of attribute or NULL on failure.
+ */
+struct nlattr *nla_reserve(struct nl_msg *msg, int attrtype, int attrlen)
+{
+       struct nlattr *nla;
+       int tlen;
+       
+       tlen = NLMSG_ALIGN(msg->nm_nlh->nlmsg_len) + nla_total_size(attrlen);
+
+       if ((tlen + msg->nm_nlh->nlmsg_len) > msg->nm_size)
+               return NULL;
+
+       nla = (struct nlattr *) nlmsg_tail(msg->nm_nlh);
+       nla->nla_type = attrtype;
+       nla->nla_len = nla_attr_size(attrlen);
+
+       memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
+       msg->nm_nlh->nlmsg_len = tlen;
+
+       NL_DBG(2, "msg %p: Reserved %d bytes at offset +%td for attr %d "
+                 "nlmsg_len=%d\n", msg, attrlen,
+                 (void *) nla - nlmsg_data(msg->nm_nlh),
+                 attrtype, msg->nm_nlh->nlmsg_len);
+
+       return nla;
+}
+
+/**
+ * Add a unspecific attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg datalen                Length of data to be used as payload.
+ * @arg data           Pointer to data to be used as attribute payload.
+ *
+ * Reserves room for a unspecific attribute and copies the provided data
+ * into the message as payload of the attribute. Returns an error if there
+ * is insufficient space for the attribute.
+ *
+ * @see nla_reserve
+ * @return 0 on success or a negative error code.
+ */
+int nla_put(struct nl_msg *msg, int attrtype, int datalen, const void *data)
+{
+       struct nlattr *nla;
+
+       nla = nla_reserve(msg, attrtype, datalen);
+       if (!nla)
+               return -NLE_NOMEM;
+
+       memcpy(nla_data(nla), data, datalen);
+       NL_DBG(2, "msg %p: Wrote %d bytes at offset +%td for attr %d\n",
+              msg, datalen, (void *) nla - nlmsg_data(msg->nm_nlh), attrtype);
+
+       return 0;
+}
+
+
+
+/** @} */
diff --git a/package/libnl-tiny/src/cache.c b/package/libnl-tiny/src/cache.c
new file mode 100644 (file)
index 0000000..fed042d
--- /dev/null
@@ -0,0 +1,841 @@
+/*
+ * lib/cache.c         Caching Module
+ *
+ *     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 cache_mngt
+ * @defgroup cache Cache
+ *
+ * @code
+ *   Cache Management             |    | Type Specific Cache Operations
+ *                                      
+ *                                |    | +----------------+ +------------+
+ *                                       | request update | | msg_parser |
+ *                                |    | +----------------+ +------------+
+ *                                     +- - - - -^- - - - - - - -^- -|- - - -
+ *    nl_cache_update:            |              |               |   |
+ *          1) --------- co_request_update ------+               |   |
+ *                                |                              |   |
+ *          2) destroy old cache     +----------- pp_cb ---------|---+
+ *                                |  |                           |
+ *          3) ---------- nl_recvmsgs ----------+   +- cb_valid -+
+ *             +--------------+   |  |          |   |
+ *             | nl_cache_add |<-----+   + - - -v- -|- - - - - - - - - - -
+ *             +--------------+   |      | +-------------+
+ *                                         | nl_recvmsgs |
+ *                                |      | +-----|-^-----+
+ *                                           +---v-|---+
+ *                                |      |   | nl_recv |
+ *                                           +---------+
+ *                                |      |                 Core Netlink
+ * @endcode
+ * 
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/cache.h>
+#include <netlink/object.h>
+#include <netlink/utils.h>
+
+/**
+ * @name Access Functions
+ * @{
+ */
+
+#ifdef disabled
+/**
+ * Return the number of items in the cache
+ * @arg cache          cache handle
+ */
+int nl_cache_nitems(struct nl_cache *cache)
+{
+       return cache->c_nitems;
+}
+
+/**
+ * Return the number of items matching a filter in the cache
+ * @arg cache          Cache object.
+ * @arg filter         Filter object.
+ */
+int nl_cache_nitems_filter(struct nl_cache *cache, struct nl_object *filter)
+{
+       struct nl_object_ops *ops;
+       struct nl_object *obj;
+       int nitems = 0;
+
+       if (cache->c_ops == NULL)
+               BUG();
+
+       ops = cache->c_ops->co_obj_ops;
+       
+       nl_list_for_each_entry(obj, &cache->c_items, ce_list) {
+               if (filter && !nl_object_match_filter(obj, filter))
+                       continue;
+
+               nitems++;
+       }
+
+       return nitems;
+}
+
+/**
+ * Returns \b true if the cache is empty.
+ * @arg cache          Cache to check
+ * @return \a true if the cache is empty, otherwise \b false is returned.
+ */
+int nl_cache_is_empty(struct nl_cache *cache)
+{
+       return nl_list_empty(&cache->c_items);
+}
+
+/**
+ * Return the operations set of the cache
+ * @arg cache          cache handle
+ */
+struct nl_cache_ops *nl_cache_get_ops(struct nl_cache *cache)
+{
+       return cache->c_ops;
+}
+
+/**
+ * Return the first element in the cache
+ * @arg cache          cache handle
+ */
+struct nl_object *nl_cache_get_first(struct nl_cache *cache)
+{
+       if (nl_list_empty(&cache->c_items))
+               return NULL;
+
+       return nl_list_entry(cache->c_items.next,
+                            struct nl_object, ce_list);
+}
+
+/**
+ * Return the last element in the cache
+ * @arg cache          cache handle
+ */
+struct nl_object *nl_cache_get_last(struct nl_cache *cache)
+{
+       if (nl_list_empty(&cache->c_items))
+               return NULL;
+
+       return nl_list_entry(cache->c_items.prev,
+                            struct nl_object, ce_list);
+}
+
+/**
+ * Return the next element in the cache
+ * @arg obj            current object
+ */
+struct nl_object *nl_cache_get_next(struct nl_object *obj)
+{
+       if (nl_list_at_tail(obj, &obj->ce_cache->c_items, ce_list))
+               return NULL;
+       else
+               return nl_list_entry(obj->ce_list.next,
+                                    struct nl_object, ce_list);
+}
+
+/**
+ * Return the previous element in the cache
+ * @arg obj            current object
+ */
+struct nl_object *nl_cache_get_prev(struct nl_object *obj)
+{
+       if (nl_list_at_head(obj, &obj->ce_cache->c_items, ce_list))
+               return NULL;
+       else
+               return nl_list_entry(obj->ce_list.prev,
+                                    struct nl_object, ce_list);
+}
+#endif
+
+/** @} */
+
+/**
+ * @name Cache Creation/Deletion
+ * @{
+ */
+
+/**
+ * Allocate an empty cache
+ * @arg ops            cache operations to base the cache on
+ * 
+ * @return A newly allocated and initialized cache.
+ */
+struct nl_cache *nl_cache_alloc(struct nl_cache_ops *ops)
+{
+       struct nl_cache *cache;
+
+       cache = calloc(1, sizeof(*cache));
+       if (!cache)
+               return NULL;
+
+       nl_init_list_head(&cache->c_items);
+       cache->c_ops = ops;
+
+       NL_DBG(2, "Allocated cache %p <%s>.\n", cache, nl_cache_name(cache));
+
+       return cache;
+}
+
+int nl_cache_alloc_and_fill(struct nl_cache_ops *ops, struct nl_sock *sock,
+                           struct nl_cache **result)
+{
+       struct nl_cache *cache;
+       int err;
+       
+       if (!(cache = nl_cache_alloc(ops)))
+               return -NLE_NOMEM;
+
+       if (sock && (err = nl_cache_refill(sock, cache)) < 0) {
+               nl_cache_free(cache);
+               return err;
+       }
+
+       *result = cache;
+       return 0;
+}
+
+#ifdef disabled
+/**
+ * Allocate an empty cache based on type name
+ * @arg kind           Name of cache type
+ * @return A newly allocated and initialized cache.
+ */
+int nl_cache_alloc_name(const char *kind, struct nl_cache **result)
+{
+       struct nl_cache_ops *ops;
+       struct nl_cache *cache;
+
+       ops = nl_cache_ops_lookup(kind);
+       if (!ops)
+               return -NLE_NOCACHE;
+
+       if (!(cache = nl_cache_alloc(ops)))
+               return -NLE_NOMEM;
+
+       *result = cache;
+       return 0;
+}
+
+/**
+ * Allocate a new cache containing a subset of a cache
+ * @arg orig           Original cache to be based on
+ * @arg filter         Filter defining the subset to be filled into new cache
+ * @return A newly allocated cache or NULL.
+ */
+struct nl_cache *nl_cache_subset(struct nl_cache *orig,
+                                struct nl_object *filter)
+{
+       struct nl_cache *cache;
+       struct nl_object_ops *ops;
+       struct nl_object *obj;
+
+       if (!filter)
+               BUG();
+
+       cache = nl_cache_alloc(orig->c_ops);
+       if (!cache)
+               return NULL;
+
+       ops = orig->c_ops->co_obj_ops;
+
+       nl_list_for_each_entry(obj, &orig->c_items, ce_list) {
+               if (!nl_object_match_filter(obj, filter))
+                       continue;
+
+               nl_cache_add(cache, obj);
+       }
+
+       return cache;
+}
+#endif
+
+/**
+ * Clear a cache.
+ * @arg cache          cache to clear
+ *
+ * Removes all elements of a cache.
+ */
+void nl_cache_clear(struct nl_cache *cache)
+{
+       struct nl_object *obj, *tmp;
+
+       NL_DBG(1, "Clearing cache %p <%s>...\n", cache, nl_cache_name(cache));
+
+       nl_list_for_each_entry_safe(obj, tmp, &cache->c_items, ce_list)
+               nl_cache_remove(obj);
+}
+
+/**
+ * Free a cache.
+ * @arg cache          Cache to free.
+ *
+ * Removes all elements of a cache and frees all memory.
+ *
+ * @note Use this function if you are working with allocated caches.
+ */
+void nl_cache_free(struct nl_cache *cache)
+{
+       if (!cache)
+               return;
+
+       nl_cache_clear(cache);
+       NL_DBG(1, "Freeing cache %p <%s>...\n", cache, nl_cache_name(cache));
+       free(cache);
+}
+
+/** @} */
+
+/**
+ * @name Cache Modifications
+ * @{
+ */
+
+static int __cache_add(struct nl_cache *cache, struct nl_object *obj)
+{
+       obj->ce_cache = cache;
+
+       nl_list_add_tail(&obj->ce_list, &cache->c_items);
+       cache->c_nitems++;
+
+       NL_DBG(1, "Added %p to cache %p <%s>.\n",
+              obj, cache, nl_cache_name(cache));
+
+       return 0;
+}
+
+/**
+ * Add object to a cache.
+ * @arg cache          Cache to add object to
+ * @arg obj            Object to be added to the cache
+ *
+ * Adds the given object to the specified cache. The object is cloned
+ * if it has been added to another cache already.
+ *
+ * @return 0 or a negative error code.
+ */
+int nl_cache_add(struct nl_cache *cache, struct nl_object *obj)
+{
+       struct nl_object *new;
+
+       if (cache->c_ops->co_obj_ops != obj->ce_ops)
+               return -NLE_OBJ_MISMATCH;
+
+       if (!nl_list_empty(&obj->ce_list)) {
+               new = nl_object_clone(obj);
+               if (!new)
+                       return -NLE_NOMEM;
+       } else {
+               nl_object_get(obj);
+               new = obj;
+       }
+
+       return __cache_add(cache, new);
+}
+
+#ifdef disabled
+/**
+ * Move object from one cache to another
+ * @arg cache          Cache to move object to.
+ * @arg obj            Object subject to be moved
+ *
+ * Removes the given object from its associated cache if needed
+ * and adds it to the new cache.
+ *
+ * @return 0 on success or a negative error code.
+ */
+int nl_cache_move(struct nl_cache *cache, struct nl_object *obj)
+{
+       if (cache->c_ops->co_obj_ops != obj->ce_ops)
+               return -NLE_OBJ_MISMATCH;
+
+       NL_DBG(3, "Moving object %p to cache %p\n", obj, cache);
+       
+       /* Acquire reference, if already in a cache this will be
+        * reverted during removal */
+       nl_object_get(obj);
+
+       if (!nl_list_empty(&obj->ce_list))
+               nl_cache_remove(obj);
+
+       return __cache_add(cache, obj);
+}
+#endif
+
+/**
+ * Removes an object from a cache.
+ * @arg obj            Object to remove from its cache
+ *
+ * Removes the object \c obj from the cache it is assigned to, since
+ * an object can only be assigned to one cache at a time, the cache
+ * must ne be passed along with it.
+ */
+void nl_cache_remove(struct nl_object *obj)
+{
+       struct nl_cache *cache = obj->ce_cache;
+
+       if (cache == NULL)
+               return;
+
+       nl_list_del(&obj->ce_list);
+       obj->ce_cache = NULL;
+       nl_object_put(obj);
+       cache->c_nitems--;
+
+       NL_DBG(1, "Deleted %p from cache %p <%s>.\n",
+              obj, cache, nl_cache_name(cache));
+}
+
+#ifdef disabled
+/**
+ * Search for an object in a cache
+ * @arg cache          Cache to search in.
+ * @arg needle         Object to look for.
+ *
+ * Iterates over the cache and looks for an object with identical
+ * identifiers as the needle.
+ *
+ * @return Reference to object or NULL if not found.
+ * @note The returned object must be returned via nl_object_put().
+ */
+struct nl_object *nl_cache_search(struct nl_cache *cache,
+                                 struct nl_object *needle)
+{
+       struct nl_object *obj;
+
+       nl_list_for_each_entry(obj, &cache->c_items, ce_list) {
+               if (nl_object_identical(obj, needle)) {
+                       nl_object_get(obj);
+                       return obj;
+               }
+       }
+
+       return NULL;
+}
+#endif
+
+/** @} */
+
+/**
+ * @name Synchronization
+ * @{
+ */
+
+/**
+ * Request a full dump from the kernel to fill a cache
+ * @arg sk             Netlink socket.
+ * @arg cache          Cache subjected to be filled.
+ *
+ * Send a dumping request to the kernel causing it to dump all objects
+ * related to the specified cache to the netlink socket.
+ *
+ * Use nl_cache_pickup() to read the objects from the socket and fill them
+ * into a cache.
+ */
+int nl_cache_request_full_dump(struct nl_sock *sk, struct nl_cache *cache)
+{
+       NL_DBG(2, "Requesting dump from kernel for cache %p <%s>...\n",
+                 cache, nl_cache_name(cache));
+
+       if (cache->c_ops->co_request_update == NULL)
+               return -NLE_OPNOTSUPP;
+
+       return cache->c_ops->co_request_update(cache, sk);
+}
+
+/** @cond SKIP */
+struct update_xdata {
+       struct nl_cache_ops *ops;
+       struct nl_parser_param *params;
+};
+
+static int update_msg_parser(struct nl_msg *msg, void *arg)
+{
+       struct update_xdata *x = arg;
+       
+       return nl_cache_parse(x->ops, &msg->nm_src, msg->nm_nlh, x->params);
+}
+/** @endcond */
+
+int __cache_pickup(struct nl_sock *sk, struct nl_cache *cache,
+                  struct nl_parser_param *param)
+{
+       int err;
+       struct nl_cb *cb;
+       struct update_xdata x = {
+               .ops = cache->c_ops,
+               .params = param,
+       };
+
+       NL_DBG(1, "Picking up answer for cache %p <%s>...\n",
+                 cache, nl_cache_name(cache));
+
+       cb = nl_cb_clone(sk->s_cb);
+       if (cb == NULL)
+               return -NLE_NOMEM;
+
+       nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, update_msg_parser, &x);
+
+       err = nl_recvmsgs(sk, cb);
+       if (err < 0)
+               NL_DBG(2, "While picking up for %p <%s>, recvmsgs() returned " \
+                      "%d: %s", cache, nl_cache_name(cache),
+                      err, nl_geterror(err));
+
+       nl_cb_put(cb);
+
+       return err;
+}
+
+static int pickup_cb(struct nl_object *c, struct nl_parser_param *p)
+{
+       return nl_cache_add((struct nl_cache *) p->pp_arg, c);
+}
+
+/**
+ * Pickup a netlink dump response and put it into a cache.
+ * @arg sk             Netlink socket.
+ * @arg cache          Cache to put items into.
+ *
+ * Waits for netlink messages to arrive, parses them and puts them into
+ * the specified cache.
+ *
+ * @return 0 on success or a negative error code.
+ */
+int nl_cache_pickup(struct nl_sock *sk, struct nl_cache *cache)
+{
+       struct nl_parser_param p = {
+               .pp_cb = pickup_cb,
+               .pp_arg = cache,
+       };
+
+       return __cache_pickup(sk, cache, &p);
+}
+
+#ifdef disabled
+static int cache_include(struct nl_cache *cache, struct nl_object *obj,
+                        struct nl_msgtype *type, change_func_t cb)
+{
+       struct nl_object *old;
+
+       switch (type->mt_act) {
+       case NL_ACT_NEW:
+       case NL_ACT_DEL:
+               old = nl_cache_search(cache, obj);
+               if (old) {
+                       nl_cache_remove(old);
+                       if (type->mt_act == NL_ACT_DEL) {
+                               if (cb)
+                                       cb(cache, old, NL_ACT_DEL);
+                               nl_object_put(old);
+                       }
+               }
+
+               if (type->mt_act == NL_ACT_NEW) {
+                       nl_cache_move(cache, obj);
+                       if (old == NULL && cb)
+                               cb(cache, obj, NL_ACT_NEW);
+                       else if (old) {
+                               if (nl_object_diff(old, obj) && cb)
+                                       cb(cache, obj, NL_ACT_CHANGE);
+
+                               nl_object_put(old);
+                       }
+               }
+               break;
+       default:
+               NL_DBG(2, "Unknown action associated to object %p\n", obj);
+               return 0;
+       }
+
+       return 0;
+}
+
+int nl_cache_include(struct nl_cache *cache, struct nl_object *obj,
+                    change_func_t change_cb)
+{
+       struct nl_cache_ops *ops = cache->c_ops;
+       int i;
+
+       if (ops->co_obj_ops != obj->ce_ops)
+               return -NLE_OBJ_MISMATCH;
+
+       for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++)
+               if (ops->co_msgtypes[i].mt_id == obj->ce_msgtype)
+                       return cache_include(cache, obj, &ops->co_msgtypes[i],
+                                            change_cb);
+
+       return -NLE_MSGTYPE_NOSUPPORT;
+}
+
+static int resync_cb(struct nl_object *c, struct nl_parser_param *p)
+{
+       struct nl_cache_assoc *ca = p->pp_arg;
+
+       return nl_cache_include(ca->ca_cache, c, ca->ca_change);
+}
+
+int nl_cache_resync(struct nl_sock *sk, struct nl_cache *cache,
+                   change_func_t change_cb)
+{
+       struct nl_object *obj, *next;
+       struct nl_cache_assoc ca = {
+               .ca_cache = cache,
+               .ca_change = change_cb,
+       };
+       struct nl_parser_param p = {
+               .pp_cb = resync_cb,
+               .pp_arg = &ca,
+       };
+       int err;
+
+       NL_DBG(1, "Resyncing cache %p <%s>...\n", cache, nl_cache_name(cache));
+
+       /* Mark all objects so we can see if some of them are obsolete */
+       nl_cache_mark_all(cache);
+
+       err = nl_cache_request_full_dump(sk, cache);
+       if (err < 0)
+               goto errout;
+
+       err = __cache_pickup(sk, cache, &p);
+       if (err < 0)
+               goto errout;
+
+       nl_list_for_each_entry_safe(obj, next, &cache->c_items, ce_list)
+               if (nl_object_is_marked(obj))
+                       nl_cache_remove(obj);
+
+       NL_DBG(1, "Finished resyncing %p <%s>\n", cache, nl_cache_name(cache));
+
+       err = 0;
+errout:
+       return err;
+}
+#endif
+
+/** @} */
+
+/**
+ * @name Parsing
+ * @{
+ */
+
+/** @cond SKIP */
+int nl_cache_parse(struct nl_cache_ops *ops, struct sockaddr_nl *who,
+                  struct nlmsghdr *nlh, struct nl_parser_param *params)
+{
+       int i, err;
+
+       if (!nlmsg_valid_hdr(nlh, ops->co_hdrsize))
+               return -NLE_MSG_TOOSHORT;
+
+       for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++) {
+               if (ops->co_msgtypes[i].mt_id == nlh->nlmsg_type) {
+                       err = ops->co_msg_parser(ops, who, nlh, params);
+                       if (err != -NLE_OPNOTSUPP)
+                               goto errout;
+               }
+       }
+
+
+       err = -NLE_MSGTYPE_NOSUPPORT;
+errout:
+       return err;
+}
+/** @endcond */
+
+/**
+ * Parse a netlink message and add it to the cache.
+ * @arg cache          cache to add element to
+ * @arg msg            netlink message
+ *
+ * Parses a netlink message by calling the cache specific message parser
+ * and adds the new element to the cache.
+ *
+ * @return 0 or a negative error code.
+ */
+int nl_cache_parse_and_add(struct nl_cache *cache, struct nl_msg *msg)
+{
+       struct nl_parser_param p = {
+               .pp_cb = pickup_cb,
+               .pp_arg = cache,
+       };
+
+       return nl_cache_parse(cache->c_ops, NULL, nlmsg_hdr(msg), &p);
+}
+
+/**
+ * (Re)fill a cache with the contents in the kernel.
+ * @arg sk             Netlink socket.
+ * @arg cache          cache to update
+ *
+ * Clears the specified cache and fills it with the current state in
+ * the kernel.
+ *
+ * @return 0 or a negative error code.
+ */
+int nl_cache_refill(struct nl_sock *sk, struct nl_cache *cache)
+{
+       int err;
+
+       err = nl_cache_request_full_dump(sk, cache);
+       if (err < 0)
+               return err;
+
+       NL_DBG(2, "Upading cache %p <%s>, request sent, waiting for dump...\n",
+              cache, nl_cache_name(cache));
+       nl_cache_clear(cache);
+
+       return nl_cache_pickup(sk, cache);
+}
+
+/** @} */
+#ifdef disabled
+
+/**
+ * @name Utillities
+ * @{
+ */
+
+/**
+ * Mark all objects in a cache
+ * @arg cache          Cache to mark all objects in
+ */
+void nl_cache_mark_all(struct nl_cache *cache)
+{
+       struct nl_object *obj;
+
+       NL_DBG(2, "Marking all objects in cache %p <%s>...\n",
+                 cache, nl_cache_name(cache));
+
+       nl_list_for_each_entry(obj, &cache->c_items, ce_list)
+               nl_object_mark(obj);
+}
+
+/** @} */
+
+/**
+ * @name Dumping
+ * @{
+ */
+#ifdef disabled
+/**
+ * Dump all elements of a cache.
+ * @arg cache          cache to dump
+ * @arg params         dumping parameters
+ *
+ * Dumps all elements of the \a cache to the file descriptor \a fd.
+ */
+void nl_cache_dump(struct nl_cache *cache, struct nl_dump_params *params)
+{
+       nl_cache_dump_filter(cache, params, NULL);
+}
+
+/**
+ * Dump all elements of a cache (filtered).
+ * @arg cache          cache to dump
+ * @arg params         dumping parameters (optional)
+ * @arg filter         filter object
+ *
+ * Dumps all elements of the \a cache to the file descriptor \a fd
+ * given they match the given filter \a filter.
+ */
+void nl_cache_dump_filter(struct nl_cache *cache,
+                         struct nl_dump_params *params,
+                         struct nl_object *filter)
+{
+       int type = params ? params->dp_type : NL_DUMP_DETAILS;
+       struct nl_object_ops *ops;
+       struct nl_object *obj;
+
+       NL_DBG(2, "Dumping cache %p <%s> filter %p\n",
+              cache, nl_cache_name(cache), filter);
+
+       if (type > NL_DUMP_MAX || type < 0)
+               BUG();
+
+       if (cache->c_ops == NULL)
+               BUG();
+
+       ops = cache->c_ops->co_obj_ops;
+       if (!ops->oo_dump[type])
+               return;
+
+       nl_list_for_each_entry(obj, &cache->c_items, ce_list) {
+               if (filter && !nl_object_match_filter(obj, filter))
+                       continue;
+
+               NL_DBG(4, "Dumping object %p...\n", obj);
+               dump_from_ops(obj, params);
+       }
+}
+#endif
+
+/** @} */
+
+/**
+ * @name Iterators
+ * @{
+ */
+
+/**
+ * Call a callback on each element of the cache.
+ * @arg cache          cache to iterate on
+ * @arg cb             callback function
+ * @arg arg            argument passed to callback function
+ *
+ * Calls a callback function \a cb on each element of the \a cache.
+ * The argument \a arg is passed on the callback function.
+ */
+void nl_cache_foreach(struct nl_cache *cache,
+                     void (*cb)(struct nl_object *, void *), void *arg)
+{
+       nl_cache_foreach_filter(cache, NULL, cb, arg);
+}
+
+/**
+ * Call a callback on each element of the cache (filtered).
+ * @arg cache          cache to iterate on
+ * @arg filter         filter object
+ * @arg cb             callback function
+ * @arg arg            argument passed to callback function
+ *
+ * Calls a callback function \a cb on each element of the \a cache
+ * that matches the \a filter. The argument \a arg is passed on
+ * to the callback function.
+ */
+void nl_cache_foreach_filter(struct nl_cache *cache, struct nl_object *filter,
+                            void (*cb)(struct nl_object *, void *), void *arg)
+{
+       struct nl_object *obj, *tmp;
+       struct nl_object_ops *ops;
+
+       if (cache->c_ops == NULL)
+               BUG();
+
+       ops = cache->c_ops->co_obj_ops;
+
+       nl_list_for_each_entry_safe(obj, tmp, &cache->c_items, ce_list) {
+               if (filter && !nl_object_match_filter(obj, filter))
+                       continue;
+
+               cb(obj, arg);
+       }
+}
+
+/** @} */
+#endif
+
+/** @} */
diff --git a/package/libnl-tiny/src/cache_mngt.c b/package/libnl-tiny/src/cache_mngt.c
new file mode 100644 (file)
index 0000000..d57d836
--- /dev/null
@@ -0,0 +1,249 @@
+/*
+ * lib/cache_mngt.c    Cache Management
+ *
+ *     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 core
+ * @defgroup cache_mngt Caching
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/cache.h>
+#include <netlink/utils.h>
+
+static struct nl_cache_ops *cache_ops;
+
+/**
+ * @name Cache Operations Sets
+ * @{
+ */
+
+/**
+ * Lookup the set cache operations of a certain cache type
+ * @arg name           name of the cache type
+ *
+ * @return The cache operations or NULL if no operations
+ *         have been registered under the specified name.
+ */
+struct nl_cache_ops *nl_cache_ops_lookup(const char *name)
+{
+       struct nl_cache_ops *ops;
+
+       for (ops = cache_ops; ops; ops = ops->co_next)
+               if (!strcmp(ops->co_name, name))
+                       return ops;
+
+       return NULL;
+}
+
+/**
+ * Associate a message type to a set of cache operations
+ * @arg protocol               netlink protocol
+ * @arg msgtype                        netlink message type
+ *
+ * Associates the specified netlink message type with
+ * a registered set of cache operations.
+ *
+ * @return The cache operations or NULL if no association
+ *         could be made.
+ */
+struct nl_cache_ops *nl_cache_ops_associate(int protocol, int msgtype)
+{
+       int i;
+       struct nl_cache_ops *ops;
+
+       for (ops = cache_ops; ops; ops = ops->co_next) {
+               if (ops->co_protocol != protocol)
+                       continue;
+
+               for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++)
+                       if (ops->co_msgtypes[i].mt_id == msgtype)
+                               return ops;
+       }
+
+       return NULL;
+}
+
+/**
+ * Lookup message type cache association
+ * @arg ops                    cache operations
+ * @arg msgtype                        netlink message type
+ *
+ * Searches for a matching message type association ing the specified
+ * cache operations.
+ *
+ * @return A message type association or NULL.
+ */
+struct nl_msgtype *nl_msgtype_lookup(struct nl_cache_ops *ops, int msgtype)
+{
+       int i;
+
+       for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++)
+               if (ops->co_msgtypes[i].mt_id == msgtype)
+                       return &ops->co_msgtypes[i];
+
+       return NULL;
+}
+
+static struct nl_cache_ops *cache_ops_lookup_for_obj(struct nl_object_ops *obj_ops)
+{
+       struct nl_cache_ops *ops;
+
+       for (ops = cache_ops; ops; ops = ops->co_next)
+               if (ops->co_obj_ops == obj_ops)
+                       return ops;
+
+       return NULL;
+
+}
+
+/**
+ * Call a function for each registered cache operation
+ * @arg cb             Callback function to be called
+ * @arg arg            User specific argument.
+ */
+void nl_cache_ops_foreach(void (*cb)(struct nl_cache_ops *, void *), void *arg)
+{
+       struct nl_cache_ops *ops;
+
+       for (ops = cache_ops; ops; ops = ops->co_next)
+               cb(ops, arg);
+}
+
+/**
+ * Register a set of cache operations
+ * @arg ops            cache operations
+ *
+ * Called by users of caches to announce the avaibility of
+ * a certain cache type.
+ *
+ * @return 0 on success or a negative error code.
+ */
+int nl_cache_mngt_register(struct nl_cache_ops *ops)
+{
+       if (!ops->co_name || !ops->co_obj_ops)
+               return -NLE_INVAL;
+
+       if (nl_cache_ops_lookup(ops->co_name))
+               return -NLE_EXIST;
+
+       ops->co_next = cache_ops;
+       cache_ops = ops;
+
+       NL_DBG(1, "Registered cache operations %s\n", ops->co_name);
+
+       return 0;
+}
+
+/**
+ * Unregister a set of cache operations
+ * @arg ops            cache operations
+ *
+ * Called by users of caches to announce a set of
+ * cache operations is no longer available. The
+ * specified cache operations must have been registered
+ * previously using nl_cache_mngt_register()
+ *
+ * @return 0 on success or a negative error code
+ */
+int nl_cache_mngt_unregister(struct nl_cache_ops *ops)
+{
+       struct nl_cache_ops *t, **tp;
+
+       for (tp = &cache_ops; (t=*tp) != NULL; tp = &t->co_next)
+               if (t == ops)
+                       break;
+
+       if (!t)
+               return -NLE_NOCACHE;
+
+       NL_DBG(1, "Unregistered cache operations %s\n", ops->co_name);
+
+       *tp = t->co_next;
+       return 0;
+}
+
+/** @} */
+
+/**
+ * @name Global Cache Provisioning/Requiring
+ * @{
+ */
+
+/**
+ * Provide a cache for global use
+ * @arg cache          cache to provide
+ *
+ * Offers the specified cache to be used by other modules.
+ * Only one cache per type may be shared at a time,
+ * a previsouly provided caches will be overwritten.
+ */
+void nl_cache_mngt_provide(struct nl_cache *cache)
+{
+       struct nl_cache_ops *ops;
+
+       ops = cache_ops_lookup_for_obj(cache->c_ops->co_obj_ops);
+       if (!ops)
+               BUG();
+       else
+               ops->co_major_cache = cache;
+}
+
+/**
+ * Unprovide a cache for global use
+ * @arg cache          cache to unprovide
+ *
+ * Cancels the offer to use a cache globally. The
+ * cache will no longer be returned via lookups but
+ * may still be in use.
+ */
+void nl_cache_mngt_unprovide(struct nl_cache *cache)
+{
+       struct nl_cache_ops *ops;
+
+       ops = cache_ops_lookup_for_obj(cache->c_ops->co_obj_ops);
+       if (!ops)
+               BUG();
+       else if (ops->co_major_cache == cache)
+               ops->co_major_cache = NULL;
+}
+
+/**
+ * Demand the use of a global cache
+ * @arg name           name of the required object type
+ *
+ * Trys to find a cache of the specified type for global
+ * use.
+ *
+ * @return A cache provided by another subsystem of the
+ *         specified type marked to be available.
+ */
+struct nl_cache *nl_cache_mngt_require(const char *name)
+{
+       struct nl_cache_ops *ops;
+
+       ops = nl_cache_ops_lookup(name);
+       if (!ops || !ops->co_major_cache) {
+               fprintf(stderr, "Application BUG: Your application must "
+                       "call nl_cache_mngt_provide() and\nprovide a valid "
+                       "%s cache to be used for internal lookups.\nSee the "
+                       " API documentation for more details.\n", name);
+
+               return NULL;
+       }
+       
+       return ops->co_major_cache;
+}
+
+/** @} */
+
+/** @} */
diff --git a/package/libnl-tiny/src/error.c b/package/libnl-tiny/src/error.c
new file mode 100644 (file)
index 0000000..71ae722
--- /dev/null
@@ -0,0 +1,108 @@
+/*
+ * lib/error.c         Error Handling
+ *
+ *     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) 2008 Thomas Graf <tgraf@suug.ch>
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+
+static const char *errmsg[NLE_MAX+1] = {
+[NLE_SUCCESS]          = "Success",
+[NLE_FAILURE]          = "Unspecific failure",
+[NLE_INTR]             = "Interrupted system call",
+[NLE_BAD_SOCK]         = "Bad socket",
+[NLE_AGAIN]            = "Try again",
+[NLE_NOMEM]            = "Out of memory",
+[NLE_EXIST]            = "Object exists",
+[NLE_INVAL]            = "Invalid input data or parameter",
+[NLE_RANGE]            = "Input data out of range",
+[NLE_MSGSIZE]          = "Message size not sufficient",
+[NLE_OPNOTSUPP]                = "Operation not supported",
+[NLE_AF_NOSUPPORT]     = "Address family not supported",
+[NLE_OBJ_NOTFOUND]     = "Object not found",
+[NLE_NOATTR]           = "Attribute not available",
+[NLE_MISSING_ATTR]     = "Missing attribute",
+[NLE_AF_MISMATCH]      = "Address family mismatch",
+[NLE_SEQ_MISMATCH]     = "Message sequence number mismatch",
+[NLE_MSG_OVERFLOW]     = "Kernel reported message overflow",
+[NLE_MSG_TRUNC]                = "Kernel reported truncated message",
+[NLE_NOADDR]           = "Invalid address for specified address family",
+[NLE_SRCRT_NOSUPPORT]  = "Source based routing not supported",
+[NLE_MSG_TOOSHORT]     = "Netlink message is too short",
+[NLE_MSGTYPE_NOSUPPORT]        = "Netlink message type is not supported",
+[NLE_OBJ_MISMATCH]     = "Object type does not match cache",
+[NLE_NOCACHE]          = "Unknown or invalid cache type",
+[NLE_BUSY]             = "Object busy",
+[NLE_PROTO_MISMATCH]   = "Protocol mismatch",
+[NLE_NOACCESS]         = "No Access",
+[NLE_PERM]             = "Operation not permitted",
+};
+
+/**
+ * Return error message for an error code
+ * @return error message
+ */
+const char *nl_geterror(int error)
+{
+       error = abs(error);
+
+       if (error > NLE_MAX)
+               error = NLE_FAILURE;
+
+       return errmsg[error];
+}
+
+/**
+ * Print a libnl error message
+ * @arg s              error message prefix
+ *
+ * Prints the error message of the call that failed last.
+ *
+ * If s is not NULL and *s is not a null byte the argument
+ * string is printed, followed by a colon and a blank. Then
+ * the error message and a new-line.
+ */
+void nl_perror(int error, const char *s)
+{
+       if (s && *s)
+               fprintf(stderr, "%s: %s\n", s, nl_geterror(error));
+       else
+               fprintf(stderr, "%s\n", nl_geterror(error));
+}
+
+int nl_syserr2nlerr(int error)
+{
+       error = abs(error);
+
+       switch (error) {
+       case EBADF:             return NLE_BAD_SOCK;
+       case EADDRINUSE:        return NLE_EXIST;
+       case EEXIST:            return NLE_EXIST;
+       case EADDRNOTAVAIL:     return NLE_NOADDR;
+       case ENOENT:            return NLE_OBJ_NOTFOUND;
+       case EINTR:             return NLE_INTR;
+       case EAGAIN:            return NLE_AGAIN;
+       case ENOTSOCK:          return NLE_BAD_SOCK;
+       case ENOPROTOOPT:       return NLE_INVAL;
+       case EFAULT:            return NLE_INVAL;
+       case EACCES:            return NLE_NOACCESS;
+       case EINVAL:            return NLE_INVAL;
+       case ENOBUFS:           return NLE_NOMEM;
+       case ENOMEM:            return NLE_NOMEM;
+       case EAFNOSUPPORT:      return NLE_AF_NOSUPPORT;
+       case EPROTONOSUPPORT:   return NLE_PROTO_MISMATCH;
+       case EOPNOTSUPP:        return NLE_OPNOTSUPP;
+       case EPERM:             return NLE_PERM;
+       case EBUSY:             return NLE_BUSY;
+       default:                return NLE_FAILURE;
+       }
+}
+
+/** @} */
+
diff --git a/package/libnl-tiny/src/genl.c b/package/libnl-tiny/src/genl.c
new file mode 100644 (file)
index 0000000..055be91
--- /dev/null
@@ -0,0 +1,268 @@
+/*
+ * lib/genl/genl.c             Generic Netlink
+ *
+ *     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>
+ */
+
+/**
+ * @defgroup genl Generic Netlink
+ *
+ * @par Message Format
+ * @code
+ *  <------- NLMSG_ALIGN(hlen) ------> <---- NLMSG_ALIGN(len) --->
+ * +----------------------------+- - -+- - - - - - - - - - -+- - -+
+ * |           Header           | Pad |       Payload       | Pad |
+ * |      struct nlmsghdr       |     |                     |     |
+ * +----------------------------+- - -+- - - - - - - - - - -+- - -+
+ * @endcode
+ * @code
+ *  <-------- GENL_HDRLEN -------> <--- hdrlen -->
+ *                                 <------- genlmsg_len(ghdr) ------>
+ * +------------------------+- - -+---------------+- - -+------------+
+ * | Generic Netlink Header | Pad | Family Header | Pad | Attributes |
+ * |    struct genlmsghdr   |     |               |     |            |
+ * +------------------------+- - -+---------------+- - -+------------+
+ * genlmsg_data(ghdr)--------------^                     ^
+ * genlmsg_attrdata(ghdr, hdrlen)-------------------------
+ * @endcode
+ *
+ * @par Example
+ * @code
+ * #include <netlink/netlink.h>
+ * #include <netlink/genl/genl.h>
+ * #include <netlink/genl/ctrl.h>
+ *
+ * struct nl_sock *sock;
+ * struct nl_msg *msg;
+ * int family;
+ *
+ * // Allocate a new netlink socket
+ * sock = nl_socket_alloc();
+ *
+ * // Connect to generic netlink socket on kernel side
+ * genl_connect(sock);
+ *
+ * // Ask kernel to resolve family name to family id
+ * family = genl_ctrl_resolve(sock, "generic_netlink_family_name");
+ *
+ * // Construct a generic netlink by allocating a new message, fill in
+ * // the header and append a simple integer attribute.
+ * msg = nlmsg_alloc();
+ * genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, family, 0, NLM_F_ECHO,
+ *             CMD_FOO_GET, FOO_VERSION);
+ * nla_put_u32(msg, ATTR_FOO, 123);
+ *
+ * // Send message over netlink socket
+ * nl_send_auto_complete(sock, msg);
+ *
+ * // Free message
+ * nlmsg_free(msg);
+ *
+ * // Prepare socket to receive the answer by specifying the callback
+ * // function to be called for valid messages.
+ * nl_socket_modify_cb(sock, NL_CB_VALID, NL_CB_CUSTOM, parse_cb, NULL);
+ *
+ * // Wait for the answer and receive it
+ * nl_recvmsgs_default(sock);
+ *
+ * static int parse_cb(struct nl_msg *msg, void *arg)
+ * {
+ *     struct nlmsghdr *nlh = nlmsg_hdr(msg);
+ *     struct nlattr *attrs[ATTR_MAX+1];
+ *
+ *     // Validate message and parse attributes
+ *     genlmsg_parse(nlh, 0, attrs, ATTR_MAX, policy);
+ *
+ *     if (attrs[ATTR_FOO]) {
+ *         uint32_t value = nla_get_u32(attrs[ATTR_FOO]);
+ *         ...
+ *     }
+ *
+ *     return 0;
+ * }
+ * @endcode
+ * @{
+ */
+
+#include <netlink-generic.h>
+#include <netlink/netlink.h>
+#include <netlink/genl/genl.h>
+#include <netlink/utils.h>
+
+/**
+ * @name Socket Creating
+ * @{
+ */
+
+int genl_connect(struct nl_sock *sk)
+{
+       return nl_connect(sk, NETLINK_GENERIC);
+}
+
+/** @} */
+
+/**
+ * @name Sending
+ * @{
+ */
+
+/**
+ * Send trivial generic netlink message
+ * @arg sk             Netlink socket.
+ * @arg family         Generic netlink family
+ * @arg cmd            Command
+ * @arg version                Version
+ * @arg flags          Additional netlink message flags.
+ *
+ * Fills out a routing netlink request message and sends it out
+ * using nl_send_simple().
+ *
+ * @return 0 on success or a negative error code.
+ */
+int genl_send_simple(struct nl_sock *sk, int family, int cmd,
+                    int version, int flags)
+{
+       struct genlmsghdr hdr = {
+               .cmd = cmd,
+               .version = version,
+       };
+
+       return nl_send_simple(sk, family, flags, &hdr, sizeof(hdr));
+}
+
+/** @} */
+
+
+/**
+ * @name Message Parsing
+ * @{
+ */
+
+int genlmsg_valid_hdr(struct nlmsghdr *nlh, int hdrlen)
+{
+       struct genlmsghdr *ghdr;
+
+       if (!nlmsg_valid_hdr(nlh, GENL_HDRLEN))
+               return 0;
+
+       ghdr = nlmsg_data(nlh);
+       if (genlmsg_len(ghdr) < NLMSG_ALIGN(hdrlen))
+               return 0;
+
+       return 1;
+}
+
+int genlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
+                  struct nla_policy *policy)
+{
+       struct genlmsghdr *ghdr;
+
+       if (!genlmsg_valid_hdr(nlh, hdrlen))
+               return -NLE_MSG_TOOSHORT;
+
+       ghdr = nlmsg_data(nlh);
+       return nla_validate(genlmsg_attrdata(ghdr, hdrlen),
+                           genlmsg_attrlen(ghdr, hdrlen), maxtype, policy);
+}
+
+int genlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[],
+                 int maxtype, struct nla_policy *policy)
+{
+       struct genlmsghdr *ghdr;
+
+       if (!genlmsg_valid_hdr(nlh, hdrlen))
+               return -NLE_MSG_TOOSHORT;
+
+       ghdr = nlmsg_data(nlh);
+       return nla_parse(tb, maxtype, genlmsg_attrdata(ghdr, hdrlen),
+                        genlmsg_attrlen(ghdr, hdrlen), policy);
+}
+
+/**
+ * Get head of message payload
+ * @arg gnlh   genetlink messsage header
+ */
+void *genlmsg_data(const struct genlmsghdr *gnlh)
+{
+       return ((unsigned char *) gnlh + GENL_HDRLEN);
+}
+
+/**
+ * Get lenght of message payload
+ * @arg gnlh   genetlink message header
+ */
+int genlmsg_len(const struct genlmsghdr *gnlh)
+{
+       struct nlmsghdr *nlh = (struct nlmsghdr *)((unsigned char *)gnlh -
+                                                       NLMSG_HDRLEN);
+       return (nlh->nlmsg_len - GENL_HDRLEN - NLMSG_HDRLEN);
+}
+
+/**
+ * Get head of attribute data
+ * @arg gnlh   generic netlink message header
+ * @arg hdrlen length of family specific header
+ */
+struct nlattr *genlmsg_attrdata(const struct genlmsghdr *gnlh, int hdrlen)
+{
+       return genlmsg_data(gnlh) + NLMSG_ALIGN(hdrlen);
+}
+
+/**
+ * Get length of attribute data
+ * @arg gnlh   generic netlink message header
+ * @arg hdrlen length of family specific header
+ */
+int genlmsg_attrlen(const struct genlmsghdr *gnlh, int hdrlen)
+{
+       return genlmsg_len(gnlh) - NLMSG_ALIGN(hdrlen);
+}
+
+/** @} */
+
+/**
+ * @name Message Building
+ * @{
+ */
+
+/**
+ * Add generic netlink header to netlink message
+ * @arg msg            netlink message
+ * @arg pid            netlink process id or NL_AUTO_PID
+ * @arg seq            sequence number of message or NL_AUTO_SEQ
+ * @arg family         generic netlink family
+ * @arg hdrlen         length of user specific header
+ * @arg flags          message flags
+ * @arg cmd            generic netlink command
+ * @arg version                protocol version
+ *
+ * Returns pointer to user specific header.
+ */
+void *genlmsg_put(struct nl_msg *msg, uint32_t pid, uint32_t seq, int family,
+                 int hdrlen, int flags, uint8_t cmd, uint8_t version)
+{
+       struct nlmsghdr *nlh;
+       struct genlmsghdr hdr = {
+               .cmd = cmd,
+               .version = version,
+       };
+
+       nlh = nlmsg_put(msg, pid, seq, family, GENL_HDRLEN + hdrlen, flags);
+       if (nlh == NULL)
+               return NULL;
+
+       memcpy(nlmsg_data(nlh), &hdr, sizeof(hdr));
+       NL_DBG(2, "msg %p: Added generic netlink header cmd=%d version=%d\n",
+              msg, cmd, version);
+
+       return nlmsg_data(nlh) + GENL_HDRLEN;
+}
+
+/** @} */
+
+/** @} */
diff --git a/package/libnl-tiny/src/genl_ctrl.c b/package/libnl-tiny/src/genl_ctrl.c
new file mode 100644 (file)
index 0000000..1301642
--- /dev/null
@@ -0,0 +1,302 @@
+/*
+ * lib/genl/ctrl.c             Generic Netlink Controller
+ *
+ *     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 genl_mngt
+ * @defgroup ctrl Controller
+ * @brief
+ *
+ * @{
+ */
+
+#include <netlink-generic.h>
+#include <netlink/netlink.h>
+#include <netlink/genl/genl.h>
+#include <netlink/genl/family.h>
+#include <netlink/genl/mngt.h>
+#include <netlink/genl/ctrl.h>
+#include <netlink/utils.h>
+
+/** @cond SKIP */
+#define CTRL_VERSION           0x0001
+
+static struct nl_cache_ops genl_ctrl_ops;
+/** @endcond */
+
+static int ctrl_request_update(struct nl_cache *c, struct nl_sock *h)
+{
+       return genl_send_simple(h, GENL_ID_CTRL, CTRL_CMD_GETFAMILY,
+                               CTRL_VERSION, NLM_F_DUMP);
+}
+
+static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
+       [CTRL_ATTR_FAMILY_ID]   = { .type = NLA_U16 },
+       [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_STRING,
+                                   .maxlen = GENL_NAMSIZ },
+       [CTRL_ATTR_VERSION]     = { .type = NLA_U32 },
+       [CTRL_ATTR_HDRSIZE]     = { .type = NLA_U32 },
+       [CTRL_ATTR_MAXATTR]     = { .type = NLA_U32 },
+       [CTRL_ATTR_OPS]         = { .type = NLA_NESTED },
+};
+
+static struct nla_policy family_op_policy[CTRL_ATTR_OP_MAX+1] = {
+       [CTRL_ATTR_OP_ID]       = { .type = NLA_U32 },
+       [CTRL_ATTR_OP_FLAGS]    = { .type = NLA_U32 },
+};
+
+static int ctrl_msg_parser(struct nl_cache_ops *ops, struct genl_cmd *cmd,
+                          struct genl_info *info, void *arg)
+{
+       struct genl_family *family;
+       struct nl_parser_param *pp = arg;
+       int err;
+
+       family = genl_family_alloc();
+       if (family == NULL) {
+               err = -NLE_NOMEM;
+               goto errout;
+       }
+
+       if (info->attrs[CTRL_ATTR_FAMILY_NAME] == NULL) {
+               err = -NLE_MISSING_ATTR;
+               goto errout;
+       }
+
+       if (info->attrs[CTRL_ATTR_FAMILY_ID] == NULL) {
+               err = -NLE_MISSING_ATTR;
+               goto errout;
+       }
+
+       family->ce_msgtype = info->nlh->nlmsg_type;
+       genl_family_set_id(family,
+                          nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]));
+       genl_family_set_name(family,
+                    nla_get_string(info->attrs[CTRL_ATTR_FAMILY_NAME]));
+
+       if (info->attrs[CTRL_ATTR_VERSION]) {
+               uint32_t version = nla_get_u32(info->attrs[CTRL_ATTR_VERSION]);
+               genl_family_set_version(family, version);
+       }
+
+       if (info->attrs[CTRL_ATTR_HDRSIZE]) {
+               uint32_t hdrsize = nla_get_u32(info->attrs[CTRL_ATTR_HDRSIZE]);
+               genl_family_set_hdrsize(family, hdrsize);
+       }
+
+       if (info->attrs[CTRL_ATTR_MAXATTR]) {
+               uint32_t maxattr = nla_get_u32(info->attrs[CTRL_ATTR_MAXATTR]);
+               genl_family_set_maxattr(family, maxattr);
+       }
+
+       if (info->attrs[CTRL_ATTR_OPS]) {
+               struct nlattr *nla, *nla_ops;
+               int remaining;
+
+               nla_ops = info->attrs[CTRL_ATTR_OPS];
+               nla_for_each_nested(nla, nla_ops, remaining) {
+                       struct nlattr *tb[CTRL_ATTR_OP_MAX+1];
+                       int flags = 0, id;
+
+                       err = nla_parse_nested(tb, CTRL_ATTR_OP_MAX, nla,
+                                              family_op_policy);
+                       if (err < 0)
+                               goto errout;
+
+                       if (tb[CTRL_ATTR_OP_ID] == NULL) {
+                               err = -NLE_MISSING_ATTR;
+                               goto errout;
+                       }
+                       
+                       id = nla_get_u32(tb[CTRL_ATTR_OP_ID]);
+
+                       if (tb[CTRL_ATTR_OP_FLAGS])
+                               flags = nla_get_u32(tb[CTRL_ATTR_OP_FLAGS]);
+
+                       err = genl_family_add_op(family, id, flags);
+                       if (err < 0)
+                               goto errout;
+
+               }
+       }
+
+       err = pp->pp_cb((struct nl_object *) family, pp);
+errout:
+       genl_family_put(family);
+       return err;
+}
+
+/**
+ * @name Cache Management
+ * @{
+ */
+
+int genl_ctrl_alloc_cache(struct nl_sock *sock, struct nl_cache **result)
+{
+       return nl_cache_alloc_and_fill(&genl_ctrl_ops, sock, result);
+}
+
+/**
+ * Look up generic netlink family by id in the provided cache.
+ * @arg cache          Generic netlink family cache.
+ * @arg id             Family identifier.
+ *
+ * Searches through the cache looking for a registered family
+ * matching the specified identifier. The caller will own a
+ * reference on the returned object which needs to be given
+ * back after usage using genl_family_put().
+ *
+ * @return Generic netlink family object or NULL if no match was found.
+ */
+struct genl_family *genl_ctrl_search(struct nl_cache *cache, int id)
+{
+       struct genl_family *fam;
+
+       if (cache->c_ops != &genl_ctrl_ops)
+               BUG();
+
+       nl_list_for_each_entry(fam, &cache->c_items, ce_list) {
+               if (fam->gf_id == id) {
+                       nl_object_get((struct nl_object *) fam);
+                       return fam;
+               }
+       }
+
+       return NULL;
+}
+
+/**
+ * @name Resolver
+ * @{
+ */
+
+/**
+ * Look up generic netlink family by family name in the provided cache.
+ * @arg cache          Generic netlink family cache.
+ * @arg name           Family name.
+ *
+ * Searches through the cache looking for a registered family
+ * matching the specified name. The caller will own a reference
+ * on the returned object which needs to be given back after
+ * usage using genl_family_put().
+ *
+ * @return Generic netlink family object or NULL if no match was found.
+ */
+struct genl_family *genl_ctrl_search_by_name(struct nl_cache *cache,
+                                           const char *name)
+{
+       struct genl_family *fam;
+
+       if (cache->c_ops != &genl_ctrl_ops)
+               BUG();
+
+       nl_list_for_each_entry(fam, &cache->c_items, ce_list) {
+               if (!strcmp(name, fam->gf_name)) {
+                       nl_object_get((struct nl_object *) fam);
+                       return fam;
+               }
+       }
+
+       return NULL;
+}
+
+/** @} */
+
+/**
+ * Resolve generic netlink family name to its identifier
+ * @arg sk             Netlink socket.
+ * @arg name           Name of generic netlink family
+ *
+ * Resolves the generic netlink family name to its identifer and returns
+ * it.
+ *
+ * @return A positive identifier or a negative error code.
+ */
+int genl_ctrl_resolve(struct nl_sock *sk, const char *name)
+{
+       struct nl_cache *cache;
+       struct genl_family *family;
+       int err;
+
+       if ((err = genl_ctrl_alloc_cache(sk, &cache)) < 0)
+               return err;
+
+       family = genl_ctrl_search_by_name(cache, name);
+       if (family == NULL) {
+               err = -NLE_OBJ_NOTFOUND;
+               goto errout;
+       }
+
+       err = genl_family_get_id(family);
+       genl_family_put(family);
+errout:
+       nl_cache_free(cache);
+
+       return err;
+}
+
+/** @} */
+
+static struct genl_cmd genl_cmds[] = {
+       {
+               .c_id           = CTRL_CMD_NEWFAMILY,
+               .c_name         = "NEWFAMILY" ,
+               .c_maxattr      = CTRL_ATTR_MAX,
+               .c_attr_policy  = ctrl_policy,
+               .c_msg_parser   = ctrl_msg_parser,
+       },
+       {
+               .c_id           = CTRL_CMD_DELFAMILY,
+               .c_name         = "DELFAMILY" ,
+       },
+       {
+               .c_id           = CTRL_CMD_GETFAMILY,
+               .c_name         = "GETFAMILY" ,
+       },
+       {
+               .c_id           = CTRL_CMD_NEWOPS,
+               .c_name         = "NEWOPS" ,
+       },
+       {
+               .c_id           = CTRL_CMD_DELOPS,
+               .c_name         = "DELOPS" ,
+       },
+};
+
+static struct genl_ops genl_ops = {
+       .o_cmds                 = genl_cmds,
+       .o_ncmds                = ARRAY_SIZE(genl_cmds),
+};
+
+/** @cond SKIP */
+extern struct nl_object_ops genl_family_ops;
+/** @endcond */
+
+static struct nl_cache_ops genl_ctrl_ops = {
+       .co_name                = "genl/family",
+       .co_hdrsize             = GENL_HDRSIZE(0),
+       .co_msgtypes            = GENL_FAMILY(GENL_ID_CTRL, "nlctrl"),
+       .co_genl                = &genl_ops,
+       .co_protocol            = NETLINK_GENERIC,
+       .co_request_update      = ctrl_request_update,
+       .co_obj_ops             = &genl_family_ops,
+};
+
+static void __init ctrl_init(void)
+{
+       genl_register(&genl_ctrl_ops);
+}
+
+static void __exit ctrl_exit(void)
+{
+       genl_unregister(&genl_ctrl_ops);
+}
+
+/** @} */
diff --git a/package/libnl-tiny/src/genl_family.c b/package/libnl-tiny/src/genl_family.c
new file mode 100644 (file)
index 0000000..88aaad9
--- /dev/null
@@ -0,0 +1,136 @@
+/*
+ * lib/genl/family.c           Generic Netlink Family
+ *
+ *     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 genl
+ * @defgroup genl_family Generic Netlink Family
+ * @brief
+ *
+ * @{
+ */
+
+#include <netlink-generic.h>
+#include <netlink/netlink.h>
+#include <netlink/genl/genl.h>
+#include <netlink/genl/family.h>
+#include <netlink/utils.h>
+
+struct nl_object_ops genl_family_ops;
+/** @endcond */
+
+static void family_constructor(struct nl_object *c)
+{
+       struct genl_family *family = (struct genl_family *) c;
+
+       nl_init_list_head(&family->gf_ops);
+}
+
+static void family_free_data(struct nl_object *c)
+{
+       struct genl_family *family = (struct genl_family *) c;
+       struct genl_family_op *ops, *tmp;
+
+       if (family == NULL)
+               return;
+
+       nl_list_for_each_entry_safe(ops, tmp, &family->gf_ops, o_list) {
+               nl_list_del(&ops->o_list);
+               free(ops);
+       }
+}
+
+static int family_clone(struct nl_object *_dst, struct nl_object *_src)
+{
+       struct genl_family *dst = nl_object_priv(_dst);
+       struct genl_family *src = nl_object_priv(_src);
+       struct genl_family_op *ops;
+       int err;
+
+       nl_list_for_each_entry(ops, &src->gf_ops, o_list) {
+               err = genl_family_add_op(dst, ops->o_id, ops->o_flags);
+               if (err < 0)
+                       return err;
+       }
+       
+       return 0;
+}
+
+static int family_compare(struct nl_object *_a, struct nl_object *_b,
+                         uint32_t attrs, int flags)
+{
+       struct genl_family *a = (struct genl_family *) _a;
+       struct genl_family *b = (struct genl_family *) _b;
+       int diff = 0;
+
+#define FAM_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, FAMILY_ATTR_##ATTR, a, b, EXPR)
+
+       diff |= FAM_DIFF(ID,            a->gf_id != b->gf_id);
+       diff |= FAM_DIFF(VERSION,       a->gf_version != b->gf_version);
+       diff |= FAM_DIFF(HDRSIZE,       a->gf_hdrsize != b->gf_hdrsize);
+       diff |= FAM_DIFF(MAXATTR,       a->gf_maxattr != b->gf_maxattr);
+       diff |= FAM_DIFF(NAME,          strcmp(a->gf_name, b->gf_name));
+
+#undef FAM_DIFF
+
+       return diff;
+}
+
+
+/**
+ * @name Family Object
+ * @{
+ */
+
+struct genl_family *genl_family_alloc(void)
+{
+       return (struct genl_family *) nl_object_alloc(&genl_family_ops);
+}
+
+void genl_family_put(struct genl_family *family)
+{
+       nl_object_put((struct nl_object *) family);
+}
+
+/** @} */
+
+
+int genl_family_add_op(struct genl_family *family, int id, int flags)
+{
+       struct genl_family_op *op;
+
+       op = calloc(1, sizeof(*op));
+       if (op == NULL)
+               return -NLE_NOMEM;
+
+       op->o_id = id;
+       op->o_flags = flags;
+
+       nl_list_add_tail(&op->o_list, &family->gf_ops);
+       family->ce_mask |= FAMILY_ATTR_OPS;
+
+       return 0;
+}
+
+/** @} */
+
+/** @cond SKIP */
+struct nl_object_ops genl_family_ops = {
+       .oo_name                = "genl/family",
+       .oo_size                = sizeof(struct genl_family),
+       .oo_constructor         = family_constructor,
+       .oo_free_data           = family_free_data,
+       .oo_clone               = family_clone,
+       .oo_compare             = family_compare,
+       .oo_id_attrs            = FAMILY_ATTR_ID,
+};
+/** @endcond */
+
+/** @} */
diff --git a/package/libnl-tiny/src/genl_mngt.c b/package/libnl-tiny/src/genl_mngt.c
new file mode 100644 (file)
index 0000000..5df9a6e
--- /dev/null
@@ -0,0 +1,273 @@
+/*
+ * lib/genl/mngt.c             Generic Netlink Management
+ *
+ *     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 genl
+ * @defgroup genl_mngt Management
+ *
+ * @par 1) Registering a generic netlink module
+ * @code
+ * #include <netlink/genl/mngt.h>
+ *
+ * // First step is to define all the commands being used in
+ * // particular generic netlink family. The ID and name are
+ * // mandatory to be filled out. A callback function and
+ * // most the attribute policy that comes with it must be
+ * // defined for commands expected to be issued towards
+ * // userspace.
+ * static struct genl_cmd foo_cmds[] = {
+ *     {
+ *             .c_id           = FOO_CMD_NEW,
+ *             .c_name         = "NEWFOO" ,
+ *             .c_maxattr      = FOO_ATTR_MAX,
+ *             .c_attr_policy  = foo_policy,
+ *             .c_msg_parser   = foo_msg_parser,
+ *     },
+ *     {
+ *             .c_id           = FOO_CMD_DEL,
+ *             .c_name         = "DELFOO" ,
+ *     },
+ * };
+ *
+ * // The list of commands must then be integrated into a
+ * // struct genl_ops serving as handle for this particular
+ * // family.
+ * static struct genl_ops my_genl_ops = {
+ *     .o_cmds                 = foo_cmds,
+ *     .o_ncmds                = ARRAY_SIZE(foo_cmds),
+ * };
+ *
+ * // Using the above struct genl_ops an arbitary number of
+ * // cache handles can be associated to it.
+ * //
+ * // The macro GENL_HDRSIZE() must be used to specify the
+ * // length of the header to automatically take headers on
+ * // generic layers into account.
+ * //
+ * // The macro GENL_FAMILY() is used to represent the generic
+ * // netlink family id.
+ * static struct nl_cache_ops genl_foo_ops = {
+ *     .co_name                = "genl/foo",
+ *     .co_hdrsize             = GENL_HDRSIZE(sizeof(struct my_hdr)),
+ *     .co_msgtypes            = GENL_FAMILY(GENL_ID_GENERATE, "foo"),
+ *     .co_genl                = &my_genl_ops,
+ *     .co_protocol            = NETLINK_GENERIC,
+ *     .co_request_update      = foo_request_update,
+ *     .co_obj_ops             = &genl_foo_ops,
+ * };
+ *
+ * // Finally each cache handle for a generic netlink family
+ * // must be registered using genl_register().
+ * static void __init foo_init(void)
+ * {
+ *     genl_register(&genl_foo_ops);
+ * }
+ *
+ * // ... respectively unregsted again.
+ * static void __exit foo_exit(void)
+ * {
+ *     genl_unregister(&genl_foo_ops);
+ * }
+ * @endcode
+ * @{
+ */
+
+#include <netlink-generic.h>
+#include <netlink/netlink.h>
+#include <netlink/genl/genl.h>
+#include <netlink/genl/mngt.h>
+#include <netlink/genl/family.h>
+#include <netlink/genl/ctrl.h>
+#include <netlink/utils.h>
+
+static NL_LIST_HEAD(genl_ops_list);
+
+static int genl_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
+                          struct nlmsghdr *nlh, struct nl_parser_param *pp)
+{
+       int i, err;
+       struct genlmsghdr *ghdr;
+       struct genl_cmd *cmd;
+
+       ghdr = nlmsg_data(nlh);
+
+       if (ops->co_genl == NULL)
+               BUG();
+
+       for (i = 0; i < ops->co_genl->o_ncmds; i++) {
+               cmd = &ops->co_genl->o_cmds[i];
+               if (cmd->c_id == ghdr->cmd)
+                       goto found;
+       }
+
+       err = -NLE_MSGTYPE_NOSUPPORT;
+       goto errout;
+
+found:
+       if (cmd->c_msg_parser == NULL)
+               err = -NLE_OPNOTSUPP;
+       else {
+               struct nlattr *tb[cmd->c_maxattr + 1];
+               struct genl_info info = {
+                       .who = who,
+                       .nlh = nlh,
+                       .genlhdr = ghdr,
+                       .userhdr = genlmsg_data(ghdr),
+                       .attrs = tb,
+               };
+
+               err = nlmsg_parse(nlh, ops->co_hdrsize, tb, cmd->c_maxattr,
+                                 cmd->c_attr_policy);
+               if (err < 0)
+                       goto errout;
+
+               err = cmd->c_msg_parser(ops, cmd, &info, pp);
+       }
+errout:
+       return err;
+
+}
+
+char *genl_op2name(int family, int op, char *buf, size_t len)
+{
+       struct genl_ops *ops;
+       int i;
+
+       nl_list_for_each_entry(ops, &genl_ops_list, o_list) {
+               if (ops->o_family == family) {
+                       for (i = 0; i < ops->o_ncmds; i++) {
+                               struct genl_cmd *cmd;
+                               cmd = &ops->o_cmds[i];
+
+                               if (cmd->c_id == op) {
+                                       strncpy(buf, cmd->c_name, len - 1);
+                                       return buf;
+                               }
+                       }
+               }
+       }
+
+       strncpy(buf, "unknown", len - 1);
+       return NULL;
+}
+
+
+/**
+ * @name Register/Unregister
+ * @{
+ */
+
+/**
+ * Register generic netlink operations
+ * @arg ops            cache operations
+ */
+int genl_register(struct nl_cache_ops *ops)
+{
+       int err;
+
+       if (ops->co_protocol != NETLINK_GENERIC) {
+               err = -NLE_PROTO_MISMATCH;
+               goto errout;
+       }
+
+       if (ops->co_hdrsize < GENL_HDRSIZE(0)) {
+               err = -NLE_INVAL;
+               goto errout;
+       }
+
+       if (ops->co_genl == NULL) {
+               err = -NLE_INVAL;
+               goto errout;
+       }
+
+       ops->co_genl->o_cache_ops = ops;
+       ops->co_genl->o_name = ops->co_msgtypes[0].mt_name;
+       ops->co_genl->o_family = ops->co_msgtypes[0].mt_id;
+       ops->co_msg_parser = genl_msg_parser;
+
+       /* FIXME: check for dup */
+
+       nl_list_add_tail(&ops->co_genl->o_list, &genl_ops_list);
+
+       err = nl_cache_mngt_register(ops);
+errout:
+       return err;
+}
+
+/**
+ * Unregister generic netlink operations
+ * @arg ops            cache operations
+ */
+void genl_unregister(struct nl_cache_ops *ops)
+{
+       nl_cache_mngt_unregister(ops);
+       nl_list_del(&ops->co_genl->o_list);
+}
+
+/** @} */
+
+/**
+ * @name Resolving ID/Name
+ * @{
+ */
+#ifdef disabled
+static int __genl_ops_resolve(struct nl_cache *ctrl, struct genl_ops *ops)
+{
+       struct genl_family *family;
+
+       family = genl_ctrl_search_by_name(ctrl, ops->o_name);
+       if (family != NULL) {
+               ops->o_id = genl_family_get_id(family);
+               genl_family_put(family);
+
+               return 0;
+       }
+
+       return -NLE_OBJ_NOTFOUND;
+}
+
+int genl_ops_resolve(struct nl_sock *sk, struct genl_ops *ops)
+{
+       struct nl_cache *ctrl;
+       int err;
+
+       if ((err = genl_ctrl_alloc_cache(sk, &ctrl)) < 0)
+               goto errout;
+
+       err = __genl_ops_resolve(ctrl, ops);
+
+       nl_cache_free(ctrl);
+errout:
+       return err;
+}
+
+int genl_mngt_resolve(struct nl_sock *sk)
+{
+       struct nl_cache *ctrl;
+       struct genl_ops *ops;
+       int err = 0;
+
+       if ((err = genl_ctrl_alloc_cache(sk, &ctrl)) < 0)
+               goto errout;
+
+       nl_list_for_each_entry(ops, &genl_ops_list, o_list) {
+               err = __genl_ops_resolve(ctrl, ops);
+       }
+
+       nl_cache_free(ctrl);
+errout:
+       return err;
+}
+#endif
+/** @} */
+
+
+/** @} */
diff --git a/package/libnl-tiny/src/handlers.c b/package/libnl-tiny/src/handlers.c
new file mode 100644 (file)
index 0000000..12ebda5
--- /dev/null
@@ -0,0 +1,162 @@
+/*
+ * lib/handlers.c      default netlink message handlers
+ *
+ *     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 core
+ * @defgroup cb Callbacks/Customization
+ *
+ * @details
+ * @par 1) Setting up a callback set
+ * @code
+ * // Allocate a callback set and initialize it to the verbose default set
+ * struct nl_cb *cb = nl_cb_alloc(NL_CB_VERBOSE);
+ *
+ * // Modify the set to call my_func() for all valid messages
+ * nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, my_func, NULL);
+ *
+ * // Set the error message handler to the verbose default implementation
+ * // and direct it to print all errors to the given file descriptor.
+ * FILE *file = fopen(...);
+ * nl_cb_err(cb, NL_CB_VERBOSE, NULL, file);
+ * @endcode
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/utils.h>
+#include <netlink/msg.h>
+#include <netlink/handlers.h>
+
+/**
+ * @name Callback Handle Management
+ * @{
+ */
+
+/**
+ * Allocate a new callback handle
+ * @arg kind           callback kind to be used for initialization
+ * @return Newly allocated callback handle or NULL
+ */
+struct nl_cb *nl_cb_alloc(enum nl_cb_kind kind)
+{
+       int i;
+       struct nl_cb *cb;
+
+       if (kind < 0 || kind > NL_CB_KIND_MAX)
+               return NULL;
+
+       cb = calloc(1, sizeof(*cb));
+       if (!cb)
+               return NULL;
+
+       cb->cb_refcnt = 1;
+
+       for (i = 0; i <= NL_CB_TYPE_MAX; i++)
+               nl_cb_set(cb, i, kind, NULL, NULL);
+
+       nl_cb_err(cb, kind, NULL, NULL);
+
+       return cb;
+}
+
+/**
+ * Clone an existing callback handle
+ * @arg orig           original callback handle
+ * @return Newly allocated callback handle being a duplicate of
+ *         orig or NULL
+ */
+struct nl_cb *nl_cb_clone(struct nl_cb *orig)
+{
+       struct nl_cb *cb;
+       
+       cb = nl_cb_alloc(NL_CB_DEFAULT);
+       if (!cb)
+               return NULL;
+
+       memcpy(cb, orig, sizeof(*orig));
+       cb->cb_refcnt = 1;
+
+       return cb;
+}
+
+void nl_cb_put(struct nl_cb *cb)
+{
+       if (!cb)
+               return;
+
+       cb->cb_refcnt--;
+
+       if (cb->cb_refcnt < 0)
+               BUG();
+
+       if (cb->cb_refcnt <= 0)
+               free(cb);
+}
+
+/** @} */
+
+/**
+ * @name Callback Setup
+ * @{
+ */
+
+/**
+ * Set up a callback 
+ * @arg cb             callback set
+ * @arg type           callback to modify
+ * @arg kind           kind of implementation
+ * @arg func           callback function (NL_CB_CUSTOM)
+ * @arg arg            argument passed to callback
+ *
+ * @return 0 on success or a negative error code
+ */
+int nl_cb_set(struct nl_cb *cb, enum nl_cb_type type, enum nl_cb_kind kind,
+             nl_recvmsg_msg_cb_t func, void *arg)
+{
+       if (type < 0 || type > NL_CB_TYPE_MAX)
+               return -NLE_RANGE;
+
+       if (kind < 0 || kind > NL_CB_KIND_MAX)
+               return -NLE_RANGE;
+
+       if (kind == NL_CB_CUSTOM) {
+               cb->cb_set[type] = func;
+               cb->cb_args[type] = arg;
+       }
+
+       return 0;
+}
+
+/**
+ * Set up an error callback
+ * @arg cb             callback set
+ * @arg kind           kind of callback
+ * @arg func           callback function
+ * @arg arg            argument to be passed to callback function
+ */
+int nl_cb_err(struct nl_cb *cb, enum nl_cb_kind kind,
+             nl_recvmsg_err_cb_t func, void *arg)
+{
+       if (kind < 0 || kind > NL_CB_KIND_MAX)
+               return -NLE_RANGE;
+
+       if (kind == NL_CB_CUSTOM) {
+               cb->cb_err = func;
+               cb->cb_err_arg = arg;
+       }
+
+       return 0;
+}
+
+/** @} */
+
+/** @} */
diff --git a/package/libnl-tiny/src/include/linux/genetlink.h b/package/libnl-tiny/src/include/linux/genetlink.h
new file mode 100644 (file)
index 0000000..b834ef6
--- /dev/null
@@ -0,0 +1,83 @@
+#ifndef __LINUX_GENERIC_NETLINK_H
+#define __LINUX_GENERIC_NETLINK_H
+
+#include <linux/types.h>
+#include <linux/netlink.h>
+
+#define GENL_NAMSIZ    16      /* length of family name */
+
+#define GENL_MIN_ID    NLMSG_MIN_TYPE
+#define GENL_MAX_ID    1023
+
+struct genlmsghdr {
+       __u8    cmd;
+       __u8    version;
+       __u16   reserved;
+};
+
+#define GENL_HDRLEN    NLMSG_ALIGN(sizeof(struct genlmsghdr))
+
+#define GENL_ADMIN_PERM                0x01
+#define GENL_CMD_CAP_DO                0x02
+#define GENL_CMD_CAP_DUMP      0x04
+#define GENL_CMD_CAP_HASPOL    0x08
+
+/*
+ * List of reserved static generic netlink identifiers:
+ */
+#define GENL_ID_GENERATE       0
+#define GENL_ID_CTRL           NLMSG_MIN_TYPE
+
+/**************************************************************************
+ * Controller
+ **************************************************************************/
+
+enum {
+       CTRL_CMD_UNSPEC,
+       CTRL_CMD_NEWFAMILY,
+       CTRL_CMD_DELFAMILY,
+       CTRL_CMD_GETFAMILY,
+       CTRL_CMD_NEWOPS,
+       CTRL_CMD_DELOPS,
+       CTRL_CMD_GETOPS,
+       CTRL_CMD_NEWMCAST_GRP,
+       CTRL_CMD_DELMCAST_GRP,
+       CTRL_CMD_GETMCAST_GRP, /* unused */
+       __CTRL_CMD_MAX,
+};
+
+#define CTRL_CMD_MAX (__CTRL_CMD_MAX - 1)
+
+enum {
+       CTRL_ATTR_UNSPEC,
+       CTRL_ATTR_FAMILY_ID,
+       CTRL_ATTR_FAMILY_NAME,
+       CTRL_ATTR_VERSION,
+       CTRL_ATTR_HDRSIZE,
+       CTRL_ATTR_MAXATTR,
+       CTRL_ATTR_OPS,
+       CTRL_ATTR_MCAST_GROUPS,
+       __CTRL_ATTR_MAX,
+};
+
+#define CTRL_ATTR_MAX (__CTRL_ATTR_MAX - 1)
+
+enum {
+       CTRL_ATTR_OP_UNSPEC,
+       CTRL_ATTR_OP_ID,
+       CTRL_ATTR_OP_FLAGS,
+       __CTRL_ATTR_OP_MAX,
+};
+
+#define CTRL_ATTR_OP_MAX (__CTRL_ATTR_OP_MAX - 1)
+
+enum {
+       CTRL_ATTR_MCAST_GRP_UNSPEC,
+       CTRL_ATTR_MCAST_GRP_NAME,
+       CTRL_ATTR_MCAST_GRP_ID,
+       __CTRL_ATTR_MCAST_GRP_MAX,
+};
+
+#define CTRL_ATTR_MCAST_GRP_MAX (__CTRL_ATTR_MCAST_GRP_MAX - 1)
+
+#endif /* __LINUX_GENERIC_NETLINK_H */
diff --git a/package/libnl-tiny/src/include/linux/if.h b/package/libnl-tiny/src/include/linux/if.h
new file mode 100644 (file)
index 0000000..4c1bcfe
--- /dev/null
@@ -0,0 +1,131 @@
+/*
+ * INET                An implementation of the TCP/IP protocol suite for the LINUX
+ *             operating system.  INET is implemented using the  BSD Socket
+ *             interface as the means of communication with the user level.
+ *
+ *             Global definitions for the INET interface module.
+ *
+ * Version:    @(#)if.h        1.0.2   04/18/93
+ *
+ * Authors:    Original taken from Berkeley UNIX 4.3, (c) UCB 1982-1988
+ *             Ross Biro
+ *             Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *             This program is free software; you can redistribute it and/or
+ *             modify it under the terms of the GNU General Public License
+ *             as published by the Free Software Foundation; either version
+ *             2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_IF_H
+#define _LINUX_IF_H
+
+#include <linux/types.h>               /* for "__kernel_caddr_t" et al */
+
+#define        IFNAMSIZ        16
+
+/* Standard interface flags (netdevice->flags). */
+#define        IFF_UP          0x1             /* interface is up              */
+#define        IFF_BROADCAST   0x2             /* broadcast address valid      */
+#define        IFF_DEBUG       0x4             /* turn on debugging            */
+#define        IFF_LOOPBACK    0x8             /* is a loopback net            */
+#define        IFF_POINTOPOINT 0x10            /* interface is has p-p link    */
+#define        IFF_NOTRAILERS  0x20            /* avoid use of trailers        */
+#define        IFF_RUNNING     0x40            /* interface RFC2863 OPER_UP    */
+#define        IFF_NOARP       0x80            /* no ARP protocol              */
+#define        IFF_PROMISC     0x100           /* receive all packets          */
+#define        IFF_ALLMULTI    0x200           /* receive all multicast packets*/
+
+#define IFF_MASTER     0x400           /* master of a load balancer    */
+#define IFF_SLAVE      0x800           /* slave of a load balancer     */
+
+#define IFF_MULTICAST  0x1000          /* Supports multicast           */
+
+#define IFF_PORTSEL    0x2000          /* can set media type           */
+#define IFF_AUTOMEDIA  0x4000          /* auto media select active     */
+#define IFF_DYNAMIC    0x8000          /* dialup device with changing addresses*/
+
+#define IFF_LOWER_UP   0x10000         /* driver signals L1 up         */
+#define IFF_DORMANT    0x20000         /* driver signals dormant       */
+
+#define IFF_ECHO       0x40000         /* echo sent packets            */
+
+#define IFF_VOLATILE   (IFF_LOOPBACK|IFF_POINTOPOINT|IFF_BROADCAST|IFF_ECHO|\
+               IFF_MASTER|IFF_SLAVE|IFF_RUNNING|IFF_LOWER_UP|IFF_DORMANT)
+
+/* Private (from user) interface flags (netdevice->priv_flags). */
+#define IFF_802_1Q_VLAN 0x1             /* 802.1Q VLAN device.          */
+#define IFF_EBRIDGE    0x2             /* Ethernet bridging device.    */
+#define IFF_SLAVE_INACTIVE     0x4     /* bonding slave not the curr. active */
+#define IFF_MASTER_8023AD      0x8     /* bonding master, 802.3ad.     */
+#define IFF_MASTER_ALB 0x10            /* bonding master, balance-alb. */
+#define IFF_BONDING    0x20            /* bonding master or slave      */
+#define IFF_SLAVE_NEEDARP 0x40         /* need ARPs for validation     */
+#define IFF_ISATAP     0x80            /* ISATAP interface (RFC4214)   */
+
+#define IF_GET_IFACE   0x0001          /* for querying only */
+#define IF_GET_PROTO   0x0002
+
+/* For definitions see hdlc.h */
+#define IF_IFACE_V35   0x1000          /* V.35 serial interface        */
+#define IF_IFACE_V24   0x1001          /* V.24 serial interface        */
+#define IF_IFACE_X21   0x1002          /* X.21 serial interface        */
+#define IF_IFACE_T1    0x1003          /* T1 telco serial interface    */
+#define IF_IFACE_E1    0x1004          /* E1 telco serial interface    */
+#define IF_IFACE_SYNC_SERIAL 0x1005    /* can't be set by software     */
+#define IF_IFACE_X21D   0x1006          /* X.21 Dual Clocking (FarSite) */
+
+/* For definitions see hdlc.h */
+#define IF_PROTO_HDLC  0x2000          /* raw HDLC protocol            */
+#define IF_PROTO_PPP   0x2001          /* PPP protocol                 */
+#define IF_PROTO_CISCO 0x2002          /* Cisco HDLC protocol          */
+#define IF_PROTO_FR    0x2003          /* Frame Relay protocol         */
+#define IF_PROTO_FR_ADD_PVC 0x2004     /*    Create FR PVC             */
+#define IF_PROTO_FR_DEL_PVC 0x2005     /*    Delete FR PVC             */
+#define IF_PROTO_X25   0x2006          /* X.25                         */
+#define IF_PROTO_HDLC_ETH 0x2007       /* raw HDLC, Ethernet emulation */
+#define IF_PROTO_FR_ADD_ETH_PVC 0x2008 /*  Create FR Ethernet-bridged PVC */
+#define IF_PROTO_FR_DEL_ETH_PVC 0x2009 /*  Delete FR Ethernet-bridged PVC */
+#define IF_PROTO_FR_PVC        0x200A          /* for reading PVC status       */
+#define IF_PROTO_FR_ETH_PVC 0x200B
+#define IF_PROTO_RAW    0x200C          /* RAW Socket                   */
+
+/* RFC 2863 operational status */
+enum {
+       IF_OPER_UNKNOWN,
+       IF_OPER_NOTPRESENT,
+       IF_OPER_DOWN,
+       IF_OPER_LOWERLAYERDOWN,
+       IF_OPER_TESTING,
+       IF_OPER_DORMANT,
+       IF_OPER_UP,
+};
+
+/* link modes */
+enum {
+       IF_LINK_MODE_DEFAULT,
+       IF_LINK_MODE_DORMANT,   /* limit upward transition to dormant */
+};
+
+/*
+ *     Device mapping structure. I'd just gone off and designed a 
+ *     beautiful scheme using only loadable modules with arguments
+ *     for driver options and along come the PCMCIA people 8)
+ *
+ *     Ah well. The get() side of this is good for WDSETUP, and it'll
+ *     be handy for debugging things. The set side is fine for now and
+ *     being very small might be worth keeping for clean configuration.
+ */
+
+struct ifmap 
+{
+       unsigned long mem_start;
+       unsigned long mem_end;
+       unsigned short base_addr; 
+       unsigned char irq;
+       unsigned char dma;
+       unsigned char port;
+       /* 3 bytes spare */
+};
+
+
+#endif /* _LINUX_IF_H */
diff --git a/package/libnl-tiny/src/include/linux/if_addr.h b/package/libnl-tiny/src/include/linux/if_addr.h
new file mode 100644 (file)
index 0000000..43f3bed
--- /dev/null
@@ -0,0 +1,62 @@
+#ifndef __LINUX_IF_ADDR_H
+#define __LINUX_IF_ADDR_H
+
+#include <linux/netlink.h>
+
+struct ifaddrmsg
+{
+       __u8            ifa_family;
+       __u8            ifa_prefixlen;  /* The prefix length            */
+       __u8            ifa_flags;      /* Flags                        */
+       __u8            ifa_scope;      /* Address scope                */
+       __u32           ifa_index;      /* Link index                   */
+};
+
+/*
+ * Important comment:
+ * IFA_ADDRESS is prefix address, rather than local interface address.
+ * It makes no difference for normally configured broadcast interfaces,
+ * but for point-to-point IFA_ADDRESS is DESTINATION address,
+ * local address is supplied in IFA_LOCAL attribute.
+ */
+enum
+{
+       IFA_UNSPEC,
+       IFA_ADDRESS,
+       IFA_LOCAL,
+       IFA_LABEL,
+       IFA_BROADCAST,
+       IFA_ANYCAST,
+       IFA_CACHEINFO,
+       IFA_MULTICAST,
+       __IFA_MAX,
+};
+
+#define IFA_MAX (__IFA_MAX - 1)
+
+/* ifa_flags */
+#define IFA_F_SECONDARY                0x01
+#define IFA_F_TEMPORARY                IFA_F_SECONDARY
+
+#define        IFA_F_NODAD             0x02
+#define IFA_F_OPTIMISTIC       0x04
+#define        IFA_F_HOMEADDRESS       0x10
+#define IFA_F_DEPRECATED       0x20
+#define IFA_F_TENTATIVE                0x40
+#define IFA_F_PERMANENT                0x80
+
+struct ifa_cacheinfo
+{
+       __u32   ifa_prefered;
+       __u32   ifa_valid;
+       __u32   cstamp; /* created timestamp, hundredths of seconds */
+       __u32   tstamp; /* updated timestamp, hundredths of seconds */
+};
+
+/* backwards compatibility for userspace */
+#ifndef __KERNEL__
+#define IFA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))))
+#define IFA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ifaddrmsg))
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/linux/netlink.h b/package/libnl-tiny/src/include/linux/netlink.h
new file mode 100644 (file)
index 0000000..d252103
--- /dev/null
@@ -0,0 +1,150 @@
+#ifndef __LINUX_NETLINK_H
+#define __LINUX_NETLINK_H
+
+#include <linux/socket.h> /* for sa_family_t */
+#include <linux/types.h>
+
+#define NETLINK_ROUTE          0       /* Routing/device hook                          */
+#define NETLINK_UNUSED         1       /* Unused number                                */
+#define NETLINK_USERSOCK       2       /* Reserved for user mode socket protocols      */
+#define NETLINK_FIREWALL       3       /* Firewalling hook                             */
+#define NETLINK_INET_DIAG      4       /* INET socket monitoring                       */
+#define NETLINK_NFLOG          5       /* netfilter/iptables ULOG */
+#define NETLINK_XFRM           6       /* ipsec */
+#define NETLINK_SELINUX                7       /* SELinux event notifications */
+#define NETLINK_ISCSI          8       /* Open-iSCSI */
+#define NETLINK_AUDIT          9       /* auditing */
+#define NETLINK_FIB_LOOKUP     10      
+#define NETLINK_CONNECTOR      11
+#define NETLINK_NETFILTER      12      /* netfilter subsystem */
+#define NETLINK_IP6_FW         13
+#define NETLINK_DNRTMSG                14      /* DECnet routing messages */
+#define NETLINK_KOBJECT_UEVENT 15      /* Kernel messages to userspace */
+#define NETLINK_GENERIC                16
+/* leave room for NETLINK_DM (DM Events) */
+#define NETLINK_SCSITRANSPORT  18      /* SCSI Transports */
+#define NETLINK_ECRYPTFS       19
+
+#define MAX_LINKS 32           
+
+struct sockaddr_nl
+{
+       sa_family_t     nl_family;      /* AF_NETLINK   */
+       unsigned short  nl_pad;         /* zero         */
+       __u32           nl_pid;         /* port ID      */
+               __u32           nl_groups;      /* multicast groups mask */
+};
+
+struct nlmsghdr
+{
+       __u32           nlmsg_len;      /* Length of message including header */
+       __u16           nlmsg_type;     /* Message content */
+       __u16           nlmsg_flags;    /* Additional flags */
+       __u32           nlmsg_seq;      /* Sequence number */
+       __u32           nlmsg_pid;      /* Sending process port ID */
+};
+
+/* Flags values */
+
+#define NLM_F_REQUEST          1       /* It is request message.       */
+#define NLM_F_MULTI            2       /* Multipart message, terminated by NLMSG_DONE */
+#define NLM_F_ACK              4       /* Reply with ack, with zero or error code */
+#define NLM_F_ECHO             8       /* Echo this request            */
+
+/* Modifiers to GET request */
+#define NLM_F_ROOT     0x100   /* specify tree root    */
+#define NLM_F_MATCH    0x200   /* return all matching  */
+#define NLM_F_ATOMIC   0x400   /* atomic GET           */
+#define NLM_F_DUMP     (NLM_F_ROOT|NLM_F_MATCH)
+
+/* Modifiers to NEW request */
+#define NLM_F_REPLACE  0x100   /* Override existing            */
+#define NLM_F_EXCL     0x200   /* Do not touch, if it exists   */
+#define NLM_F_CREATE   0x400   /* Create, if it does not exist */
+#define NLM_F_APPEND   0x800   /* Add to end of list           */
+
+/*
+   4.4BSD ADD          NLM_F_CREATE|NLM_F_EXCL
+   4.4BSD CHANGE       NLM_F_REPLACE
+
+   True CHANGE         NLM_F_CREATE|NLM_F_REPLACE
+   Append              NLM_F_CREATE
+   Check               NLM_F_EXCL
+ */
+
+#define NLMSG_ALIGNTO  4
+#define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )
+#define NLMSG_HDRLEN    ((int) NLMSG_ALIGN(sizeof(struct nlmsghdr)))
+#define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(NLMSG_HDRLEN))
+#define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len))
+#define NLMSG_DATA(nlh)  ((void*)(((char*)nlh) + NLMSG_LENGTH(0)))
+#define NLMSG_NEXT(nlh,len)     ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
+                                 (struct nlmsghdr*)(((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))
+#define NLMSG_OK(nlh,len) ((len) >= (int)sizeof(struct nlmsghdr) && \
+                          (nlh)->nlmsg_len >= sizeof(struct nlmsghdr) && \
+                          (nlh)->nlmsg_len <= (len))
+#define NLMSG_PAYLOAD(nlh,len) ((nlh)->nlmsg_len - NLMSG_SPACE((len)))
+
+#define NLMSG_NOOP             0x1     /* Nothing.             */
+#define NLMSG_ERROR            0x2     /* Error                */
+#define NLMSG_DONE             0x3     /* End of a dump        */
+#define NLMSG_OVERRUN          0x4     /* Data lost            */
+
+#define NLMSG_MIN_TYPE         0x10    /* < 0x10: reserved control messages */
+
+struct nlmsgerr
+{
+       int             error;
+       struct nlmsghdr msg;
+};
+
+#define NETLINK_ADD_MEMBERSHIP 1
+#define NETLINK_DROP_MEMBERSHIP        2
+#define NETLINK_PKTINFO                3
+
+struct nl_pktinfo
+{
+       __u32   group;
+};
+
+#define NET_MAJOR 36           /* Major 36 is reserved for networking                                          */
+
+enum {
+       NETLINK_UNCONNECTED = 0,
+       NETLINK_CONNECTED,
+};
+
+/*
+ *  <------- NLA_HDRLEN ------> <-- NLA_ALIGN(payload)-->
+ * +---------------------+- - -+- - - - - - - - - -+- - -+
+ * |        Header       | Pad |     Payload       | Pad |
+ * |   (struct nlattr)   | ing |                   | ing |
+ * +---------------------+- - -+- - - - - - - - - -+- - -+
+ *  <-------------- nlattr->nla_len -------------->
+ */
+
+struct nlattr
+{
+       __u16           nla_len;
+       __u16           nla_type;
+};
+
+/*
+ * nla_type (16 bits)
+ * +---+---+-------------------------------+
+ * | N | O | Attribute Type                |
+ * +---+---+-------------------------------+
+ * N := Carries nested attributes
+ * O := Payload stored in network byte order
+ *
+ * Note: The N and O flag are mutually exclusive.
+ */
+#define NLA_F_NESTED           (1 << 15)
+#define NLA_F_NET_BYTEORDER    (1 << 14)
+#define NLA_TYPE_MASK          ~(NLA_F_NESTED | NLA_F_NET_BYTEORDER)
+
+#define NLA_ALIGNTO            4
+#define NLA_ALIGN(len)         (((len) + NLA_ALIGNTO - 1) & ~(NLA_ALIGNTO - 1))
+#define NLA_HDRLEN             ((int) NLA_ALIGN(sizeof(struct nlattr)))
+
+#endif /* __LINUX_NETLINK_H */
diff --git a/package/libnl-tiny/src/include/netlink-generic.h b/package/libnl-tiny/src/include/netlink-generic.h
new file mode 100644 (file)
index 0000000..10aa2f0
--- /dev/null
@@ -0,0 +1,20 @@
+/*
+ * netlink-generic.h   Local Generic Netlink 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-2006 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef NETLINK_GENL_PRIV_H_
+#define NETLINK_GENL_PRIV_H_
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+
+#define GENL_HDRSIZE(hdrlen) (GENL_HDRLEN + (hdrlen))
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink-local.h b/package/libnl-tiny/src/include/netlink-local.h
new file mode 100644 (file)
index 0000000..a2000fa
--- /dev/null
@@ -0,0 +1,154 @@
+/*
+ * netlink-local.h             Local Netlink 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_LOCAL_H_
+#define NETLINK_LOCAL_H_
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <math.h>
+#include <time.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <inttypes.h>
+#include <assert.h>
+#include <limits.h>
+
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#ifndef SOL_NETLINK
+#define SOL_NETLINK 270
+#endif
+
+#include <linux/types.h>
+
+/* local header copies */
+#include <linux/if.h>
+#include <linux/if_arp.h>
+#include <linux/if_ether.h>
+#include <linux/pkt_sched.h>
+#include <linux/pkt_cls.h>
+#include <linux/gen_stats.h>
+
+#include <netlink/netlink.h>
+#include <netlink/handlers.h>
+#include <netlink/cache.h>
+#include <netlink/object-api.h>
+#include <netlink/cache-api.h>
+#include <netlink-types.h>
+
+struct trans_tbl {
+       int i;
+       const char *a;
+};
+
+#define __ADD(id, name) { .i = id, .a = #name },
+
+struct trans_list {
+       int i;
+       char *a;
+       struct nl_list_head list;
+};
+
+#define NL_DEBUG       1
+
+#define NL_DBG(LVL,FMT,ARG...) \
+       do {} while (0)
+
+#define BUG()                            \
+       do {                                 \
+               fprintf(stderr, "BUG: %s:%d\n",  \
+                       __FILE__, __LINE__);         \
+               assert(0);      \
+       } while (0)
+
+extern int __nl_read_num_str_file(const char *path,
+                                 int (*cb)(long, const char *));
+
+extern int __trans_list_add(int, const char *, struct nl_list_head *);
+extern void __trans_list_clear(struct nl_list_head *);
+
+extern char *__type2str(int, char *, size_t, struct trans_tbl *, size_t);
+extern int __str2type(const char *, struct trans_tbl *, size_t);
+
+extern char *__list_type2str(int, char *, size_t, struct nl_list_head *);
+extern int __list_str2type(const char *, struct nl_list_head *);
+
+extern char *__flags2str(int, char *, size_t, struct trans_tbl *, size_t);
+extern int __str2flags(const char *, struct trans_tbl *, size_t);
+
+extern void dump_from_ops(struct nl_object *, struct nl_dump_params *);
+
+static inline struct nl_cache *dp_cache(struct nl_object *obj)
+{
+       if (obj->ce_cache == NULL)
+               return nl_cache_mngt_require(obj->ce_ops->oo_name);
+
+       return obj->ce_cache;
+}
+
+static inline int nl_cb_call(struct nl_cb *cb, int type, struct nl_msg *msg)
+{
+       return cb->cb_set[type](msg, cb->cb_args[type]);
+}
+
+#define ARRAY_SIZE(X) (sizeof(X) / sizeof((X)[0]))
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+
+#define __init __attribute__ ((constructor))
+#define __exit __attribute__ ((destructor))
+#undef __deprecated
+#define __deprecated __attribute__ ((deprecated))
+
+#define min(x,y) ({ \
+       typeof(x) _x = (x);     \
+       typeof(y) _y = (y);     \
+       (void) (&_x == &_y);            \
+       _x < _y ? _x : _y; })
+
+#define max(x,y) ({ \
+       typeof(x) _x = (x);     \
+       typeof(y) _y = (y);     \
+       (void) (&_x == &_y);            \
+       _x > _y ? _x : _y; })
+
+extern int nl_cache_parse(struct nl_cache_ops *, struct sockaddr_nl *,
+                         struct nlmsghdr *, struct nl_parser_param *);
+
+
+static inline char *nl_cache_name(struct nl_cache *cache)
+{
+       return cache->c_ops ? cache->c_ops->co_name : "unknown";
+}
+
+#define GENL_FAMILY(id, name) \
+       { \
+               { id, NL_ACT_UNSPEC, name }, \
+               END_OF_MSGTYPES_LIST, \
+       }
+
+static inline int wait_for_ack(struct nl_sock *sk)
+{
+       if (sk->s_flags & NL_NO_AUTO_ACK)
+               return 0;
+       else
+               return nl_wait_for_ack(sk);
+}
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink-types.h b/package/libnl-tiny/src/include/netlink-types.h
new file mode 100644 (file)
index 0000000..0d00593
--- /dev/null
@@ -0,0 +1,81 @@
+/*
+ * netlink-types.h     Netlink Types (Private)
+ *
+ *     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_LOCAL_TYPES_H_
+#define NETLINK_LOCAL_TYPES_H_
+
+#include <netlink/list.h>
+
+struct nl_cache_ops;
+struct nl_sock;
+struct nl_object;
+
+struct nl_cache
+{
+       struct nl_list_head     c_items;
+       int                     c_nitems;
+       int                     c_iarg1;
+       int                     c_iarg2;
+       struct nl_cache_ops *   c_ops;
+};
+
+struct nl_cache_assoc
+{
+       struct nl_cache *       ca_cache;
+       change_func_t           ca_change;
+};
+
+struct nl_cache_mngr
+{
+       int                     cm_protocol;
+       int                     cm_flags;
+       int                     cm_nassocs;
+       struct nl_sock *        cm_handle;
+       struct nl_cache_assoc * cm_assocs;
+};
+
+struct nl_parser_param;
+
+#define LOOSE_COMPARISON       1
+
+
+struct nl_data
+{
+       size_t                  d_size;
+       void *                  d_data;
+};
+
+struct nl_addr
+{
+       int                     a_family;
+       unsigned int            a_maxsize;
+       unsigned int            a_len;
+       int                     a_prefixlen;
+       int                     a_refcnt;
+       char                    a_addr[0];
+};
+
+#define IFQDISCSIZ     32
+
+#define GENL_OP_HAS_POLICY     1
+#define GENL_OP_HAS_DOIT       2
+#define GENL_OP_HAS_DUMPIT     4
+
+struct genl_family_op
+{
+       uint32_t                o_id;
+       uint32_t                o_flags;
+
+       struct nl_list_head     o_list;
+};
+
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/addr.h b/package/libnl-tiny/src/include/netlink/addr.h
new file mode 100644 (file)
index 0000000..cc3d201
--- /dev/null
@@ -0,0 +1,69 @@
+/*
+ * netlink/addr.h              Abstract Address
+ *
+ *     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_ADDR_H_
+#define NETLINK_ADDR_H_
+
+#include <netlink/netlink.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct nl_addr;
+
+/* Creation */
+extern struct nl_addr *        nl_addr_alloc(size_t);
+extern struct nl_addr *        nl_addr_alloc_attr(struct nlattr *, int);
+extern struct nl_addr *        nl_addr_build(int, void *, size_t);
+extern int             nl_addr_parse(const char *, int, struct nl_addr **);
+extern struct nl_addr *        nl_addr_clone(struct nl_addr *);
+
+/* Destroyage */
+extern void            nl_addr_destroy(struct nl_addr *);
+
+/* Usage Management */
+extern struct nl_addr *        nl_addr_get(struct nl_addr *);
+extern void            nl_addr_put(struct nl_addr *);
+extern int             nl_addr_shared(struct nl_addr *);
+
+extern int             nl_addr_cmp(struct nl_addr *, struct nl_addr *);
+extern int             nl_addr_cmp_prefix(struct nl_addr *, struct nl_addr *);
+extern int             nl_addr_iszero(struct nl_addr *);
+extern int             nl_addr_valid(char *, int);
+extern int             nl_addr_guess_family(struct nl_addr *);
+extern int             nl_addr_fill_sockaddr(struct nl_addr *,
+                                             struct sockaddr *, socklen_t *);
+extern int             nl_addr_info(struct nl_addr *, struct addrinfo **);
+extern int             nl_addr_resolve(struct nl_addr *addr, char *host, size_t hostlen);
+
+/* Access Functions */
+extern void            nl_addr_set_family(struct nl_addr *, int);
+extern int             nl_addr_get_family(struct nl_addr *);
+extern int             nl_addr_set_binary_addr(struct nl_addr *, void *,
+                                               size_t);
+extern void *          nl_addr_get_binary_addr(struct nl_addr *);
+extern unsigned int    nl_addr_get_len(struct nl_addr *);
+extern void            nl_addr_set_prefixlen(struct nl_addr *, int);
+extern unsigned int    nl_addr_get_prefixlen(struct nl_addr *);
+
+/* Address Family Translations */
+extern char *          nl_af2str(int, char *, size_t);
+extern int             nl_str2af(const char *);
+
+/* Translations to Strings */
+extern char *          nl_addr2str(struct nl_addr *, char *, size_t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/attr.h b/package/libnl-tiny/src/include/netlink/attr.h
new file mode 100644 (file)
index 0000000..7076d67
--- /dev/null
@@ -0,0 +1,726 @@
+/*
+ * netlink/attr.h              Netlink Attributes
+ *
+ *     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_ATTR_H_
+#define NETLINK_ATTR_H_
+
+#include <netlink/netlink.h>
+#include <netlink/object.h>
+#include <netlink/addr.h>
+#include <netlink/data.h>
+#include <netlink/msg.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct nl_msg;
+
+/**
+ * @name Basic Attribute Data Types
+ * @{
+ */
+
+ /**
+  * @ingroup attr
+  * Basic attribute data types
+  *
+  * See \ref attr_datatypes for more details.
+  */
+enum {
+       NLA_UNSPEC,     /**< Unspecified type, binary data chunk */
+       NLA_U8,         /**< 8 bit integer */
+       NLA_U16,        /**< 16 bit integer */
+       NLA_U32,        /**< 32 bit integer */
+       NLA_U64,        /**< 64 bit integer */
+       NLA_STRING,     /**< NUL terminated character string */
+       NLA_FLAG,       /**< Flag */
+       NLA_MSECS,      /**< Micro seconds (64bit) */
+       NLA_NESTED,     /**< Nested attributes */
+       __NLA_TYPE_MAX,
+};
+
+#define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
+
+/** @} */
+
+/**
+ * @ingroup attr
+ * Attribute validation policy.
+ *
+ * See \ref attr_datatypes for more details.
+ */
+struct nla_policy {
+       /** Type of attribute or NLA_UNSPEC */
+       uint16_t        type;
+
+       /** Minimal length of payload required */
+       uint16_t        minlen;
+
+       /** Maximal length of payload allowed */
+       uint16_t        maxlen;
+};
+
+/* Attribute parsing */
+extern int             nla_ok(const struct nlattr *, int);
+extern struct nlattr * nla_next(const struct nlattr *, int *);
+extern int             nla_parse(struct nlattr **, int, struct nlattr *,
+                                 int, struct nla_policy *);
+extern int             nla_validate(struct nlattr *, int, int,
+                                    struct nla_policy *);
+extern struct nlattr * nla_find(struct nlattr *, int, int);
+
+/* Unspecific attribute */
+extern struct nlattr * nla_reserve(struct nl_msg *, int, int);
+extern int             nla_put(struct nl_msg *, int, int, const void *);
+
+/**
+ * nlmsg_find_attr - find a specific attribute in a netlink message
+ * @arg nlh            netlink message header
+ * @arg hdrlen         length of familiy specific header
+ * @arg attrtype       type of attribute to look for
+ *
+ * Returns the first attribute which matches the specified type.
+ */
+static inline struct nlattr *nlmsg_find_attr(struct nlmsghdr *nlh, int hdrlen, int attrtype)
+{
+       return nla_find(nlmsg_attrdata(nlh, hdrlen),
+                       nlmsg_attrlen(nlh, hdrlen), attrtype);
+}
+
+
+/**
+ * Return size of attribute whithout padding.
+ * @arg payload                Payload length of attribute.
+ *
+ * @code
+ *    <-------- nla_attr_size(payload) --------->
+ *   +------------------+- - -+- - - - - - - - - +- - -+
+ *   | Attribute Header | Pad |     Payload      | Pad |
+ *   +------------------+- - -+- - - - - - - - - +- - -+
+ * @endcode
+ *
+ * @return Size of attribute in bytes without padding.
+ */
+static inline int nla_attr_size(int payload)
+{
+       return NLA_HDRLEN + payload;
+}
+
+/**
+ * Return size of attribute including padding.
+ * @arg payload                Payload length of attribute.
+ *
+ * @code
+ *    <----------- nla_total_size(payload) ----------->
+ *   +------------------+- - -+- - - - - - - - - +- - -+
+ *   | Attribute Header | Pad |     Payload      | Pad |
+ *   +------------------+- - -+- - - - - - - - - +- - -+
+ * @endcode
+ *
+ * @return Size of attribute in bytes.
+ */
+static inline int nla_total_size(int payload)
+{
+       return NLA_ALIGN(nla_attr_size(payload));
+}
+
+/**
+ * Return length of padding at the tail of the attribute.
+ * @arg payload                Payload length of attribute.
+ *
+ * @code
+ *   +------------------+- - -+- - - - - - - - - +- - -+
+ *   | Attribute Header | Pad |     Payload      | Pad |
+ *   +------------------+- - -+- - - - - - - - - +- - -+
+ *                                                <--->  
+ * @endcode
+ *
+ * @return Length of padding in bytes.
+ */
+static inline int nla_padlen(int payload)
+{
+       return nla_total_size(payload) - nla_attr_size(payload);
+}
+
+/**
+ * Return type of the attribute.
+ * @arg nla            Attribute.
+ *
+ * @return Type of attribute.
+ */
+static inline int nla_type(const struct nlattr *nla)
+{
+       return nla->nla_type & NLA_TYPE_MASK;
+}
+
+/**
+ * Return pointer to the payload section.
+ * @arg nla            Attribute.
+ *
+ * @return Pointer to start of payload section.
+ */
+static inline void *nla_data(const struct nlattr *nla)
+{
+       return (char *) nla + NLA_HDRLEN;
+}
+
+/**
+ * Return length of the payload .
+ * @arg nla            Attribute
+ *
+ * @return Length of payload in bytes.
+ */
+static inline int nla_len(const struct nlattr *nla)
+{
+       return nla->nla_len - NLA_HDRLEN;
+}
+
+/**
+ * Copy attribute payload to another memory area.
+ * @arg dest           Pointer to destination memory area.
+ * @arg src            Attribute
+ * @arg count          Number of bytes to copy at most.
+ *
+ * Note: The number of bytes copied is limited by the length of
+ *       the attribute payload.
+ *
+ * @return The number of bytes copied to dest.
+ */
+static inline int nla_memcpy(void *dest, struct nlattr *src, int count)
+{
+       int minlen;
+
+       if (!src)
+               return 0;
+       
+       minlen = min_t(int, count, nla_len(src));
+       memcpy(dest, nla_data(src), minlen);
+
+       return minlen;
+}
+
+
+/**
+ * Add abstract data as unspecific attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg data           Abstract data object.
+ *
+ * Equivalent to nla_put() except that the length of the payload is
+ * derived from the abstract data object.
+ *
+ * @see nla_put
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_put_data(struct nl_msg *msg, int attrtype, struct nl_data *data)
+{
+       return nla_put(msg, attrtype, nl_data_get_size(data),
+                      nl_data_get(data));
+}
+
+/**
+ * Add abstract address as unspecific attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg addr           Abstract address object.
+ *
+ * @see nla_put
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_put_addr(struct nl_msg *msg, int attrtype, struct nl_addr *addr)
+{
+       return nla_put(msg, attrtype, nl_addr_get_len(addr),
+                      nl_addr_get_binary_addr(addr));
+}
+
+/** @} */
+
+/**
+ * @name Integer Attributes
+ */
+
+/**
+ * Add 8 bit integer attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg value          Numeric value to store as payload.
+ *
+ * @see nla_put
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_put_u8(struct nl_msg *msg, int attrtype, uint8_t value)
+{
+       return nla_put(msg, attrtype, sizeof(uint8_t), &value);
+}
+
+/**
+ * Return value of 8 bit integer attribute.
+ * @arg nla            8 bit integer attribute
+ *
+ * @return Payload as 8 bit integer.
+ */
+static inline uint8_t nla_get_u8(struct nlattr *nla)
+{
+       return *(uint8_t *) nla_data(nla);
+}
+
+/**
+ * Add 16 bit integer attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg value          Numeric value to store as payload.
+ *
+ * @see nla_put
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_put_u16(struct nl_msg *msg, int attrtype, uint16_t value)
+{
+       return nla_put(msg, attrtype, sizeof(uint16_t), &value);
+}
+
+/**
+ * Return payload of 16 bit integer attribute.
+ * @arg nla            16 bit integer attribute
+ *
+ * @return Payload as 16 bit integer.
+ */
+static inline uint16_t nla_get_u16(struct nlattr *nla)
+{
+       return *(uint16_t *) nla_data(nla);
+}
+
+/**
+ * Add 32 bit integer attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg value          Numeric value to store as payload.
+ *
+ * @see nla_put
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_put_u32(struct nl_msg *msg, int attrtype, uint32_t value)
+{
+       return nla_put(msg, attrtype, sizeof(uint32_t), &value);
+}
+
+/**
+ * Return payload of 32 bit integer attribute.
+ * @arg nla            32 bit integer attribute.
+ *
+ * @return Payload as 32 bit integer.
+ */
+static inline uint32_t nla_get_u32(struct nlattr *nla)
+{
+       return *(uint32_t *) nla_data(nla);
+}
+
+/**
+ * Add 64 bit integer attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg value          Numeric value to store as payload.
+ *
+ * @see nla_put
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_put_u64(struct nl_msg *msg, int attrtype, uint64_t value)
+{
+       return nla_put(msg, attrtype, sizeof(uint64_t), &value);
+}
+
+/**
+ * Return payload of u64 attribute
+ * @arg nla            u64 netlink attribute
+ *
+ * @return Payload as 64 bit integer.
+ */
+static inline uint64_t nla_get_u64(struct nlattr *nla)
+{
+       uint64_t tmp;
+
+       nla_memcpy(&tmp, nla, sizeof(tmp));
+
+       return tmp;
+}
+
+/**
+ * Add string attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg str            NUL terminated string.
+ *
+ * @see nla_put
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_put_string(struct nl_msg *msg, int attrtype, const char *str)
+{
+       return nla_put(msg, attrtype, strlen(str) + 1, str);
+}
+
+/**
+ * Return payload of string attribute.
+ * @arg nla            String attribute.
+ *
+ * @return Pointer to attribute payload.
+ */
+static inline char *nla_get_string(struct nlattr *nla)
+{
+       return (char *) nla_data(nla);
+}
+
+static inline char *nla_strdup(struct nlattr *nla)
+{
+       return strdup(nla_get_string(nla));
+}
+
+/** @} */
+
+/**
+ * @name Flag Attribute
+ */
+
+/**
+ * Add flag netlink attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ *
+ * @see nla_put
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_put_flag(struct nl_msg *msg, int attrtype)
+{
+       return nla_put(msg, attrtype, 0, NULL);
+}
+
+/**
+ * Return true if flag attribute is set.
+ * @arg nla            Flag netlink attribute.
+ *
+ * @return True if flag is set, otherwise false.
+ */
+static inline int nla_get_flag(struct nlattr *nla)
+{
+       return !!nla;
+}
+
+/** @} */
+
+/**
+ * @name Microseconds Attribute
+ */
+
+/**
+ * Add a msecs netlink attribute to a netlink message
+ * @arg n              netlink message
+ * @arg attrtype       attribute type
+ * @arg msecs          number of msecs
+ */
+static inline int nla_put_msecs(struct nl_msg *n, int attrtype, unsigned long msecs)
+{
+       return nla_put_u64(n, attrtype, msecs);
+}
+
+/**
+ * Return payload of msecs attribute
+ * @arg nla            msecs netlink attribute
+ *
+ * @return the number of milliseconds.
+ */
+static inline unsigned long nla_get_msecs(struct nlattr *nla)
+{
+       return nla_get_u64(nla);
+}
+
+/**
+ * Add nested attributes to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg nested         Message containing attributes to be nested.
+ *
+ * Takes the attributes found in the \a nested message and appends them
+ * to the message \a msg nested in a container of the type \a attrtype.
+ * The \a nested message may not have a family specific header.
+ *
+ * @see nla_put
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_put_nested(struct nl_msg *msg, int attrtype, struct nl_msg *nested)
+{
+       return nla_put(msg, attrtype, nlmsg_len(nested->nm_nlh),
+                      nlmsg_data(nested->nm_nlh));
+}
+
+/**
+ * Start a new level of nested attributes.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type of container.
+ *
+ * @return Pointer to container attribute.
+ */
+static inline struct nlattr *nla_nest_start(struct nl_msg *msg, int attrtype)
+{
+       struct nlattr *start = (struct nlattr *) nlmsg_tail(msg->nm_nlh);
+
+       if (nla_put(msg, attrtype, 0, NULL) < 0)
+               return NULL;
+
+       return start;
+}
+
+/**
+ * Finalize nesting of attributes.
+ * @arg msg            Netlink message.
+ * @arg start          Container attribute as returned from nla_nest_start().
+ *
+ * Corrects the container attribute header to include the appeneded attributes.
+ *
+ * @return 0
+ */
+static inline int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
+{
+       start->nla_len = (unsigned char *) nlmsg_tail(msg->nm_nlh) -
+                               (unsigned char *) start;
+       return 0;
+}
+
+/**
+ * Create attribute index based on nested attribute
+ * @arg tb             Index array to be filled (maxtype+1 elements).
+ * @arg maxtype                Maximum attribute type expected and accepted.
+ * @arg nla            Nested Attribute.
+ * @arg policy         Attribute validation policy.
+ *
+ * Feeds the stream of attributes nested into the specified attribute
+ * to nla_parse().
+ *
+ * @see nla_parse
+ * @return 0 on success or a negative error code.
+ */
+static inline int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla,
+                    struct nla_policy *policy)
+{
+       return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
+}
+
+/**
+ * Compare attribute payload with memory area.
+ * @arg nla            Attribute.
+ * @arg data           Memory area to compare to.
+ * @arg size           Number of bytes to compare.
+ *
+ * @see memcmp(3)
+ * @return An integer less than, equal to, or greater than zero.
+ */
+static inline int nla_memcmp(const struct nlattr *nla, const void *data, size_t size)
+{
+       int d = nla_len(nla) - size;
+
+       if (d == 0)
+               d = memcmp(nla_data(nla), data, size);
+
+       return d;
+}
+
+/**
+ * Compare string attribute payload with string
+ * @arg nla            Attribute of type NLA_STRING.
+ * @arg str            NUL terminated string.
+ *
+ * @see strcmp(3)
+ * @return An integer less than, equal to, or greater than zero.
+ */
+static inline int nla_strcmp(const struct nlattr *nla, const char *str)
+{
+       int len = strlen(str) + 1;
+       int d = nla_len(nla) - len;
+
+       if (d == 0)
+               d = memcmp(nla_data(nla), str, len);
+
+       return d;
+}
+
+/**
+ * Copy string attribute payload to a buffer.
+ * @arg dst            Pointer to destination buffer.
+ * @arg nla            Attribute of type NLA_STRING.
+ * @arg dstsize                Size of destination buffer in bytes.
+ *
+ * Copies at most dstsize - 1 bytes to the destination buffer.
+ * The result is always a valid NUL terminated string. Unlike
+ * strlcpy the destination buffer is always padded out.
+ *
+ * @return The length of string attribute without the terminating NUL.
+ */
+static inline size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize)
+{
+       size_t srclen = nla_len(nla);
+       char *src = nla_data(nla);
+
+       if (srclen > 0 && src[srclen - 1] == '\0')
+               srclen--;
+
+       if (dstsize > 0) {
+               size_t len = (srclen >= dstsize) ? dstsize - 1 : srclen;
+
+               memset(dst, 0, dstsize);
+               memcpy(dst, src, len);
+       }
+
+       return srclen;
+}
+
+
+/**
+ * @name Attribute Construction (Exception Based)
+ * @{
+ */
+
+/**
+ * @ingroup attr
+ * Add unspecific attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg attrlen                Length of attribute payload.
+ * @arg data           Head of attribute payload.
+ */
+#define NLA_PUT(msg, attrtype, attrlen, data) \
+       do { \
+               if (nla_put(msg, attrtype, attrlen, data) < 0) \
+                       goto nla_put_failure; \
+       } while(0)
+
+/**
+ * @ingroup attr
+ * Add atomic type attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg type           Atomic type.
+ * @arg attrtype       Attribute type.
+ * @arg value          Head of attribute payload.
+ */
+#define NLA_PUT_TYPE(msg, type, attrtype, value) \
+       do { \
+               type __tmp = value; \
+               NLA_PUT(msg, attrtype, sizeof(type), &__tmp); \
+       } while(0)
+
+/**
+ * Add 8 bit integer attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg value          Numeric value.
+ */
+#define NLA_PUT_U8(msg, attrtype, value) \
+       NLA_PUT_TYPE(msg, uint8_t, attrtype, value)
+
+/**
+ * Add 16 bit integer attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg value          Numeric value.
+ */
+#define NLA_PUT_U16(msg, attrtype, value) \
+       NLA_PUT_TYPE(msg, uint16_t, attrtype, value)
+
+/**
+ * Add 32 bit integer attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg value          Numeric value.
+ */
+#define NLA_PUT_U32(msg, attrtype, value) \
+       NLA_PUT_TYPE(msg, uint32_t, attrtype, value)
+
+/**
+ * Add 64 bit integer attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg value          Numeric value.
+ */
+#define NLA_PUT_U64(msg, attrtype, value) \
+       NLA_PUT_TYPE(msg, uint64_t, attrtype, value)
+
+/**
+ * Add string attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg value          NUL terminated character string.
+ */
+#define NLA_PUT_STRING(msg, attrtype, value) \
+       NLA_PUT(msg, attrtype, strlen(value) + 1, value)
+
+/**
+ * Add flag attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ */
+#define NLA_PUT_FLAG(msg, attrtype) \
+       NLA_PUT(msg, attrtype, 0, NULL)
+
+/**
+ * Add msecs attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg msecs          Numeric value in micro seconds.
+ */
+#define NLA_PUT_MSECS(msg, attrtype, msecs) \
+       NLA_PUT_U64(msg, attrtype, msecs)
+
+/**
+ * Add address attribute to netlink message.
+ * @arg msg            Netlink message.
+ * @arg attrtype       Attribute type.
+ * @arg addr           Abstract address object.
+ */
+#define NLA_PUT_ADDR(msg, attrtype, addr) \
+       NLA_PUT(msg, attrtype, nl_addr_get_len(addr), \
+               nl_addr_get_binary_addr(addr))
+
+/** @} */
+
+/**
+ * @name Iterators
+ * @{
+ */
+
+/**
+ * @ingroup attr
+ * Iterate over a stream of attributes
+ * @arg pos    loop counter, set to current attribute
+ * @arg head   head of attribute stream
+ * @arg len    length of attribute stream
+ * @arg rem    initialized to len, holds bytes currently remaining in stream
+ */
+#define nla_for_each_attr(pos, head, len, rem) \
+       for (pos = head, rem = len; \
+            nla_ok(pos, rem); \
+            pos = nla_next(pos, &(rem)))
+
+/**
+ * @ingroup attr
+ * Iterate over a stream of nested attributes
+ * @arg pos    loop counter, set to current attribute
+ * @arg nla    attribute containing the nested attributes
+ * @arg rem    initialized to len, holds bytes currently remaining in stream
+ */
+#define nla_for_each_nested(pos, nla, rem) \
+       for (pos = nla_data(nla), rem = nla_len(nla); \
+            nla_ok(pos, rem); \
+            pos = nla_next(pos, &(rem)))
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/cache-api.h b/package/libnl-tiny/src/include/netlink/cache-api.h
new file mode 100644 (file)
index 0000000..22fc449
--- /dev/null
@@ -0,0 +1,199 @@
+/*
+ * netlink/cache-api.h         Caching 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-2006 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef NETLINK_CACHE_API_H_
+#define NETLINK_CACHE_API_H_
+
+#include <netlink/netlink.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @ingroup cache
+ * @defgroup cache_api Cache Implementation
+ * @brief
+ *
+ * @par 1) Cache Definition
+ * @code
+ * struct nl_cache_ops my_cache_ops = {
+ *     .co_name                = "route/link",
+ *     .co_protocol            = NETLINK_ROUTE,
+ *     .co_hdrsize             = sizeof(struct ifinfomsg),
+ *     .co_obj_ops             = &my_obj_ops,
+ * };
+ * @endcode
+ *
+ * @par 2) 
+ * @code
+ * // The simplest way to fill a cache is by providing a request-update
+ * // function which must trigger a complete dump on the kernel-side of
+ * // whatever the cache covers.
+ * static int my_request_update(struct nl_cache *cache,
+ *                             struct nl_sock *socket)
+ * {
+ *     // In this example, we request a full dump of the interface table
+ *     return nl_rtgen_request(socket, RTM_GETLINK, AF_UNSPEC, NLM_F_DUMP);
+ * }
+ *
+ * // The resulting netlink messages sent back will be fed into a message
+ * // parser one at a time. The message parser has to extract all relevant
+ * // information from the message and create an object reflecting the
+ * // contents of the message and pass it on to the parser callback function
+ * // provide which will add the object to the cache.
+ * static int my_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
+ *                         struct nlmsghdr *nlh, struct nl_parser_param *pp)
+ * {
+ *     struct my_obj *obj;
+ *
+ *     obj = my_obj_alloc();
+ *     obj->ce_msgtype = nlh->nlmsg_type;
+ *
+ *     // Parse the netlink message and continue creating the object.
+ *
+ *     err = pp->pp_cb((struct nl_object *) obj, pp);
+ *     if (err < 0)
+ *             goto errout;
+ * }
+ *
+ * struct nl_cache_ops my_cache_ops = {
+ *     ...
+ *     .co_request_update      = my_request_update,
+ *     .co_msg_parser          = my_msg_parser,
+ * };
+ * @endcode
+ *
+ * @par 3) Notification based Updates
+ * @code
+ * // Caches can be kept up-to-date based on notifications if the kernel
+ * // sends out notifications whenever an object is added/removed/changed.
+ * //
+ * // It is trivial to support this, first a list of groups needs to be
+ * // defined which are required to join in order to receive all necessary
+ * // notifications. The groups are separated by address family to support
+ * // the common situation where a separate group is used for each address
+ * // family. If there is only one group, simply specify AF_UNSPEC.
+ * static struct nl_af_group addr_groups[] = {
+ *     { AF_INET,      RTNLGRP_IPV4_IFADDR },
+ *     { AF_INET6,     RTNLGRP_IPV6_IFADDR },
+ *     { END_OF_GROUP_LIST },
+ * };
+ *
+ * // In order for the caching system to know the meaning of each message
+ * // type it requires a table which maps each supported message type to
+ * // a cache action, e.g. RTM_NEWADDR means address has been added or
+ * // updated, RTM_DELADDR means address has been removed.
+ * static struct nl_cache_ops rtnl_addr_ops = {
+ *     ...
+ *     .co_msgtypes            = {
+ *                                     { RTM_NEWADDR, NL_ACT_NEW, "new" },
+ *                                     { RTM_DELADDR, NL_ACT_DEL, "del" },
+ *                                     { RTM_GETADDR, NL_ACT_GET, "get" },
+ *                                     END_OF_MSGTYPES_LIST,
+ *                             },
+ *     .co_groups              = addr_groups,
+ * };
+ *
+ * // It is now possible to keep the cache up-to-date using the cache manager.
+ * @endcode
+ * @{
+ */
+
+enum {
+       NL_ACT_UNSPEC,
+       NL_ACT_NEW,
+       NL_ACT_DEL,
+       NL_ACT_GET,
+       NL_ACT_SET,
+       NL_ACT_CHANGE,
+       __NL_ACT_MAX,
+};
+
+#define NL_ACT_MAX (__NL_ACT_MAX - 1)
+
+#define END_OF_MSGTYPES_LIST   { -1, -1, NULL }
+
+/**
+ * Message type to cache action association
+ */
+struct nl_msgtype
+{
+       /** Netlink message type */
+       int                     mt_id;
+
+       /** Cache action to take */
+       int                     mt_act;
+
+       /** Name of operation for human-readable printing */
+       char *                  mt_name;
+};
+
+/**
+ * Address family to netlink group association
+ */
+struct nl_af_group
+{
+       /** Address family */
+       int                     ag_family;
+
+       /** Netlink group identifier */
+       int                     ag_group;
+};
+
+#define END_OF_GROUP_LIST AF_UNSPEC, 0
+
+struct nl_parser_param
+{
+       int             (*pp_cb)(struct nl_object *, struct nl_parser_param *);
+       void *            pp_arg;
+};
+
+/**
+ * Cache Operations
+ */
+struct nl_cache_ops
+{
+       char  *                 co_name;
+
+       int                     co_hdrsize;
+       int                     co_protocol;
+       struct nl_af_group *    co_groups;
+       
+       /**
+        * Called whenever an update of the cache is required. Must send
+        * a request message to the kernel requesting a complete dump.
+        */
+       int   (*co_request_update)(struct nl_cache *, struct nl_sock *);
+
+       /**
+        * Called whenever a message was received that needs to be parsed.
+        * Must parse the message and call the paser callback function
+        * (nl_parser_param) provided via the argument.
+        */
+       int   (*co_msg_parser)(struct nl_cache_ops *, struct sockaddr_nl *,
+                              struct nlmsghdr *, struct nl_parser_param *);
+
+       struct nl_object_ops *  co_obj_ops;
+
+       struct nl_cache_ops *co_next;
+       struct nl_cache *co_major_cache;
+       struct genl_ops *       co_genl;
+       struct nl_msgtype       co_msgtypes[];
+};
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/cache.h b/package/libnl-tiny/src/include/netlink/cache.h
new file mode 100644 (file)
index 0000000..f4db3b9
--- /dev/null
@@ -0,0 +1,126 @@
+/*
+ * netlink/cache.h             Caching Module
+ *
+ *     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_CACHE_H_
+#define NETLINK_CACHE_H_
+
+#include <netlink/netlink.h>
+#include <netlink/msg.h>
+#include <netlink/utils.h>
+#include <netlink/object.h>
+#include <netlink/cache-api.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct nl_cache;
+
+typedef void (*change_func_t)(struct nl_cache *, struct nl_object *, int);
+
+/* Access Functions */
+extern int                     nl_cache_nitems(struct nl_cache *);
+extern int                     nl_cache_nitems_filter(struct nl_cache *,
+                                                      struct nl_object *);
+extern struct nl_cache_ops *   nl_cache_get_ops(struct nl_cache *);
+extern struct nl_object *      nl_cache_get_first(struct nl_cache *);
+extern struct nl_object *      nl_cache_get_last(struct nl_cache *);
+extern struct nl_object *      nl_cache_get_next(struct nl_object *);
+extern struct nl_object *      nl_cache_get_prev(struct nl_object *);
+
+extern struct nl_cache *       nl_cache_alloc(struct nl_cache_ops *);
+extern int                     nl_cache_alloc_and_fill(struct nl_cache_ops *,
+                                                       struct nl_sock *,
+                                                       struct nl_cache **);
+extern int                     nl_cache_alloc_name(const char *,
+                                                   struct nl_cache **);
+extern struct nl_cache *       nl_cache_subset(struct nl_cache *,
+                                               struct nl_object *);
+extern void                    nl_cache_clear(struct nl_cache *);
+extern void                    nl_cache_free(struct nl_cache *);
+
+/* Cache modification */
+extern int                     nl_cache_add(struct nl_cache *,
+                                            struct nl_object *);
+extern int                     nl_cache_parse_and_add(struct nl_cache *,
+                                                      struct nl_msg *);
+extern void                    nl_cache_remove(struct nl_object *);
+extern int                     nl_cache_refill(struct nl_sock *,
+                                               struct nl_cache *);
+extern int                     nl_cache_pickup(struct nl_sock *,
+                                               struct nl_cache *);
+extern int                     nl_cache_resync(struct nl_sock *,
+                                               struct nl_cache *,
+                                               change_func_t);
+extern int                     nl_cache_include(struct nl_cache *,
+                                                struct nl_object *,
+                                                change_func_t);
+
+/* General */
+extern int                     nl_cache_is_empty(struct nl_cache *);
+extern void                    nl_cache_mark_all(struct nl_cache *);
+
+/* Dumping */
+extern void                    nl_cache_dump(struct nl_cache *,
+                                             struct nl_dump_params *);
+extern void                    nl_cache_dump_filter(struct nl_cache *,
+                                                    struct nl_dump_params *,
+                                                    struct nl_object *);
+
+/* Iterators */
+extern void                    nl_cache_foreach(struct nl_cache *,
+                                                void (*cb)(struct nl_object *,
+                                                           void *),
+                                                void *arg);
+extern void                    nl_cache_foreach_filter(struct nl_cache *,
+                                                       struct nl_object *,
+                                                       void (*cb)(struct
+                                                                  nl_object *,
+                                                                  void *),
+                                                       void *arg);
+
+/* --- cache management --- */
+
+/* Cache type management */
+extern struct nl_cache_ops *   nl_cache_ops_lookup(const char *);
+extern struct nl_cache_ops *   nl_cache_ops_associate(int, int);
+extern struct nl_msgtype *     nl_msgtype_lookup(struct nl_cache_ops *, int);
+extern void                    nl_cache_ops_foreach(void (*cb)(struct nl_cache_ops *, void *), void *);
+extern int                     nl_cache_mngt_register(struct nl_cache_ops *);
+extern int                     nl_cache_mngt_unregister(struct nl_cache_ops *);
+
+/* Global cache provisioning/requiring */
+extern void                    nl_cache_mngt_provide(struct nl_cache *);
+extern void                    nl_cache_mngt_unprovide(struct nl_cache *);
+extern struct nl_cache *       nl_cache_mngt_require(const char *);
+
+struct nl_cache_mngr;
+
+#define NL_AUTO_PROVIDE                1
+
+extern int                     nl_cache_mngr_alloc(struct nl_sock *,
+                                                   int, int,
+                                                   struct nl_cache_mngr **);
+extern int                     nl_cache_mngr_add(struct nl_cache_mngr *,
+                                                 const char *,
+                                                 change_func_t,
+                                                 struct nl_cache **);
+extern int                     nl_cache_mngr_get_fd(struct nl_cache_mngr *);
+extern int                     nl_cache_mngr_poll(struct nl_cache_mngr *,
+                                                  int);
+extern int                     nl_cache_mngr_data_ready(struct nl_cache_mngr *);
+extern void                    nl_cache_mngr_free(struct nl_cache_mngr *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/data.h b/package/libnl-tiny/src/include/netlink/data.h
new file mode 100644 (file)
index 0000000..071159e
--- /dev/null
@@ -0,0 +1,41 @@
+/*
+ * netlink/data.h      Abstract Data
+ *
+ *     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_DATA_H_
+#define NETLINK_DATA_H_
+
+#include <netlink/netlink.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct nl_data;
+
+/* General */
+extern struct nl_data *        nl_data_alloc(void *, size_t);
+extern struct nl_data * nl_data_alloc_attr(struct nlattr *);
+extern struct nl_data *        nl_data_clone(struct nl_data *);
+extern int             nl_data_append(struct nl_data *, void *, size_t);
+extern void            nl_data_free(struct nl_data *);
+
+/* Access Functions */
+extern void *          nl_data_get(struct nl_data *);
+extern size_t          nl_data_get_size(struct nl_data *);
+
+/* Misc */
+extern int             nl_data_cmp(struct nl_data *, struct nl_data *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/errno.h b/package/libnl-tiny/src/include/netlink/errno.h
new file mode 100644 (file)
index 0000000..0b43da0
--- /dev/null
@@ -0,0 +1,59 @@
+/*
+ * netlink/errno.h             Error Numbers
+ *
+ *     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) 2008 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef NETLINK_ERRNO_H_
+#define NETLINK_ERRNO_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NLE_SUCCESS            0
+#define NLE_FAILURE            1
+#define NLE_INTR               2
+#define NLE_BAD_SOCK           3
+#define NLE_AGAIN              4
+#define NLE_NOMEM              5
+#define NLE_EXIST              6
+#define NLE_INVAL              7
+#define NLE_RANGE              8
+#define NLE_MSGSIZE            9
+#define NLE_OPNOTSUPP          10
+#define NLE_AF_NOSUPPORT       11
+#define NLE_OBJ_NOTFOUND       12
+#define NLE_NOATTR             13
+#define NLE_MISSING_ATTR       14
+#define NLE_AF_MISMATCH                15
+#define NLE_SEQ_MISMATCH       16
+#define NLE_MSG_OVERFLOW       17
+#define NLE_MSG_TRUNC          18
+#define NLE_NOADDR             19
+#define NLE_SRCRT_NOSUPPORT    20
+#define NLE_MSG_TOOSHORT       21
+#define NLE_MSGTYPE_NOSUPPORT  22
+#define NLE_OBJ_MISMATCH       23
+#define NLE_NOCACHE            24
+#define NLE_BUSY               25
+#define NLE_PROTO_MISMATCH     26
+#define NLE_NOACCESS           27
+#define NLE_PERM               28
+
+#define NLE_MAX                        NLE_PERM
+
+extern const char *    nl_geterror(int);
+extern void            nl_perror(int, const char *);
+extern int             nl_syserr2nlerr(int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/genl/ctrl.h b/package/libnl-tiny/src/include/netlink/genl/ctrl.h
new file mode 100644 (file)
index 0000000..1ae62f4
--- /dev/null
@@ -0,0 +1,37 @@
+/*
+ * netlink/genl/ctrl.h         Generic Netlink Controller
+ *
+ *     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_GENL_CTRL_H_
+#define NETLINK_GENL_CTRL_H_
+
+#include <netlink/netlink.h>
+#include <netlink/cache.h>
+#include <netlink/addr.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct genl_family;
+
+extern int                     genl_ctrl_alloc_cache(struct nl_sock *,
+                                                     struct nl_cache **);
+extern struct genl_family *    genl_ctrl_search(struct nl_cache *, int);
+extern struct genl_family *    genl_ctrl_search_by_name(struct nl_cache *,
+                                                        const char *);
+extern int                     genl_ctrl_resolve(struct nl_sock *,
+                                                 const char *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/genl/family.h b/package/libnl-tiny/src/include/netlink/genl/family.h
new file mode 100644 (file)
index 0000000..0257cbe
--- /dev/null
@@ -0,0 +1,130 @@
+/*
+ * netlink/genl/family.h       Generic Netlink Family
+ *
+ *     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>
+ */
+
+#ifndef NETLINK_GENL_FAMILY_H_
+#define NETLINK_GENL_FAMILY_H_
+
+#include <netlink/netlink.h>
+#include <netlink/cache.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @cond SKIP */
+#define FAMILY_ATTR_ID         0x01
+#define FAMILY_ATTR_NAME       0x02
+#define FAMILY_ATTR_VERSION    0x04
+#define FAMILY_ATTR_HDRSIZE    0x08
+#define FAMILY_ATTR_MAXATTR    0x10
+#define FAMILY_ATTR_OPS                0x20
+
+
+struct genl_family
+{
+       NLHDR_COMMON
+
+       uint16_t                gf_id;
+       char                    gf_name[GENL_NAMSIZ];
+       uint32_t                gf_version;
+       uint32_t                gf_hdrsize;
+       uint32_t                gf_maxattr;
+
+       struct nl_list_head     gf_ops;
+};
+
+
+extern struct genl_family *    genl_family_alloc(void);
+extern void                    genl_family_put(struct genl_family *);
+
+extern int                     genl_family_add_op(struct genl_family *,
+                                                  int, int);
+
+/**
+ * @name Attributes
+ * @{
+ */
+
+static inline unsigned int genl_family_get_id(struct genl_family *family)
+{
+       if (family->ce_mask & FAMILY_ATTR_ID)
+               return family->gf_id;
+       else
+               return GENL_ID_GENERATE;
+}
+
+static inline void genl_family_set_id(struct genl_family *family, unsigned int id)
+{
+       family->gf_id = id;
+       family->ce_mask |= FAMILY_ATTR_ID;
+}
+
+static inline char *genl_family_get_name(struct genl_family *family)
+{
+       if (family->ce_mask & FAMILY_ATTR_NAME)
+               return family->gf_name;
+       else
+               return NULL;
+}
+
+static inline void genl_family_set_name(struct genl_family *family, const char *name)
+{
+       strncpy(family->gf_name, name, GENL_NAMSIZ-1);
+       family->ce_mask |= FAMILY_ATTR_NAME;
+}
+
+static inline uint8_t genl_family_get_version(struct genl_family *family)
+{
+       if (family->ce_mask & FAMILY_ATTR_VERSION)
+               return family->gf_version;
+       else
+               return 0;
+}
+
+static inline void genl_family_set_version(struct genl_family *family, uint8_t version)
+{
+       family->gf_version = version;
+       family->ce_mask |= FAMILY_ATTR_VERSION;
+}
+
+static inline uint32_t genl_family_get_hdrsize(struct genl_family *family)
+{
+       if (family->ce_mask & FAMILY_ATTR_HDRSIZE)
+               return family->gf_hdrsize;
+       else
+               return 0;
+}
+
+static inline void genl_family_set_hdrsize(struct genl_family *family, uint32_t hdrsize)
+{
+       family->gf_hdrsize = hdrsize;
+       family->ce_mask |= FAMILY_ATTR_HDRSIZE;
+}
+
+static inline uint32_t genl_family_get_maxattr(struct genl_family *family)
+{
+       if (family->ce_mask & FAMILY_ATTR_MAXATTR)
+               return family->gf_maxattr;
+       else
+               return family->gf_maxattr;
+}
+
+static inline void genl_family_set_maxattr(struct genl_family *family, uint32_t maxattr)
+{
+       family->gf_maxattr = maxattr;
+       family->ce_mask |= FAMILY_ATTR_MAXATTR;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/genl/genl.h b/package/libnl-tiny/src/include/netlink/genl/genl.h
new file mode 100644 (file)
index 0000000..3f3340c
--- /dev/null
@@ -0,0 +1,47 @@
+/*
+ * netlink/genl/genl.h         Generic Netlink
+ *
+ *     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_GENL_H_
+#define NETLINK_GENL_H_
+
+#include <netlink/netlink.h>
+#include <netlink/msg.h>
+#include <netlink/attr.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int             genl_connect(struct nl_sock *);
+
+extern int             genl_send_simple(struct nl_sock *, int, int,
+                                        int, int);
+
+extern void *          genlmsg_put(struct nl_msg *, uint32_t, uint32_t,
+                                   int, int, int, uint8_t, uint8_t);
+
+extern int             genlmsg_valid_hdr(struct nlmsghdr *, int);
+extern int             genlmsg_validate(struct nlmsghdr *, int, int,
+                                        struct nla_policy *);
+extern int             genlmsg_parse(struct nlmsghdr *, int, struct nlattr **,
+                                     int, struct nla_policy *);
+extern void *          genlmsg_data(const struct genlmsghdr *);
+extern int             genlmsg_len(const struct genlmsghdr *);
+extern struct nlattr * genlmsg_attrdata(const struct genlmsghdr *, int);
+extern int             genlmsg_attrlen(const struct genlmsghdr *, int);
+
+extern char *          genl_op2name(int, int, char *, size_t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/genl/mngt.h b/package/libnl-tiny/src/include/netlink/genl/mngt.h
new file mode 100644 (file)
index 0000000..8b0244f
--- /dev/null
@@ -0,0 +1,87 @@
+/*
+ * netlink/genl/mngt.h         Generic Netlink Management
+ *
+ *     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>
+ */
+
+#ifndef NETLINK_GENL_MNGT_H_
+#define NETLINK_GENL_MNGT_H_
+
+#include <netlink/netlink.h>
+#include <netlink/attr.h>
+#include <netlink/list.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct nl_cache_ops;
+
+struct genl_info
+{
+       struct sockaddr_nl *    who;
+       struct nlmsghdr *       nlh;
+       struct genlmsghdr *     genlhdr;
+       void *                  userhdr;
+       struct nlattr **        attrs;
+};
+
+/**
+ * @ingroup genl_mngt
+ * Generic Netlink Command
+ */
+struct genl_cmd
+{
+       /** Unique command identifier */
+       int                     c_id;
+
+       /** Name/description of command */
+       char *                  c_name;
+
+       /**
+        * Maximum attribute identifier, must be provided if
+        * a message parser is available.
+        */
+       int                     c_maxattr;
+
+       int                   (*c_msg_parser)(struct nl_cache_ops *,
+                                             struct genl_cmd *,
+                                             struct genl_info *, void *);
+
+       /**
+        * Attribute validation policy (optional)
+        */
+       struct nla_policy *     c_attr_policy;
+};
+
+/**
+ * @ingroup genl_mngt
+ * Generic Netlink Operations
+ */
+struct genl_ops
+{
+       int                     o_family;
+       int                     o_id;
+       char *                  o_name;
+       struct nl_cache_ops *   o_cache_ops;
+       struct genl_cmd *       o_cmds;
+       int                     o_ncmds;
+
+       /* linked list of all genl cache operations */
+       struct nl_list_head     o_list;
+};
+
+
+extern int             genl_register(struct nl_cache_ops *);
+extern void            genl_unregister(struct nl_cache_ops *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/handlers.h b/package/libnl-tiny/src/include/netlink/handlers.h
new file mode 100644 (file)
index 0000000..5c62368
--- /dev/null
@@ -0,0 +1,230 @@
+/*
+ * netlink/handlers.c  default netlink message handlers
+ *
+ *     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>
+ */
+
+#ifndef NETLINK_HANDLERS_H_
+#define NETLINK_HANDLERS_H_
+
+#include <stdio.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <netlink/netlink-compat.h>
+#include <netlink/netlink-kernel.h>
+#include <netlink/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct nl_sock;
+struct nl_msg;
+struct nl_cb;
+/**
+ * @name Callback Typedefs
+ * @{
+ */
+
+/**
+ * nl_recvmsgs() callback for message processing customization
+ * @ingroup cb
+ * @arg msg            netlink message being processed
+ * @arg arg            argument passwd on through caller
+ */
+typedef int (*nl_recvmsg_msg_cb_t)(struct nl_msg *msg, void *arg);
+
+/**
+ * nl_recvmsgs() callback for error message processing customization
+ * @ingroup cb
+ * @arg nla            netlink address of the peer
+ * @arg nlerr          netlink error message being processed
+ * @arg arg            argument passed on through caller
+ */
+typedef int (*nl_recvmsg_err_cb_t)(struct sockaddr_nl *nla,
+                                  struct nlmsgerr *nlerr, void *arg);
+
+/** @} */
+
+/**
+ * Callback actions
+ * @ingroup cb
+ */
+enum nl_cb_action {
+       /** Proceed with wathever would come next */
+       NL_OK,
+       /** Skip this message */
+       NL_SKIP,
+       /** Stop parsing altogether and discard remaining messages */
+       NL_STOP,
+};
+
+/**
+ * Callback kinds
+ * @ingroup cb
+ */
+enum nl_cb_kind {
+       /** Default handlers (quiet) */
+       NL_CB_DEFAULT,
+       /** Verbose default handlers (error messages printed) */
+       NL_CB_VERBOSE,
+       /** Debug handlers for debugging */
+       NL_CB_DEBUG,
+       /** Customized handler specified by the user */
+       NL_CB_CUSTOM,
+       __NL_CB_KIND_MAX,
+};
+
+#define NL_CB_KIND_MAX (__NL_CB_KIND_MAX - 1)
+
+/**
+ * Callback types
+ * @ingroup cb
+ */
+enum nl_cb_type {
+       /** Message is valid */
+       NL_CB_VALID,
+       /** Last message in a series of multi part messages received */
+       NL_CB_FINISH,
+       /** Report received that data was lost */
+       NL_CB_OVERRUN,
+       /** Message wants to be skipped */
+       NL_CB_SKIPPED,
+       /** Message is an acknowledge */
+       NL_CB_ACK,
+       /** Called for every message received */
+       NL_CB_MSG_IN,
+       /** Called for every message sent out except for nl_sendto() */
+       NL_CB_MSG_OUT,
+       /** Message is malformed and invalid */
+       NL_CB_INVALID,
+       /** Called instead of internal sequence number checking */
+       NL_CB_SEQ_CHECK,
+       /** Sending of an acknowledge message has been requested */
+       NL_CB_SEND_ACK,
+       __NL_CB_TYPE_MAX,
+};
+
+#define NL_CB_TYPE_MAX (__NL_CB_TYPE_MAX - 1)
+
+struct nl_cb
+{
+       nl_recvmsg_msg_cb_t     cb_set[NL_CB_TYPE_MAX+1];
+       void *                  cb_args[NL_CB_TYPE_MAX+1];
+       
+       nl_recvmsg_err_cb_t     cb_err;
+       void *                  cb_err_arg;
+
+       /** May be used to replace nl_recvmsgs with your own implementation
+        * in all internal calls to nl_recvmsgs. */
+       int                     (*cb_recvmsgs_ow)(struct nl_sock *,
+                                                 struct nl_cb *);
+
+       /** Overwrite internal calls to nl_recv, must return the number of
+        * octets read and allocate a buffer for the received data. */
+       int                     (*cb_recv_ow)(struct nl_sock *,
+                                             struct sockaddr_nl *,
+                                             unsigned char **,
+                                             struct ucred **);
+
+       /** Overwrites internal calls to nl_send, must send the netlink
+        * message. */
+       int                     (*cb_send_ow)(struct nl_sock *,
+                                             struct nl_msg *);
+
+       int                     cb_refcnt;
+};
+
+
+extern struct nl_cb *  nl_cb_alloc(enum nl_cb_kind);
+extern struct nl_cb *  nl_cb_clone(struct nl_cb *);
+extern void            nl_cb_put(struct nl_cb *);
+
+extern int  nl_cb_set(struct nl_cb *, enum nl_cb_type, enum nl_cb_kind,
+                     nl_recvmsg_msg_cb_t, void *);
+extern int  nl_cb_err(struct nl_cb *, enum nl_cb_kind, nl_recvmsg_err_cb_t,
+                     void *);
+
+static inline struct nl_cb *nl_cb_get(struct nl_cb *cb)
+{
+       cb->cb_refcnt++;
+
+       return cb;
+}
+
+/**
+ * Set up a all callbacks
+ * @arg cb             callback set
+ * @arg kind           kind of callback
+ * @arg func           callback function
+ * @arg arg            argument to be passwd to callback function
+ *
+ * @return 0 on success or a negative error code
+ */
+static inline int nl_cb_set_all(struct nl_cb *cb, enum nl_cb_kind kind,
+                 nl_recvmsg_msg_cb_t func, void *arg)
+{
+       int i, err;
+
+       for (i = 0; i <= NL_CB_TYPE_MAX; i++) {
+               err = nl_cb_set(cb, i, kind, func, arg);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+
+/**
+ * @name Overwriting
+ * @{
+ */
+
+/**
+ * Overwrite internal calls to nl_recvmsgs()
+ * @arg cb             callback set
+ * @arg func           replacement callback for nl_recvmsgs()
+ */
+static inline void nl_cb_overwrite_recvmsgs(struct nl_cb *cb,
+                             int (*func)(struct nl_sock *, struct nl_cb *))
+{
+       cb->cb_recvmsgs_ow = func;
+}
+
+/**
+ * Overwrite internal calls to nl_recv()
+ * @arg cb             callback set
+ * @arg func           replacement callback for nl_recv()
+ */
+static inline void nl_cb_overwrite_recv(struct nl_cb *cb,
+                         int (*func)(struct nl_sock *, struct sockaddr_nl *,
+                                     unsigned char **, struct ucred **))
+{
+       cb->cb_recv_ow = func;
+}
+
+/**
+ * Overwrite internal calls to nl_send()
+ * @arg cb             callback set
+ * @arg func           replacement callback for nl_send()
+ */
+static inline void nl_cb_overwrite_send(struct nl_cb *cb,
+                         int (*func)(struct nl_sock *, struct nl_msg *))
+{
+       cb->cb_send_ow = func;
+}
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/list.h b/package/libnl-tiny/src/include/netlink/list.h
new file mode 100644 (file)
index 0000000..c6876a7
--- /dev/null
@@ -0,0 +1,88 @@
+/*
+ * netlink/list.h      Netlink List Utilities
+ *
+ *     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>
+ */
+
+#ifndef NETLINK_LIST_H_
+#define NETLINK_LIST_H_
+
+struct nl_list_head
+{
+       struct nl_list_head *   next;
+       struct nl_list_head *   prev;
+};
+
+
+static inline void __nl_list_add(struct nl_list_head *obj,
+                                struct nl_list_head *prev,
+                                struct nl_list_head *next)
+{
+       prev->next = obj;
+       obj->prev = prev;
+       next->prev = obj;
+       obj->next = next;
+}
+
+static inline void nl_list_add_tail(struct nl_list_head *obj,
+                                   struct nl_list_head *head)
+{
+       __nl_list_add(obj, head->prev, head);
+}
+
+static inline void nl_list_add_head(struct nl_list_head *obj,
+                                   struct nl_list_head *head)
+{
+       __nl_list_add(obj, head, head->next);
+}
+
+static inline void nl_list_del(struct nl_list_head *obj)
+{
+       obj->next->prev = obj->prev;
+       obj->prev->next = obj->next;
+}
+
+static inline int nl_list_empty(struct nl_list_head *head)
+{
+       return head->next == head;
+}
+
+#define nl_container_of(ptr, type, member) ({                  \
+        const typeof( ((type *)0)->member ) *__mptr = (ptr);   \
+        (type *)( (char *)__mptr - ((size_t) &((type *)0)->member));})
+
+#define nl_list_entry(ptr, type, member) \
+       nl_container_of(ptr, type, member)
+
+#define nl_list_at_tail(pos, head, member) \
+       ((pos)->member.next == (head))
+
+#define nl_list_at_head(pos, head, member) \
+       ((pos)->member.prev == (head))
+
+#define NL_LIST_HEAD(name) \
+       struct nl_list_head name = { &(name), &(name) }
+
+#define nl_list_first_entry(head, type, member)                        \
+       nl_list_entry((head)->next, type, member)
+
+#define nl_list_for_each_entry(pos, head, member)                              \
+       for (pos = nl_list_entry((head)->next, typeof(*pos), member);   \
+            &(pos)->member != (head);  \
+            (pos) = nl_list_entry((pos)->member.next, typeof(*(pos)), member))
+
+#define nl_list_for_each_entry_safe(pos, n, head, member)                      \
+       for (pos = nl_list_entry((head)->next, typeof(*pos), member),   \
+               n = nl_list_entry(pos->member.next, typeof(*pos), member);      \
+            &(pos)->member != (head);                                  \
+            pos = n, n = nl_list_entry(n->member.next, typeof(*n), member))
+
+#define nl_init_list_head(head) \
+       do { (head)->next = (head); (head)->prev = (head); } while (0)
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/msg.h b/package/libnl-tiny/src/include/netlink/msg.h
new file mode 100644 (file)
index 0000000..aedcb08
--- /dev/null
@@ -0,0 +1,308 @@
+/*
+ * netlink/msg.c               Netlink Messages 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-2006 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef NETLINK_MSG_H_
+#define NETLINK_MSG_H_
+
+#include <netlink/netlink.h>
+#include <netlink/object.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct nla_policy;
+
+#define NL_DONTPAD     0
+
+/**
+ * @ingroup msg
+ * @brief
+ * Will cause the netlink pid to be set to the pid assigned to
+ * the netlink handle (socket) just before sending the message off.
+ * @note Requires the use of nl_send_auto_complete()!
+ */
+#define NL_AUTO_PID    0
+
+/**
+ * @ingroup msg
+ * @brief
+ * May be used to refer to a sequence number which should be
+ * automatically set just before sending the message off.
+ * @note Requires the use of nl_send_auto_complete()!
+ */
+#define NL_AUTO_SEQ    0
+
+#define NL_MSG_CRED_PRESENT 1
+
+struct nl_msg
+{
+       int                     nm_protocol;
+       int                     nm_flags;
+       struct sockaddr_nl      nm_src;
+       struct sockaddr_nl      nm_dst;
+       struct ucred            nm_creds;
+       struct nlmsghdr *       nm_nlh;
+       size_t                  nm_size;
+       int                     nm_refcnt;
+};
+
+
+struct nl_msg;
+struct nl_tree;
+struct ucred;
+
+/* message parsing */
+extern int               nlmsg_ok(const struct nlmsghdr *, int);
+extern struct nlmsghdr *  nlmsg_next(struct nlmsghdr *, int *);
+extern int               nlmsg_parse(struct nlmsghdr *, int, struct nlattr **,
+                                     int, struct nla_policy *);
+extern int               nlmsg_validate(struct nlmsghdr *, int, int,
+                                        struct nla_policy *);
+
+extern struct nl_msg *   nlmsg_alloc(void);
+extern struct nl_msg *   nlmsg_alloc_size(size_t);
+extern struct nl_msg *   nlmsg_alloc_simple(int, int);
+extern void              nlmsg_set_default_size(size_t);
+extern struct nl_msg *   nlmsg_inherit(struct nlmsghdr *);
+extern struct nl_msg *   nlmsg_convert(struct nlmsghdr *);
+extern void *            nlmsg_reserve(struct nl_msg *, size_t, int);
+extern int               nlmsg_append(struct nl_msg *, void *, size_t, int);
+
+extern struct nlmsghdr *  nlmsg_put(struct nl_msg *, uint32_t, uint32_t,
+                                   int, int, int);
+extern void              nlmsg_free(struct nl_msg *);
+
+extern int               nl_msg_parse(struct nl_msg *,
+                                      void (*cb)(struct nl_object *, void *),
+                                      void *);
+
+extern void            nl_msg_dump(struct nl_msg *, FILE *);
+
+/**
+ * length of netlink message not including padding
+ * @arg payload                length of message payload
+ */
+static inline int nlmsg_msg_size(int payload)
+{
+       return NLMSG_HDRLEN + payload;
+}
+
+/**
+ * length of netlink message including padding
+ * @arg payload                length of message payload
+ */
+static inline int nlmsg_total_size(int payload)
+{
+       return NLMSG_ALIGN(nlmsg_msg_size(payload));
+}
+
+/**
+ * length of padding at the message's tail
+ * @arg payload                length of message payload
+ */
+static inline int nlmsg_padlen(int payload)
+{
+       return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
+}
+
+/**
+ * head of message payload
+ * @arg nlh            netlink messsage header
+ */
+static inline void *nlmsg_data(const struct nlmsghdr *nlh)
+{
+       return (unsigned char *) nlh + NLMSG_HDRLEN;
+}
+
+static inline void *nlmsg_tail(const struct nlmsghdr *nlh)
+{
+       return (unsigned char *) nlh + NLMSG_ALIGN(nlh->nlmsg_len);
+}
+
+/**
+ * length of message payload
+ * @arg nlh            netlink message header
+ */
+static inline int nlmsg_len(const struct nlmsghdr *nlh)
+{
+       return nlh->nlmsg_len - NLMSG_HDRLEN;
+}
+
+/**
+ * head of attributes data
+ * @arg nlh            netlink message header
+ * @arg hdrlen         length of family specific header
+ */
+static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh, int hdrlen)
+{
+       unsigned char *data = nlmsg_data(nlh);
+       return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
+}
+
+/**
+ * length of attributes data
+ * @arg nlh            netlink message header
+ * @arg hdrlen         length of family specific header
+ */
+static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
+{
+       return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
+}
+
+static inline int nlmsg_valid_hdr(const struct nlmsghdr *nlh, int hdrlen)
+{
+       if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
+               return 0;
+
+       return 1;
+}
+
+
+static inline void nlmsg_set_proto(struct nl_msg *msg, int protocol)
+{
+       msg->nm_protocol = protocol;
+}
+
+static inline int nlmsg_get_proto(struct nl_msg *msg)
+{
+       return msg->nm_protocol;
+}
+
+static inline size_t nlmsg_get_max_size(struct nl_msg *msg)
+{
+       return msg->nm_size;
+}
+
+static inline void nlmsg_set_src(struct nl_msg *msg, struct sockaddr_nl *addr)
+{
+       memcpy(&msg->nm_src, addr, sizeof(*addr));
+}
+
+static inline struct sockaddr_nl *nlmsg_get_src(struct nl_msg *msg)
+{
+       return &msg->nm_src;
+}
+
+static inline void nlmsg_set_dst(struct nl_msg *msg, struct sockaddr_nl *addr)
+{
+       memcpy(&msg->nm_dst, addr, sizeof(*addr));
+}
+
+static inline struct sockaddr_nl *nlmsg_get_dst(struct nl_msg *msg)
+{
+       return &msg->nm_dst;
+}
+
+static inline void nlmsg_set_creds(struct nl_msg *msg, struct ucred *creds)
+{
+       memcpy(&msg->nm_creds, creds, sizeof(*creds));
+       msg->nm_flags |= NL_MSG_CRED_PRESENT;
+}
+
+static inline struct ucred *nlmsg_get_creds(struct nl_msg *msg)
+{
+       if (msg->nm_flags & NL_MSG_CRED_PRESENT)
+               return &msg->nm_creds;
+       return NULL;
+}
+
+/**
+ * Return actual netlink message
+ * @arg n              netlink message
+ * 
+ * Returns the actual netlink message casted to the type of the netlink
+ * message header.
+ * 
+ * @return A pointer to the netlink message.
+ */
+static inline struct nlmsghdr *nlmsg_hdr(struct nl_msg *n)
+{
+       return n->nm_nlh;
+}
+
+/**
+ * Acquire a reference on a netlink message
+ * @arg msg            message to acquire reference from
+ */
+static inline void nlmsg_get(struct nl_msg *msg)
+{
+       msg->nm_refcnt++;
+}
+
+/**
+ * Expand maximum payload size of a netlink message
+ * @arg n              Netlink message.
+ * @arg newlen         New maximum payload size.
+ *
+ * Reallocates the payload section of a netlink message and increases
+ * the maximum payload size of the message.
+ *
+ * @note Any pointers pointing to old payload block will be stale and
+ *       need to be refetched. Therfore, do not expand while constructing
+ *       nested attributes or while reserved data blocks are held.
+ *
+ * @return 0 on success or a negative error code.
+ */
+static inline int nlmsg_expand(struct nl_msg *n, size_t newlen)
+{
+       void *tmp;
+
+       if (newlen <= n->nm_size)
+               return -NLE_INVAL;
+
+       tmp = realloc(n->nm_nlh, newlen);
+       if (tmp == NULL)
+               return -NLE_NOMEM;
+
+       n->nm_nlh = tmp;
+       n->nm_size = newlen;
+
+       return 0;
+}
+
+
+/**
+ * @name Iterators
+ * @{
+ */
+
+/**
+ * @ingroup msg
+ * Iterate over a stream of attributes in a message
+ * @arg pos    loop counter, set to current attribute
+ * @arg nlh    netlink message header
+ * @arg hdrlen length of family header
+ * @arg rem    initialized to len, holds bytes currently remaining in stream
+ */
+#define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
+       nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
+                         nlmsg_attrlen(nlh, hdrlen), rem)
+
+/**
+ * Iterate over a stream of messages
+ * @arg pos    loop counter, set to current message
+ * @arg head   head of message stream
+ * @arg len    length of message stream
+ * @arg rem    initialized to len, holds bytes currently remaining in stream
+ */
+#define nlmsg_for_each_msg(pos, head, len, rem) \
+       for (pos = head, rem = len; \
+            nlmsg_ok(pos, rem); \
+            pos = nlmsg_next(pos, &(rem)))
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/netlink-compat.h b/package/libnl-tiny/src/include/netlink/netlink-compat.h
new file mode 100644 (file)
index 0000000..17ec9fc
--- /dev/null
@@ -0,0 +1,50 @@
+/*
+ * netlink/netlink-compat.h    Netlink Compatability
+ *
+ *     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>
+ */
+
+#ifndef NETLINK_COMPAT_H_
+#define NETLINK_COMPAT_H_
+
+#if !defined _LINUX_SOCKET_H && !defined _BITS_SOCKADDR_H
+typedef unsigned short  sa_family_t;
+#endif
+
+#ifndef IFNAMSIZ 
+/** Maximum length of a interface name */
+#define IFNAMSIZ 16
+#endif
+
+/* patch 2.4.x if_arp */
+#ifndef ARPHRD_INFINIBAND
+#define ARPHRD_INFINIBAND 32
+#endif
+
+/* patch 2.4.x eth header file */
+#ifndef ETH_P_MPLS_UC
+#define ETH_P_MPLS_UC  0x8847 
+#endif
+
+#ifndef ETH_P_MPLS_MC
+#define ETH_P_MPLS_MC   0x8848
+#endif
+
+#ifndef  ETH_P_EDP2
+#define ETH_P_EDP2      0x88A2
+#endif
+
+#ifndef ETH_P_HDLC
+#define ETH_P_HDLC      0x0019 
+#endif
+
+#ifndef AF_LLC
+#define AF_LLC         26
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/netlink-kernel.h b/package/libnl-tiny/src/include/netlink/netlink-kernel.h
new file mode 100644 (file)
index 0000000..a0f5535
--- /dev/null
@@ -0,0 +1,196 @@
+#ifndef __LINUX_NETLINK_H
+#define __LINUX_NETLINK_H
+
+/**
+ * Netlink socket address
+ * @ingroup nl
+ */
+struct sockaddr_nl
+{
+       /** socket family (AF_NETLINK) */
+       sa_family_t     nl_family;
+
+       /** Padding (unused) */
+       unsigned short  nl_pad;
+
+       /** Unique process ID  */
+       uint32_t        nl_pid;
+
+       /** Multicast group subscriptions */
+       uint32_t        nl_groups;
+};
+
+/**
+ * Netlink message header
+ * @ingroup msg
+ */
+struct nlmsghdr
+{
+       /**
+        * Length of message including header.
+        */
+       uint32_t        nlmsg_len;
+
+       /**
+        * Message type (content type)
+        */
+       uint16_t        nlmsg_type;
+
+       /**
+        * Message flags
+        */
+       uint16_t        nlmsg_flags;
+
+       /**
+        * Sequence number
+        */
+       uint32_t        nlmsg_seq;
+
+       /**
+        * Netlink PID of the proccess sending the message.
+        */
+       uint32_t        nlmsg_pid;
+};
+
+/**
+ * @name Standard message flags
+ * @{
+ */
+
+/**
+ * Must be set on all request messages (typically from user space to
+ * kernel space).
+ * @ingroup msg
+ */
+#define NLM_F_REQUEST          1
+
+/**
+ * Indicates the message is part of a multipart message terminated
+ * by NLMSG_DONE.
+ */
+#define NLM_F_MULTI            2
+
+/**
+ * Request for an acknowledgment on success.
+ */
+#define NLM_F_ACK              4
+
+/**
+ * Echo this request
+ */
+#define NLM_F_ECHO             8
+
+/** @} */
+
+/**
+ * @name Additional message flags for GET requests
+ * @{
+ */
+
+/**
+ * Return the complete table instead of a single entry.
+ * @ingroup msg
+ */
+#define NLM_F_ROOT     0x100
+
+/**
+ * Return all entries matching criteria passed in message content.
+ */
+#define NLM_F_MATCH    0x200
+
+/**
+ * Return an atomic snapshot of the table being referenced. This
+ * may require special privileges because it has the potential to
+ * interrupt service in the FE for a longer time.
+ */
+#define NLM_F_ATOMIC   0x400
+
+/**
+ * Dump all entries
+ */
+#define NLM_F_DUMP     (NLM_F_ROOT|NLM_F_MATCH)
+
+/** @} */
+
+/**
+ * @name Additional messsage flags for NEW requests
+ * @{
+ */
+
+/**
+ * Replace existing matching config object with this request.
+ * @ingroup msg
+ */
+#define NLM_F_REPLACE  0x100
+
+/**
+ * Don't replace the config object if it already exists.
+ */
+#define NLM_F_EXCL     0x200
+
+/**
+ * Create config object if it doesn't already exist.
+ */
+#define NLM_F_CREATE   0x400
+
+/**
+ * Add to the end of the object list.
+ */
+#define NLM_F_APPEND   0x800
+
+/** @} */
+
+/**
+ * @name Standard Message types
+ * @{
+ */
+
+/**
+ * No operation, message must be ignored
+ * @ingroup msg
+ */
+#define NLMSG_NOOP             0x1
+
+/**
+ * The message signals an error and the payload contains a nlmsgerr
+ * structure. This can be looked at as a NACK and typically it is
+ * from FEC to CPC.
+ */
+#define NLMSG_ERROR            0x2
+
+/**
+ * Message terminates a multipart message.
+ */
+#define NLMSG_DONE             0x3
+
+/**
+ * The message signals that data got lost
+ */
+#define NLMSG_OVERRUN          0x4
+
+/**
+ * Lower limit of reserved message types
+ */
+#define NLMSG_MIN_TYPE         0x10
+
+/** @} */
+
+/**
+ * Netlink error message
+ * @ingroup msg
+ */
+struct nlmsgerr
+{
+       /** Error code (errno number) */
+       int             error;
+
+       /** Original netlink message causing the error */
+       struct nlmsghdr msg;
+};
+
+struct nl_pktinfo
+{
+       __u32   group;
+};
+
+#endif /* __LINUX_NETLINK_H */
diff --git a/package/libnl-tiny/src/include/netlink/netlink.h b/package/libnl-tiny/src/include/netlink/netlink.h
new file mode 100644 (file)
index 0000000..e06fb7f
--- /dev/null
@@ -0,0 +1,82 @@
+/*
+ * netlink/netlink.h           Netlink 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-2006 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef NETLINK_NETLINK_H_
+#define NETLINK_NETLINK_H_
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/poll.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <netdb.h>
+#include <netlink/netlink-compat.h>
+#include <linux/netlink.h>
+#include <linux/genetlink.h>
+#include <netlink/version.h>
+#include <netlink/errno.h>
+#include <netlink/types.h>
+#include <netlink/handlers.h>
+#include <netlink/socket.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int nl_debug;
+extern struct nl_dump_params nl_debug_dp;
+
+/* Connection Management */
+extern int                     nl_connect(struct nl_sock *, int);
+extern void                    nl_close(struct nl_sock *);
+
+/* Send */
+extern int                     nl_sendto(struct nl_sock *, void *, size_t);
+extern int                     nl_sendmsg(struct nl_sock *, struct nl_msg *,
+                                          struct msghdr *);
+extern int                     nl_send(struct nl_sock *, struct nl_msg *);
+extern int                     nl_send_auto_complete(struct nl_sock *,
+                                                     struct nl_msg *);
+extern int                     nl_send_simple(struct nl_sock *, int, int,
+                                              void *, size_t);
+
+/* Receive */
+extern int                     nl_recv(struct nl_sock *,
+                                       struct sockaddr_nl *, unsigned char **,
+                                       struct ucred **);
+extern int                     nl_recvmsgs(struct nl_sock *sk, struct nl_cb *cb);
+
+extern int                     nl_wait_for_ack(struct nl_sock *);
+
+/* Netlink Family Translations */
+extern char *                  nl_nlfamily2str(int, char *, size_t);
+extern int                     nl_str2nlfamily(const char *);
+
+/**
+ * Receive a set of message from a netlink socket using handlers in nl_sock.
+ * @arg sk             Netlink socket.
+ *
+ * Calls nl_recvmsgs() with the handlers configured in the netlink socket.
+ */
+static inline int nl_recvmsgs_default(struct nl_sock *sk)
+{
+       return nl_recvmsgs(sk, sk->s_cb);
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/object-api.h b/package/libnl-tiny/src/include/netlink/object-api.h
new file mode 100644 (file)
index 0000000..8a44fe9
--- /dev/null
@@ -0,0 +1,331 @@
+/*
+ * netlink/object-api.c                Object 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-2007 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef NETLINK_OBJECT_API_H_
+#define NETLINK_OBJECT_API_H_
+
+#include <netlink/netlink.h>
+#include <netlink/utils.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @ingroup object
+ * @defgroup object_api Object API
+ * @brief
+ *
+ * @par 1) Object Definition
+ * @code
+ * // Define your object starting with the common object header
+ * struct my_obj {
+ *     NLHDR_COMMON
+ *     int             my_data;
+ * };
+ *
+ * // Fill out the object operations structure
+ * struct nl_object_ops my_ops = {
+ *     .oo_name        = "my_obj",
+ *     .oo_size        = sizeof(struct my_obj),
+ * };
+ *
+ * // At this point the object can be allocated, you may want to provide a
+ * // separate _alloc() function to ease allocting objects of this kind.
+ * struct nl_object *obj = nl_object_alloc(&my_ops);
+ *
+ * // And release it again...
+ * nl_object_put(obj);
+ * @endcode
+ *
+ * @par 2) Allocating additional data
+ * @code
+ * // You may require to allocate additional data and store it inside
+ * // object, f.e. assuming there is a field `ptr'.
+ * struct my_obj {
+ *     NLHDR_COMMON
+ *     void *          ptr;
+ * };
+ *
+ * // And at some point you may assign allocated data to this field:
+ * my_obj->ptr = calloc(1, ...);
+ *
+ * // In order to not introduce any memory leaks you have to release
+ * // this data again when the last reference is given back.
+ * static void my_obj_free_data(struct nl_object *obj)
+ * {
+ *     struct my_obj *my_obj = nl_object_priv(obj);
+ *
+ *     free(my_obj->ptr);
+ * }
+ *
+ * // Also when the object is cloned, you must ensure for your pointer
+ * // stay valid even if one of the clones is freed by either making
+ * // a clone as well or increase the reference count.
+ * static int my_obj_clone(struct nl_object *src, struct nl_object *dst)
+ * {
+ *     struct my_obj *my_src = nl_object_priv(src);
+ *     struct my_obj *my_dst = nl_object_priv(dst);
+ *
+ *     if (src->ptr) {
+ *             dst->ptr = calloc(1, ...);
+ *             memcpy(dst->ptr, src->ptr, ...);
+ *     }
+ * }
+ *
+ * struct nl_object_ops my_ops = {
+ *     ...
+ *     .oo_free_data   = my_obj_free_data,
+ *     .oo_clone       = my_obj_clone,
+ * };
+ * @endcode
+ *
+ * @par 3) Object Dumping
+ * @code
+ * static int my_obj_dump_detailed(struct nl_object *obj,
+ *                                struct nl_dump_params *params)
+ * {
+ *     struct my_obj *my_obj = nl_object_priv(obj);
+ *
+ *     // It is absolutely essential to use nl_dump() when printing
+ *     // any text to make sure the dumping parameters are respected.
+ *     nl_dump(params, "Obj Integer: %d\n", my_obj->my_int);
+ *
+ *     // Before we can dump the next line, make sure to prefix
+ *     // this line correctly.
+ *     nl_new_line(params);
+ *
+ *     // You may also split a line into multiple nl_dump() calls.
+ *     nl_dump(params, "String: %s ", my_obj->my_string);
+ *     nl_dump(params, "String-2: %s\n", my_obj->another_string);
+ * }
+ *
+ * struct nl_object_ops my_ops = {
+ *     ...
+ *     .oo_dump[NL_DUMP_FULL]  = my_obj_dump_detailed,
+ * };
+ * @endcode
+ *
+ * @par 4) Object Attributes
+ * @code
+ * // The concept of object attributes is optional but can ease the typical
+ * // case of objects that have optional attributes, e.g. a route may have a
+ * // nexthop assigned but it is not required to.
+ *
+ * // The first step to define your object specific bitmask listing all
+ * // attributes
+ * #define MY_ATTR_FOO         (1<<0)
+ * #define MY_ATTR_BAR         (1<<1)
+ *
+ * // When assigning an optional attribute to the object, make sure
+ * // to mark its availability.
+ * my_obj->foo = 123123;
+ * my_obj->ce_mask |= MY_ATTR_FOO;
+ *
+ * // At any time you may use this mask to check for the availability
+ * // of the attribute, e.g. while dumping
+ * if (my_obj->ce_mask & MY_ATTR_FOO)
+ *     nl_dump(params, "foo %d ", my_obj->foo);
+ *
+ * // One of the big advantages of this concept is that it allows for
+ * // standardized comparisons which make it trivial for caches to
+ * // identify unique objects by use of unified comparison functions.
+ * // In order for it to work, your object implementation must provide
+ * // a comparison function and define a list of attributes which
+ * // combined together make an object unique.
+ *
+ * static int my_obj_compare(struct nl_object *_a, struct nl_object *_b,
+ *                          uint32_t attrs, int flags)
+ * {
+ *     struct my_obj *a = nl_object_priv(_a):
+ *     struct my_obj *b = nl_object_priv(_b):
+ *     int diff = 0;
+ *
+ *     // We help ourselves in defining our own DIFF macro which will
+ *     // call ATTR_DIFF() on both objects which will make sure to only
+ *     // compare the attributes if required.
+ *     #define MY_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, MY_ATTR_##ATTR, a, b, EXPR)
+ *
+ *     // Call our own diff macro for each attribute to build a bitmask
+ *     // representing the attributes which mismatch.
+ *     diff |= MY_DIFF(FOO, a->foo != b->foo)
+ *     diff |= MY_DIFF(BAR, strcmp(a->bar, b->bar))
+ *
+ *     return diff;
+ * }
+ *
+ * // In order to identify identical objects with differing attributes
+ * // you must specify the attributes required to uniquely identify
+ * // your object. Make sure to not include too many attributes, this
+ * // list is used when caches look for an old version of an object.
+ * struct nl_object_ops my_ops = {
+ *     ...
+ *     .oo_id_attrs            = MY_ATTR_FOO,
+ *     .oo_compare             = my_obj_compare,
+ * };
+ * @endcode
+ * @{
+ */
+
+/**
+ * Common Object Header
+ *
+ * This macro must be included as first member in every object
+ * definition to allow objects to be cached.
+ */
+#define NLHDR_COMMON                           \
+       int                     ce_refcnt;      \
+       struct nl_object_ops *  ce_ops;         \
+       struct nl_cache *       ce_cache;       \
+       struct nl_list_head     ce_list;        \
+       int                     ce_msgtype;     \
+       int                     ce_flags;       \
+       uint32_t                ce_mask;
+
+/**
+ * Return true if attribute is available in both objects
+ * @arg A              an object
+ * @arg B              another object
+ * @arg ATTR           attribute bit
+ *
+ * @return True if the attribute is available, otherwise false is returned.
+ */
+#define AVAILABLE(A, B, ATTR)  (((A)->ce_mask & (B)->ce_mask) & (ATTR))
+
+/**
+ * Return true if attributes mismatch
+ * @arg A              an object
+ * @arg B              another object
+ * @arg ATTR           attribute bit
+ * @arg EXPR           Comparison expression
+ *
+ * This function will check if the attribute in question is available
+ * in both objects, if not this will count as a mismatch.
+ *
+ * If available the function will execute the expression which must
+ * return true if the attributes mismatch.
+ *
+ * @return True if the attribute mismatch, or false if they match.
+ */
+#define ATTR_MISMATCH(A, B, ATTR, EXPR)        (!AVAILABLE(A, B, ATTR) || (EXPR))
+
+/**
+ * Return attribute bit if attribute does not match
+ * @arg LIST           list of attributes to be compared
+ * @arg ATTR           attribute bit
+ * @arg A              an object
+ * @arg B              another object
+ * @arg EXPR           Comparison expression
+ *
+ * This function will check if the attribute in question is available
+ * in both objects, if not this will count as a mismatch.
+ *
+ * If available the function will execute the expression which must
+ * return true if the attributes mismatch.
+ *
+ * In case the attributes mismatch, the attribute is returned, otherwise
+ * 0 is returned.
+ *
+ * @code
+ * diff |= ATTR_DIFF(attrs, MY_ATTR_FOO, a, b, a->foo != b->foo);
+ * @endcode
+ */
+#define ATTR_DIFF(LIST, ATTR, A, B, EXPR) \
+({     int diff = 0; \
+       if (((LIST) & (ATTR)) && ATTR_MISMATCH(A, B, ATTR, EXPR)) \
+               diff = ATTR; \
+       diff; })
+
+/**
+ * Object Operations
+ */
+struct nl_object;
+struct nl_object_ops
+{
+       /**
+        * Unique name of object type
+        *
+        * Must be in the form family/name, e.g. "route/addr"
+        */
+       char *          oo_name;
+
+       /** Size of object including its header */
+       size_t          oo_size;
+
+       /* List of attributes needed to uniquely identify the object */
+       uint32_t        oo_id_attrs;
+
+       /**
+        * Constructor function
+        *
+        * Will be called when a new object of this type is allocated.
+        * Can be used to initialize members such as lists etc.
+        */
+       void  (*oo_constructor)(struct nl_object *);
+
+       /**
+        * Destructor function
+        *
+        * Will be called when an object is freed. Must free all
+        * resources which may have been allocated as part of this
+        * object.
+        */
+       void  (*oo_free_data)(struct nl_object *);
+
+       /**
+        * Cloning function
+        *
+        * Will be called when an object needs to be cloned. Please
+        * note that the generic object code will make an exact
+        * copy of the object first, therefore you only need to take
+        * care of members which require reference counting etc.
+        *
+        * May return a negative error code to abort cloning.
+        */
+       int  (*oo_clone)(struct nl_object *, struct nl_object *);
+
+       /**
+        * Dumping functions
+        *
+        * Will be called when an object is dumped. The implementations
+        * have to use nl_dump(), nl_dump_line(), and nl_new_line() to
+        * dump objects.
+        *
+        * The functions must return the number of lines printed.
+        */
+       void (*oo_dump[NL_DUMP_MAX+1])(struct nl_object *,
+                                      struct nl_dump_params *);
+
+       /**
+        * Comparison function
+        *
+        * Will be called when two objects of the same type are
+        * compared. It takes the two objects in question, an object
+        * specific bitmask defining which attributes should be
+        * compared and flags to control the behaviour.
+        *
+        * The function must return a bitmask with the relevant bit
+        * set for each attribute that mismatches.
+        */
+       int   (*oo_compare)(struct nl_object *, struct nl_object *,
+                           uint32_t, int);
+
+
+       char *(*oo_attrs2str)(int, char *, size_t);
+};
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/object.h b/package/libnl-tiny/src/include/netlink/object.h
new file mode 100644 (file)
index 0000000..87385c4
--- /dev/null
@@ -0,0 +1,144 @@
+/*
+ * netlink/object.c    Generic Cacheable Object
+ *
+ *     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_OBJECT_H_
+#define NETLINK_OBJECT_H_
+
+#include <netlink/netlink.h>
+#include <netlink/utils.h>
+#include <netlink/object-api.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NL_OBJ_MARK            1
+
+struct nl_cache;
+struct nl_object;
+struct nl_object_ops;
+
+struct nl_object
+{
+       NLHDR_COMMON
+};
+
+#define OBJ_CAST(ptr)          ((struct nl_object *) (ptr))
+
+/* General */
+extern struct nl_object *      nl_object_alloc(struct nl_object_ops *);
+extern int                     nl_object_alloc_name(const char *,
+                                                    struct nl_object **);
+extern void                    nl_object_free(struct nl_object *);
+extern struct nl_object *      nl_object_clone(struct nl_object *obj);
+extern void                    nl_object_get(struct nl_object *);
+extern void                    nl_object_put(struct nl_object *);
+extern void                    nl_object_dump(struct nl_object *,
+                                              struct nl_dump_params *);
+extern int                     nl_object_identical(struct nl_object *,
+                                                   struct nl_object *);
+extern uint32_t                        nl_object_diff(struct nl_object *,
+                                              struct nl_object *);
+extern int                     nl_object_match_filter(struct nl_object *,
+                                                      struct nl_object *);
+extern char *                  nl_object_attrs2str(struct nl_object *,
+                                                   uint32_t attrs, char *buf,
+                                                   size_t);
+/**
+ * Check whether this object is used by multiple users
+ * @arg obj            object to check
+ * @return true or false
+ */
+static inline int nl_object_shared(struct nl_object *obj)
+{
+       return obj->ce_refcnt > 1;
+}
+
+
+
+/**
+ * @name Marks
+ * @{
+ */
+
+/**
+ * Add mark to object
+ * @arg obj            Object to mark
+ */
+static inline void nl_object_mark(struct nl_object *obj)
+{
+       obj->ce_flags |= NL_OBJ_MARK;
+}
+
+/**
+ * Remove mark from object
+ * @arg obj            Object to unmark
+ */
+static inline void nl_object_unmark(struct nl_object *obj)
+{
+       obj->ce_flags &= ~NL_OBJ_MARK;
+}
+
+/**
+ * Return true if object is marked
+ * @arg obj            Object to check
+ * @return true if object is marked, otherwise false
+ */
+static inline int nl_object_is_marked(struct nl_object *obj)
+{
+       return (obj->ce_flags & NL_OBJ_MARK);
+}
+
+/** @} */
+
+/**
+ * Return list of attributes present in an object
+ * @arg obj            an object
+ * @arg buf            destination buffer
+ * @arg len            length of destination buffer
+ *
+ * @return destination buffer.
+ */
+static inline char *nl_object_attr_list(struct nl_object *obj, char *buf, size_t len)
+{
+       return nl_object_attrs2str(obj, obj->ce_mask, buf, len);
+}
+
+
+/**
+ * @name Attributes
+ * @{
+ */
+
+static inline int nl_object_get_refcnt(struct nl_object *obj)
+{
+       return obj->ce_refcnt;
+}
+
+static inline struct nl_cache *nl_object_get_cache(struct nl_object *obj)
+{
+       return obj->ce_cache;
+}
+
+static inline void *           nl_object_priv(struct nl_object *obj)
+{
+       return obj;
+}
+
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/socket.h b/package/libnl-tiny/src/include/netlink/socket.h
new file mode 100644 (file)
index 0000000..9f7f422
--- /dev/null
@@ -0,0 +1,221 @@
+/*
+ * netlink/socket.h            Netlink Socket
+ *
+ *     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_SOCKET_H_
+#define NETLINK_SOCKET_H_
+
+#include <netlink/types.h>
+#include <netlink/handlers.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NL_SOCK_BUFSIZE_SET    (1<<0)
+#define NL_SOCK_PASSCRED       (1<<1)
+#define NL_OWN_PORT            (1<<2)
+#define NL_MSG_PEEK            (1<<3)
+#define NL_NO_AUTO_ACK         (1<<4)
+
+struct nl_cb;
+struct nl_sock
+{
+       struct sockaddr_nl      s_local;
+       struct sockaddr_nl      s_peer;
+       int                     s_fd;
+       int                     s_proto;
+       unsigned int            s_seq_next;
+       unsigned int            s_seq_expect;
+       int                     s_flags;
+       struct nl_cb *          s_cb;
+};
+
+
+extern struct nl_sock *        nl_socket_alloc(void);
+extern struct nl_sock *        nl_socket_alloc_cb(struct nl_cb *);
+extern void            nl_socket_free(struct nl_sock *);
+
+extern void            nl_socket_set_local_port(struct nl_sock *, uint32_t);
+
+extern int             nl_socket_add_memberships(struct nl_sock *, int, ...);
+extern int             nl_socket_drop_memberships(struct nl_sock *, int, ...);
+
+extern int             nl_socket_set_buffer_size(struct nl_sock *, int, int);
+extern int             nl_socket_set_passcred(struct nl_sock *, int);
+extern int             nl_socket_recv_pktinfo(struct nl_sock *, int);
+
+extern void            nl_socket_disable_seq_check(struct nl_sock *);
+
+extern int             nl_socket_set_nonblocking(struct nl_sock *);
+
+/**
+ * Use next sequence number
+ * @arg sk             Netlink socket.
+ *
+ * Uses the next available sequence number and increases the counter
+ * by one for subsequent calls.
+ *
+ * @return Unique serial sequence number
+ */
+static inline unsigned int nl_socket_use_seq(struct nl_sock *sk)
+{
+       return sk->s_seq_next++;
+}
+
+/**
+ * Disable automatic request for ACK
+ * @arg sk             Netlink socket.
+ *
+ * The default behaviour of a socket is to request an ACK for
+ * each message sent to allow for the caller to synchronize to
+ * the completion of the netlink operation. This function
+ * disables this behaviour and will result in requests being
+ * sent which will not have the NLM_F_ACK flag set automatically.
+ * However, it is still possible for the caller to set the
+ * NLM_F_ACK flag explicitely.
+ */
+static inline void nl_socket_disable_auto_ack(struct nl_sock *sk)
+{
+       sk->s_flags |= NL_NO_AUTO_ACK;
+}
+
+/**
+ * Enable automatic request for ACK (default)
+ * @arg sk             Netlink socket.
+ * @see nl_socket_disable_auto_ack
+ */
+static inline void nl_socket_enable_auto_ack(struct nl_sock *sk)
+{
+       sk->s_flags &= ~NL_NO_AUTO_ACK;
+}
+
+/**
+ * @name Source Idenficiation
+ * @{
+ */
+
+static inline uint32_t nl_socket_get_local_port(struct nl_sock *sk)
+{
+       return sk->s_local.nl_pid;
+}
+
+/**
+ * Join multicast groups (deprecated)
+ * @arg sk             Netlink socket.
+ * @arg groups         Bitmask of groups to join.
+ *
+ * This function defines the old way of joining multicast group which
+ * has to be done prior to calling nl_connect(). It works on any kernel
+ * version but is very limited as only 32 groups can be joined.
+ */
+static inline void nl_join_groups(struct nl_sock *sk, int groups)
+{
+       sk->s_local.nl_groups |= groups;
+}
+
+/**
+ * @name Peer Identfication
+ * @{
+ */
+
+static inline uint32_t nl_socket_get_peer_port(struct nl_sock *sk)
+{
+       return sk->s_peer.nl_pid;
+}
+
+static inline void nl_socket_set_peer_port(struct nl_sock *sk, uint32_t port)
+{
+       sk->s_peer.nl_pid = port;
+}
+
+/** @} */
+
+/**
+ * @name File Descriptor
+ * @{
+ */
+
+static inline int nl_socket_get_fd(struct nl_sock *sk)
+{
+       return sk->s_fd;
+}
+
+/**
+ * Enable use of MSG_PEEK when reading from socket
+ * @arg sk             Netlink socket.
+ */
+static inline void nl_socket_enable_msg_peek(struct nl_sock *sk)
+{
+       sk->s_flags |= NL_MSG_PEEK;
+}
+
+/**
+ * Disable use of MSG_PEEK when reading from socket
+ * @arg sk             Netlink socket.
+ */
+static inline void nl_socket_disable_msg_peek(struct nl_sock *sk)
+{
+       sk->s_flags &= ~NL_MSG_PEEK;
+}
+
+/**
+ * @name Callback Handler
+ * @{
+ */
+
+static inline struct nl_cb *nl_socket_get_cb(struct nl_sock *sk)
+{
+       return nl_cb_get(sk->s_cb);
+}
+
+static inline void nl_socket_set_cb(struct nl_sock *sk, struct nl_cb *cb)
+{
+       nl_cb_put(sk->s_cb);
+       sk->s_cb = nl_cb_get(cb);
+}
+
+/**
+ * Modify the callback handler associated to the socket
+ * @arg sk             Netlink socket.
+ * @arg type           which type callback to set
+ * @arg kind           kind of callback
+ * @arg func           callback function
+ * @arg arg            argument to be passwd to callback function
+ *
+ * @see nl_cb_set
+ */
+static inline int nl_socket_modify_cb(struct nl_sock *sk, enum nl_cb_type type,
+                       enum nl_cb_kind kind, nl_recvmsg_msg_cb_t func,
+                       void *arg)
+{
+       return nl_cb_set(sk->s_cb, type, kind, func, arg);
+}
+
+/** @} */
+
+static inline int nl_socket_add_membership(struct nl_sock *sk, int group)
+{
+       return nl_socket_add_memberships(sk, group, 0);
+}
+
+
+static inline int nl_socket_drop_membership(struct nl_sock *sk, int group)
+{
+       return nl_socket_drop_memberships(sk, group, 0);
+}
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/types.h b/package/libnl-tiny/src/include/netlink/types.h
new file mode 100644 (file)
index 0000000..6d8aaf8
--- /dev/null
@@ -0,0 +1,117 @@
+/*
+ * netlink/netlink-types.h     Netlink Types
+ *
+ *     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>
+ */
+
+#ifndef __NETLINK_TYPES_H_
+#define __NETLINK_TYPES_H_
+
+#include <stdio.h>
+
+/**
+ * Dumping types (dp_type)
+ * @ingroup utils
+ */
+enum nl_dump_type {
+       NL_DUMP_LINE,           /**< Dump object briefly on one line */
+       NL_DUMP_DETAILS,        /**< Dump all attributes but no statistics */
+       NL_DUMP_STATS,          /**< Dump all attributes including statistics */
+       NL_DUMP_ENV,            /**< Dump all attribtues as env variables */
+       __NL_DUMP_MAX,
+};
+#define NL_DUMP_MAX (__NL_DUMP_MAX - 1)
+
+/**
+ * Dumping parameters
+ * @ingroup utils
+ */
+struct nl_dump_params
+{
+       /**
+        * Specifies the type of dump that is requested.
+        */
+       enum nl_dump_type       dp_type;
+
+       /**
+        * Specifies the number of whitespaces to be put in front
+        * of every new line (indentation).
+        */
+       int                     dp_prefix;
+
+       /**
+        * Causes the cache index to be printed for each element.
+        */
+       int                     dp_print_index;
+
+       /**
+        * Causes each element to be prefixed with the message type.
+        */
+       int                     dp_dump_msgtype;
+
+       /**
+        * A callback invoked for output
+        *
+        * Passed arguments are:
+        *  - dumping parameters
+        *  - string to append to the output
+        */
+       void                    (*dp_cb)(struct nl_dump_params *, char *);
+
+       /**
+        * A callback invoked for every new line, can be used to
+        * customize the indentation.
+        *
+        * Passed arguments are:
+        *  - dumping parameters
+        *  - line number starting from 0
+        */
+       void                    (*dp_nl_cb)(struct nl_dump_params *, int);
+
+       /**
+        * User data pointer, can be used to pass data to callbacks.
+        */
+       void                    *dp_data;
+
+       /**
+        * File descriptor the dumping output should go to
+        */
+       FILE *                  dp_fd;
+
+       /**
+        * Alternatively the output may be redirected into a buffer
+        */
+       char *                  dp_buf;
+
+       /**
+        * Length of the buffer dp_buf
+        */
+       size_t                  dp_buflen;
+
+       /**
+        * PRIVATE
+        * Set if a dump was performed prior to the actual dump handler.
+        */
+       int                     dp_pre_dump;
+
+       /**
+        * PRIVATE
+        * Owned by the current caller
+        */
+       int                     dp_ivar;
+
+       unsigned int            dp_line;
+};
+
+#define min_t(type,x,y) \
+       ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
+#define max_t(type,x,y) \
+       ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
+
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/utils.h b/package/libnl-tiny/src/include/netlink/utils.h
new file mode 100644 (file)
index 0000000..480bab6
--- /dev/null
@@ -0,0 +1,78 @@
+/*
+ * netlink/utils.h             Utility Functions
+ *
+ *     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_UTILS_H_
+#define NETLINK_UTILS_H_
+
+#include <netlink/netlink.h>
+#include <netlink/list.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @name Probability Constants
+ * @{
+ */
+
+/**
+ * Lower probability limit
+ * @ingroup utils
+ */
+#define NL_PROB_MIN 0x0
+
+/**
+ * Upper probability limit
+ * @ingroup utils
+ */
+#define NL_PROB_MAX 0xffffffff
+
+/** @} */
+
+/* unit pretty-printing */
+extern double  nl_cancel_down_bytes(unsigned long long, char **);
+extern double  nl_cancel_down_bits(unsigned long long, char **);
+extern double  nl_cancel_down_us(uint32_t, char **);
+
+/* generic unit translations */
+extern long    nl_size2int(const char *);
+extern long    nl_prob2int(const char *);
+
+/* time translations */
+extern int     nl_get_hz(void);
+extern uint32_t        nl_us2ticks(uint32_t);
+extern uint32_t        nl_ticks2us(uint32_t);
+extern int     nl_str2msec(const char *, uint64_t *);
+extern char *  nl_msec2str(uint64_t, char *, size_t);
+
+/* link layer protocol translations */
+extern char *  nl_llproto2str(int, char *, size_t);
+extern int     nl_str2llproto(const char *);
+
+/* ethernet protocol translations */
+extern char *  nl_ether_proto2str(int, char *, size_t);
+extern int     nl_str2ether_proto(const char *);
+
+/* IP protocol translations */
+extern char *  nl_ip_proto2str(int, char *, size_t);
+extern int     nl_str2ip_proto(const char *);
+
+/* Dumping helpers */
+extern void    nl_new_line(struct nl_dump_params *);
+extern void    nl_dump(struct nl_dump_params *, const char *, ...);
+extern void    nl_dump_line(struct nl_dump_params *, const char *, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/package/libnl-tiny/src/include/netlink/version.h b/package/libnl-tiny/src/include/netlink/version.h
new file mode 100644 (file)
index 0000000..6a316d4
--- /dev/null
@@ -0,0 +1,18 @@
+/*
+ * netlink/version.h   Compile Time Versioning Information
+ *
+ *     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) 2008 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef NETLINK_VERSION_H_
+#define NETLINK_VERSION_H_
+
+#define LIBNL_STRING "libnl"
+#define LIBNL_VERSION "2.0"
+
+#endif
diff --git a/package/libnl-tiny/src/msg.c b/package/libnl-tiny/src/msg.c
new file mode 100644 (file)
index 0000000..e84c281
--- /dev/null
@@ -0,0 +1,566 @@
+/*
+ * lib/msg.c           Netlink Messages 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>
+ */
+
+/**
+ * @ingroup core
+ * @defgroup msg Messages
+ * Netlink Message Construction/Parsing Interface
+ * 
+ * The following information is partly extracted from RFC3549
+ * (ftp://ftp.rfc-editor.org/in-notes/rfc3549.txt)
+ *
+ * @par Message Format
+ * Netlink messages consist of a byte stream with one or multiple
+ * Netlink headers and an associated payload.  If the payload is too big
+ * to fit into a single message it, can be split over multiple Netlink
+ * messages, collectively called a multipart message.  For multipart
+ * messages, the first and all following headers have the \c NLM_F_MULTI
+ * Netlink header flag set, except for the last header which has the
+ * Netlink header type \c NLMSG_DONE.
+ *
+ * @par
+ * The Netlink message header (\link nlmsghdr struct nlmsghdr\endlink) is shown below.
+ * @code   
+ * 0                   1                   2                   3
+ * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                          Length                             |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |            Type              |           Flags              |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                      Sequence Number                        |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                      Process ID (PID)                       |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * @endcode
+ *
+ * @par
+ * The netlink message header and payload must be aligned properly:
+ * @code
+ *  <------- NLMSG_ALIGN(hlen) ------> <---- NLMSG_ALIGN(len) --->
+ * +----------------------------+- - -+- - - - - - - - - - -+- - -+
+ * |           Header           | Pad |       Payload       | Pad |
+ * |      struct nlmsghdr       |     |                     |     |
+ * +----------------------------+- - -+- - - - - - - - - - -+- - -+
+ * @endcode
+ * @par
+ * Message Format:
+ * @code
+ *    <--- nlmsg_total_size(payload)  --->
+ *    <-- nlmsg_msg_size(payload) ->
+ *   +----------+- - -+-------------+- - -+-------- - -
+ *   | nlmsghdr | Pad |   Payload   | Pad | nlmsghdr
+ *   +----------+- - -+-------------+- - -+-------- - -
+ *   nlmsg_data(nlh)---^                   ^
+ *   nlmsg_next(nlh)-----------------------+
+ * @endcode
+ * @par
+ * The payload may consist of arbitary data but may have strict
+ * alignment and formatting rules depening on the specific netlink
+ * families.
+ * @par
+ * @code
+ *    <---------------------- nlmsg_len(nlh) --------------------->
+ *    <------ hdrlen ------>       <- nlmsg_attrlen(nlh, hdrlen) ->
+ *   +----------------------+- - -+--------------------------------+
+ *   |     Family Header    | Pad |           Attributes           |
+ *   +----------------------+- - -+--------------------------------+
+ *   nlmsg_attrdata(nlh, hdrlen)---^
+ * @endcode
+ * @par The ACK Netlink Message
+ * This message is actually used to denote both an ACK and a NACK.
+ * Typically, the direction is from FEC to CPC (in response to an ACK
+ * request message).  However, the CPC should be able to send ACKs back
+ * to FEC when requested.
+ * @code
+ *  0                   1                   2                   3
+ *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                       Netlink message header                  |
+ * |                       type = NLMSG_ERROR                      |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                          Error code                           |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                       OLD Netlink message header              |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * @endcode
+ *
+ * @par Example
+ * @code
+ * // Various methods exist to create/allocate a new netlink
+ * // message. 
+ * //
+ * // nlmsg_alloc() will allocate an empty netlink message with
+ * // a maximum payload size which defaults to the page size of
+ * // the system. This default size can be modified using the
+ * // function nlmsg_set_default_size().
+ * struct nl_msg *msg = nlmsg_alloc();
+ *
+ * // Very often, the message type and message flags are known
+ * // at allocation time while the other fields are auto generated:
+ * struct nl_msg *msg = nlmsg_alloc_simple(MY_TYPE, MY_FLAGS);
+ *
+ * // Alternatively an existing netlink message header can be used
+ * // to inherit the header values:
+ * struct nlmsghdr hdr = {
+ *     .nlmsg_type = MY_TYPE,
+ *     .nlmsg_flags = MY_FLAGS,
+ * };
+ * struct nl_msg *msg = nlmsg_inherit(&hdr);
+ *
+ * // Last but not least, netlink messages received from netlink sockets
+ * // can be converted into nl_msg objects using nlmsg_convert(). This
+ * // will create a message with a maximum payload size which equals the
+ * // length of the existing netlink message, therefore no more data can
+ * // be appened without calling nlmsg_expand() first.
+ * struct nl_msg *msg = nlmsg_convert(nlh_from_nl_sock);
+ *
+ * // Payload may be added to the message via nlmsg_append(). The fourth
+ * // parameter specifies the number of alignment bytes the data should
+ * // be padding with at the end. Common values are 0 to disable it or
+ * // NLMSG_ALIGNTO to ensure proper netlink message padding.
+ * nlmsg_append(msg, &mydata, sizeof(mydata), 0);
+ *
+ * // Sometimes it may be necessary to reserve room for data but defer
+ * // the actual copying to a later point, nlmsg_reserve() can be used
+ * // for this purpose:
+ * void *data = nlmsg_reserve(msg, sizeof(mydata), NLMSG_ALIGNTO);
+ *
+ * // Attributes may be added using the attributes interface.
+ *
+ * // After successful use of the message, the memory must be freed
+ * // using nlmsg_free()
+ * nlmsg_free(msg);
+ * @endcode
+ * 
+ * @par 4) Parsing messages
+ * @code
+ * int n;
+ * unsigned char *buf;
+ * struct nlmsghdr *hdr;
+ *
+ * n = nl_recv(handle, NULL, &buf);
+ * 
+ * hdr = (struct nlmsghdr *) buf;
+ * while (nlmsg_ok(hdr, n)) {
+ *     // Process message here...
+ *     hdr = nlmsg_next(hdr, &n);
+ * }
+ * @endcode
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/utils.h>
+#include <netlink/cache.h>
+#include <netlink/attr.h>
+#include <netlink/msg.h>
+#include <linux/socket.h>
+
+static size_t default_msg_size;
+
+static void __init init_msg_size(void)
+{
+       default_msg_size = getpagesize();
+}
+
+/**
+ * @name Attribute Access
+ * @{
+ */
+
+//** @} */
+
+/**
+ * @name Message Parsing
+ * @{
+ */
+
+/**
+ * check if the netlink message fits into the remaining bytes
+ * @arg nlh            netlink message header
+ * @arg remaining      number of bytes remaining in message stream
+ */
+int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
+{
+       return (remaining >= sizeof(struct nlmsghdr) &&
+               nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
+               nlh->nlmsg_len <= remaining);
+}
+
+/**
+ * next netlink message in message stream
+ * @arg nlh            netlink message header
+ * @arg remaining      number of bytes remaining in message stream
+ *
+ * @returns the next netlink message in the message stream and
+ * decrements remaining by the size of the current message.
+ */
+struct nlmsghdr *nlmsg_next(struct nlmsghdr *nlh, int *remaining)
+{
+       int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
+
+       *remaining -= totlen;
+
+       return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
+}
+
+/**
+ * parse attributes of a netlink message
+ * @arg nlh            netlink message header
+ * @arg hdrlen         length of family specific header
+ * @arg tb             destination array with maxtype+1 elements
+ * @arg maxtype                maximum attribute type to be expected
+ * @arg policy         validation policy
+ *
+ * See nla_parse()
+ */
+int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[],
+               int maxtype, struct nla_policy *policy)
+{
+       if (!nlmsg_valid_hdr(nlh, hdrlen))
+               return -NLE_MSG_TOOSHORT;
+
+       return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
+                        nlmsg_attrlen(nlh, hdrlen), policy);
+}
+
+/**
+ * nlmsg_validate - validate a netlink message including attributes
+ * @arg nlh            netlinket message header
+ * @arg hdrlen         length of familiy specific header
+ * @arg maxtype                maximum attribute type to be expected
+ * @arg policy         validation policy
+ */
+int nlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
+                  struct nla_policy *policy)
+{
+       if (!nlmsg_valid_hdr(nlh, hdrlen))
+               return -NLE_MSG_TOOSHORT;
+
+       return nla_validate(nlmsg_attrdata(nlh, hdrlen),
+                           nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
+}
+
+/** @} */
+
+/**
+ * @name Message Building/Access
+ * @{
+ */
+
+static struct nl_msg *__nlmsg_alloc(size_t len)
+{
+       struct nl_msg *nm;
+
+       nm = calloc(1, sizeof(*nm));
+       if (!nm)
+               goto errout;
+
+       nm->nm_refcnt = 1;
+
+       nm->nm_nlh = malloc(len);
+       if (!nm->nm_nlh)
+               goto errout;
+
+       memset(nm->nm_nlh, 0, sizeof(struct nlmsghdr));
+
+       nm->nm_protocol = -1;
+       nm->nm_size = len;
+       nm->nm_nlh->nlmsg_len = nlmsg_total_size(0);
+
+       NL_DBG(2, "msg %p: Allocated new message, maxlen=%zu\n", nm, len);
+
+       return nm;
+errout:
+       free(nm);
+       return NULL;
+}
+
+/**
+ * Allocate a new netlink message with the default maximum payload size.
+ *
+ * Allocates a new netlink message without any further payload. The
+ * maximum payload size defaults to PAGESIZE or as otherwise specified
+ * with nlmsg_set_default_size().
+ *
+ * @return Newly allocated netlink message or NULL.
+ */
+struct nl_msg *nlmsg_alloc(void)
+{
+       return __nlmsg_alloc(default_msg_size);
+}
+
+/**
+ * Allocate a new netlink message with maximum payload size specified.
+ */
+struct nl_msg *nlmsg_alloc_size(size_t max)
+{
+       return __nlmsg_alloc(max);
+}
+
+/**
+ * Allocate a new netlink message and inherit netlink message header
+ * @arg hdr            Netlink message header template
+ *
+ * Allocates a new netlink message and inherits the original message
+ * header. If \a hdr is not NULL it will be used as a template for
+ * the netlink message header, otherwise the header is left blank.
+ * 
+ * @return Newly allocated netlink message or NULL
+ */
+struct nl_msg *nlmsg_inherit(struct nlmsghdr *hdr)
+{
+       struct nl_msg *nm;
+
+       nm = nlmsg_alloc();
+       if (nm && hdr) {
+               struct nlmsghdr *new = nm->nm_nlh;
+
+               new->nlmsg_type = hdr->nlmsg_type;
+               new->nlmsg_flags = hdr->nlmsg_flags;
+               new->nlmsg_seq = hdr->nlmsg_seq;
+               new->nlmsg_pid = hdr->nlmsg_pid;
+       }
+
+       return nm;
+}
+
+/**
+ * Allocate a new netlink message
+ * @arg nlmsgtype      Netlink message type
+ * @arg flags          Message flags.
+ *
+ * @return Newly allocated netlink message or NULL.
+ */
+struct nl_msg *nlmsg_alloc_simple(int nlmsgtype, int flags)
+{
+       struct nl_msg *msg;
+       struct nlmsghdr nlh = {
+               .nlmsg_type = nlmsgtype,
+               .nlmsg_flags = flags,
+       };
+
+       msg = nlmsg_inherit(&nlh);
+       if (msg)
+               NL_DBG(2, "msg %p: Allocated new simple message\n", msg);
+
+       return msg;
+}
+
+/**
+ * Set the default maximum message payload size for allocated messages
+ * @arg max            Size of payload in bytes.
+ */
+void nlmsg_set_default_size(size_t max)
+{
+       if (max < nlmsg_total_size(0))
+               max = nlmsg_total_size(0);
+
+       default_msg_size = max;
+}
+
+/**
+ * Convert a netlink message received from a netlink socket to a nl_msg
+ * @arg hdr            Netlink message received from netlink socket.
+ *
+ * Allocates a new netlink message and copies all of the data pointed to
+ * by \a hdr into the new message object.
+ *
+ * @return Newly allocated netlink message or NULL.
+ */
+struct nl_msg *nlmsg_convert(struct nlmsghdr *hdr)
+{
+       struct nl_msg *nm;
+
+       nm = __nlmsg_alloc(NLMSG_ALIGN(hdr->nlmsg_len));
+       if (!nm)
+               goto errout;
+
+       memcpy(nm->nm_nlh, hdr, hdr->nlmsg_len);
+
+       return nm;
+errout:
+       nlmsg_free(nm);
+       return NULL;
+}
+
+/**
+ * Reserve room for additional data in a netlink message
+ * @arg n              netlink message
+ * @arg len            length of additional data to reserve room for
+ * @arg pad            number of bytes to align data to
+ *
+ * Reserves room for additional data at the tail of the an
+ * existing netlink message. Eventual padding required will
+ * be zeroed out.
+ *
+ * @return Pointer to start of additional data tailroom or NULL.
+ */
+void *nlmsg_reserve(struct nl_msg *n, size_t len, int pad)
+{
+       void *buf = n->nm_nlh;
+       size_t nlmsg_len = n->nm_nlh->nlmsg_len;
+       size_t tlen;
+
+       tlen = pad ? ((len + (pad - 1)) & ~(pad - 1)) : len;
+
+       if ((tlen + nlmsg_len) > n->nm_size)
+               return NULL;
+
+       buf += nlmsg_len;
+       n->nm_nlh->nlmsg_len += tlen;
+
+       if (tlen > len)
+               memset(buf + len, 0, tlen - len);
+
+       NL_DBG(2, "msg %p: Reserved %zu bytes, pad=%d, nlmsg_len=%d\n",
+                 n, len, pad, n->nm_nlh->nlmsg_len);
+
+       return buf;
+}
+
+/**
+ * Append data to tail of a netlink message
+ * @arg n              netlink message
+ * @arg data           data to add
+ * @arg len            length of data
+ * @arg pad            Number of bytes to align data to.
+ *
+ * Extends the netlink message as needed and appends the data of given
+ * length to the message. 
+ *
+ * @return 0 on success or a negative error code
+ */
+int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
+{
+       void *tmp;
+
+       tmp = nlmsg_reserve(n, len, pad);
+       if (tmp == NULL)
+               return -NLE_NOMEM;
+
+       memcpy(tmp, data, len);
+       NL_DBG(2, "msg %p: Appended %zu bytes with padding %d\n", n, len, pad);
+
+       return 0;
+}
+
+/**
+ * Add a netlink message header to a netlink message
+ * @arg n              netlink message
+ * @arg pid            netlink process id or NL_AUTO_PID
+ * @arg seq            sequence number of message or NL_AUTO_SEQ
+ * @arg type           message type
+ * @arg payload                length of message payload
+ * @arg flags          message flags
+ *
+ * Adds or overwrites the netlink message header in an existing message
+ * object. If \a payload is greater-than zero additional room will be
+ * reserved, f.e. for family specific headers. It can be accesed via
+ * nlmsg_data().
+ *
+ * @return A pointer to the netlink message header or NULL.
+ */
+struct nlmsghdr *nlmsg_put(struct nl_msg *n, uint32_t pid, uint32_t seq,
+                          int type, int payload, int flags)
+{
+       struct nlmsghdr *nlh;
+
+       if (n->nm_nlh->nlmsg_len < NLMSG_HDRLEN)
+               BUG();
+
+       nlh = (struct nlmsghdr *) n->nm_nlh;
+       nlh->nlmsg_type = type;
+       nlh->nlmsg_flags = flags;
+       nlh->nlmsg_pid = pid;
+       nlh->nlmsg_seq = seq;
+
+       NL_DBG(2, "msg %p: Added netlink header type=%d, flags=%d, pid=%d, "
+                 "seq=%d\n", n, type, flags, pid, seq);
+
+       if (payload > 0 &&
+           nlmsg_reserve(n, payload, NLMSG_ALIGNTO) == NULL)
+               return NULL;
+
+       return nlh;
+}
+
+/**
+ * Release a reference from an netlink message
+ * @arg msg            message to release reference from
+ *
+ * Frees memory after the last reference has been released.
+ */
+void nlmsg_free(struct nl_msg *msg)
+{
+       if (!msg)
+               return;
+
+       msg->nm_refcnt--;
+       NL_DBG(4, "Returned message reference %p, %d remaining\n",
+              msg, msg->nm_refcnt);
+
+       if (msg->nm_refcnt < 0)
+               BUG();
+
+       if (msg->nm_refcnt <= 0) {
+               free(msg->nm_nlh);
+               free(msg);
+               NL_DBG(2, "msg %p: Freed\n", msg);
+       }
+}
+
+/** @} */
+
+/**
+ * @name Direct Parsing
+ * @{
+ */
+
+/** @cond SKIP */
+struct dp_xdata {
+       void (*cb)(struct nl_object *, void *);
+       void *arg;
+};
+/** @endcond */
+
+static int parse_cb(struct nl_object *obj, struct nl_parser_param *p)
+{
+       struct dp_xdata *x = p->pp_arg;
+
+       x->cb(obj, x->arg);
+       return 0;
+}
+
+int nl_msg_parse(struct nl_msg *msg, void (*cb)(struct nl_object *, void *),
+                void *arg)
+{
+       struct nl_cache_ops *ops;
+       struct nl_parser_param p = {
+               .pp_cb = parse_cb
+       };
+       struct dp_xdata x = {
+               .cb = cb,
+               .arg = arg,
+       };
+
+       ops = nl_cache_ops_associate(nlmsg_get_proto(msg),
+                                    nlmsg_hdr(msg)->nlmsg_type);
+       if (ops == NULL)
+               return -NLE_MSGTYPE_NOSUPPORT;
+       p.pp_arg = &x;
+
+       return nl_cache_parse(ops, NULL, nlmsg_hdr(msg), &p);
+}
+
+/** @} */
diff --git a/package/libnl-tiny/src/nl.c b/package/libnl-tiny/src/nl.c
new file mode 100644 (file)
index 0000000..99e9aeb
--- /dev/null
@@ -0,0 +1,720 @@
+/*
+ * lib/nl.c            Core Netlink 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>
+ */
+
+/**
+ * @defgroup core Core
+ *
+ * @details
+ * @par 1) Connecting the socket
+ * @code
+ * // Bind and connect the socket to a protocol, NETLINK_ROUTE in this example.
+ * nl_connect(sk, NETLINK_ROUTE);
+ * @endcode
+ *
+ * @par 2) Sending data
+ * @code
+ * // The most rudimentary method is to use nl_sendto() simply pushing
+ * // a piece of data to the other netlink peer. This method is not
+ * // recommended.
+ * const char buf[] = { 0x01, 0x02, 0x03, 0x04 };
+ * nl_sendto(sk, buf, sizeof(buf));
+ *
+ * // A more comfortable interface is nl_send() taking a pointer to
+ * // a netlink message.
+ * struct nl_msg *msg = my_msg_builder();
+ * nl_send(sk, nlmsg_hdr(msg));
+ *
+ * // nl_sendmsg() provides additional control over the sendmsg() message
+ * // header in order to allow more specific addressing of multiple peers etc.
+ * struct msghdr hdr = { ... };
+ * nl_sendmsg(sk, nlmsg_hdr(msg), &hdr);
+ *
+ * // You're probably too lazy to fill out the netlink pid, sequence number
+ * // and message flags all the time. nl_send_auto_complete() automatically
+ * // extends your message header as needed with an appropriate sequence
+ * // number, the netlink pid stored in the netlink socket and the message
+ * // flags NLM_F_REQUEST and NLM_F_ACK (if not disabled in the socket)
+ * nl_send_auto_complete(sk, nlmsg_hdr(msg));
+ *
+ * // Simple protocols don't require the complex message construction interface
+ * // and may favour nl_send_simple() to easly send a bunch of payload
+ * // encapsulated in a netlink message header.
+ * nl_send_simple(sk, MY_MSG_TYPE, 0, buf, sizeof(buf));
+ * @endcode
+ *
+ * @par 3) Receiving data
+ * @code
+ * // nl_recv() receives a single message allocating a buffer for the message
+ * // content and gives back the pointer to you.
+ * struct sockaddr_nl peer;
+ * unsigned char *msg;
+ * nl_recv(sk, &peer, &msg);
+ *
+ * // nl_recvmsgs() receives a bunch of messages until the callback system
+ * // orders it to state, usually after receving a compolete multi part
+ * // message series.
+ * nl_recvmsgs(sk, my_callback_configuration);
+ *
+ * // nl_recvmsgs_default() acts just like nl_recvmsg() but uses the callback
+ * // configuration stored in the socket.
+ * nl_recvmsgs_default(sk);
+ *
+ * // In case you want to wait for the ACK to be recieved that you requested
+ * // with your latest message, you can call nl_wait_for_ack()
+ * nl_wait_for_ack(sk);
+ * @endcode
+ *
+ * @par 4) Closing
+ * @code
+ * // Close the socket first to release kernel memory
+ * nl_close(sk);
+ * @endcode
+ * 
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/utils.h>
+#include <netlink/handlers.h>
+#include <netlink/msg.h>
+#include <netlink/attr.h>
+
+/**
+ * @name Connection Management
+ * @{
+ */
+
+/**
+ * Create and connect netlink socket.
+ * @arg sk             Netlink socket.
+ * @arg protocol       Netlink protocol to use.
+ *
+ * Creates a netlink socket using the specified protocol, binds the socket
+ * and issues a connection attempt.
+ *
+ * @return 0 on success or a negative error code.
+ */
+int nl_connect(struct nl_sock *sk, int protocol)
+{
+       int err;
+       socklen_t addrlen;
+
+       sk->s_fd = socket(AF_NETLINK, SOCK_RAW, protocol);
+       if (sk->s_fd < 0) {
+               err = -nl_syserr2nlerr(errno);
+               goto errout;
+       }
+
+       if (!(sk->s_flags & NL_SOCK_BUFSIZE_SET)) {
+               err = nl_socket_set_buffer_size(sk, 0, 0);
+               if (err < 0)
+                       goto errout;
+       }
+
+       err = bind(sk->s_fd, (struct sockaddr*) &sk->s_local,
+                  sizeof(sk->s_local));
+       if (err < 0) {
+               err = -nl_syserr2nlerr(errno);
+               goto errout;
+       }
+
+       addrlen = sizeof(sk->s_local);
+       err = getsockname(sk->s_fd, (struct sockaddr *) &sk->s_local,
+                         &addrlen);
+       if (err < 0) {
+               err = -nl_syserr2nlerr(errno);
+               goto errout;
+       }
+
+       if (addrlen != sizeof(sk->s_local)) {
+               err = -NLE_NOADDR;
+               goto errout;
+       }
+
+       if (sk->s_local.nl_family != AF_NETLINK) {
+               err = -NLE_AF_NOSUPPORT;
+               goto errout;
+       }
+
+       sk->s_proto = protocol;
+
+       return 0;
+errout:
+       close(sk->s_fd);
+       sk->s_fd = -1;
+
+       return err;
+}
+
+/**
+ * Close/Disconnect netlink socket.
+ * @arg sk             Netlink socket.
+ */
+void nl_close(struct nl_sock *sk)
+{
+       if (sk->s_fd >= 0) {
+               close(sk->s_fd);
+               sk->s_fd = -1;
+       }
+
+       sk->s_proto = 0;
+}
+
+/** @} */
+
+/**
+ * @name Send
+ * @{
+ */
+
+/**
+ * Send raw data over netlink socket.
+ * @arg sk             Netlink socket.
+ * @arg buf            Data buffer.
+ * @arg size           Size of data buffer.
+ * @return Number of characters written on success or a negative error code.
+ */
+int nl_sendto(struct nl_sock *sk, void *buf, size_t size)
+{
+       int ret;
+
+       ret = sendto(sk->s_fd, buf, size, 0, (struct sockaddr *)
+                    &sk->s_peer, sizeof(sk->s_peer));
+       if (ret < 0)
+               return -nl_syserr2nlerr(errno);
+
+       return ret;
+}
+
+/**
+ * Send netlink message with control over sendmsg() message header.
+ * @arg sk             Netlink socket.
+ * @arg msg            Netlink message to be sent.
+ * @arg hdr            Sendmsg() message header.
+ * @return Number of characters sent on sucess or a negative error code.
+ */
+int nl_sendmsg(struct nl_sock *sk, struct nl_msg *msg, struct msghdr *hdr)
+{
+       struct nl_cb *cb;
+       int ret;
+
+       struct iovec iov = {
+               .iov_base = (void *) nlmsg_hdr(msg),
+               .iov_len = nlmsg_hdr(msg)->nlmsg_len,
+       };
+
+       hdr->msg_iov = &iov;
+       hdr->msg_iovlen = 1;
+
+       nlmsg_set_src(msg, &sk->s_local);
+
+       cb = sk->s_cb;
+       if (cb->cb_set[NL_CB_MSG_OUT])
+               if (nl_cb_call(cb, NL_CB_MSG_OUT, msg) != NL_OK)
+                       return 0;
+
+       ret = sendmsg(sk->s_fd, hdr, 0);
+       if (ret < 0)
+               return -nl_syserr2nlerr(errno);
+
+       return ret;
+}
+
+
+/**
+ * Send netlink message.
+ * @arg sk             Netlink socket.
+ * @arg msg            Netlink message to be sent.
+ * @see nl_sendmsg()
+ * @return Number of characters sent on success or a negative error code.
+ */
+int nl_send(struct nl_sock *sk, struct nl_msg *msg)
+{
+       struct sockaddr_nl *dst;
+       struct ucred *creds;
+       
+       struct msghdr hdr = {
+               .msg_name = (void *) &sk->s_peer,
+               .msg_namelen = sizeof(struct sockaddr_nl),
+       };
+
+       /* Overwrite destination if specified in the message itself, defaults
+        * to the peer address of the socket.
+        */
+       dst = nlmsg_get_dst(msg);
+       if (dst->nl_family == AF_NETLINK)
+               hdr.msg_name = dst;
+
+       /* Add credentials if present. */
+       creds = nlmsg_get_creds(msg);
+       if (creds != NULL) {
+               char buf[CMSG_SPACE(sizeof(struct ucred))];
+               struct cmsghdr *cmsg;
+
+               hdr.msg_control = buf;
+               hdr.msg_controllen = sizeof(buf);
+
+               cmsg = CMSG_FIRSTHDR(&hdr);
+               cmsg->cmsg_level = SOL_SOCKET;
+               cmsg->cmsg_type = SCM_CREDENTIALS;
+               cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
+               memcpy(CMSG_DATA(cmsg), creds, sizeof(struct ucred));
+       }
+
+       return nl_sendmsg(sk, msg, &hdr);
+}
+
+/**
+ * Send netlink message and check & extend header values as needed.
+ * @arg sk             Netlink socket.
+ * @arg msg            Netlink message to be sent.
+ *
+ * Checks the netlink message \c nlh for completness and extends it
+ * as required before sending it out. Checked fields include pid,
+ * sequence nr, and flags.
+ *
+ * @see nl_send()
+ * @return Number of characters sent or a negative error code.
+ */
+int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
+{
+       struct nlmsghdr *nlh;
+       struct nl_cb *cb = sk->s_cb;
+
+       nlh = nlmsg_hdr(msg);
+       if (nlh->nlmsg_pid == 0)
+               nlh->nlmsg_pid = sk->s_local.nl_pid;
+
+       if (nlh->nlmsg_seq == 0)
+               nlh->nlmsg_seq = sk->s_seq_next++;
+
+       if (msg->nm_protocol == -1)
+               msg->nm_protocol = sk->s_proto;
+       
+       nlh->nlmsg_flags |= NLM_F_REQUEST;
+
+       if (!(sk->s_flags & NL_NO_AUTO_ACK))
+               nlh->nlmsg_flags |= NLM_F_ACK;
+
+       if (cb->cb_send_ow)
+               return cb->cb_send_ow(sk, msg);
+       else
+               return nl_send(sk, msg);
+}
+
+/**
+ * Send simple netlink message using nl_send_auto_complete()
+ * @arg sk             Netlink socket.
+ * @arg type           Netlink message type.
+ * @arg flags          Netlink message flags.
+ * @arg buf            Data buffer.
+ * @arg size           Size of data buffer.
+ *
+ * Builds a netlink message with the specified type and flags and
+ * appends the specified data as payload to the message.
+ *
+ * @see nl_send_auto_complete()
+ * @return Number of characters sent on success or a negative error code.
+ */
+int nl_send_simple(struct nl_sock *sk, int type, int flags, void *buf,
+                  size_t size)
+{
+       int err;
+       struct nl_msg *msg;
+
+       msg = nlmsg_alloc_simple(type, flags);
+       if (!msg)
+               return -NLE_NOMEM;
+
+       if (buf && size) {
+               err = nlmsg_append(msg, buf, size, NLMSG_ALIGNTO);
+               if (err < 0)
+                       goto errout;
+       }
+       
+
+       err = nl_send_auto_complete(sk, msg);
+errout:
+       nlmsg_free(msg);
+
+       return err;
+}
+
+/** @} */
+
+/**
+ * @name Receive
+ * @{
+ */
+
+/**
+ * Receive data from netlink socket
+ * @arg sk             Netlink socket.
+ * @arg nla            Destination pointer for peer's netlink address.
+ * @arg buf            Destination pointer for message content.
+ * @arg creds          Destination pointer for credentials.
+ *
+ * Receives a netlink message, allocates a buffer in \c *buf and
+ * stores the message content. The peer's netlink address is stored
+ * in \c *nla. The caller is responsible for freeing the buffer allocated
+ * in \c *buf if a positive value is returned.  Interruped system calls
+ * are handled by repeating the read. The input buffer size is determined
+ * by peeking before the actual read is done.
+ *
+ * A non-blocking sockets causes the function to return immediately with
+ * a return value of 0 if no data is available.
+ *
+ * @return Number of octets read, 0 on EOF or a negative error code.
+ */
+int nl_recv(struct nl_sock *sk, struct sockaddr_nl *nla,
+           unsigned char **buf, struct ucred **creds)
+{
+       int n;
+       int flags = 0;
+       static int page_size = 0;
+       struct iovec iov;
+       struct msghdr msg = {
+               .msg_name = (void *) nla,
+               .msg_namelen = sizeof(struct sockaddr_nl),
+               .msg_iov = &iov,
+               .msg_iovlen = 1,
+               .msg_control = NULL,
+               .msg_controllen = 0,
+               .msg_flags = 0,
+       };
+       struct cmsghdr *cmsg;
+
+       if (sk->s_flags & NL_MSG_PEEK)
+               flags |= MSG_PEEK;
+
+       if (page_size == 0)
+               page_size = getpagesize();
+
+       iov.iov_len = page_size;
+       iov.iov_base = *buf = malloc(iov.iov_len);
+
+       if (sk->s_flags & NL_SOCK_PASSCRED) {
+               msg.msg_controllen = CMSG_SPACE(sizeof(struct ucred));
+               msg.msg_control = calloc(1, msg.msg_controllen);
+       }
+retry:
+
+       n = recvmsg(sk->s_fd, &msg, flags);
+       if (!n)
+               goto abort;
+       else if (n < 0) {
+               if (errno == EINTR) {
+                       NL_DBG(3, "recvmsg() returned EINTR, retrying\n");
+                       goto retry;
+               } else if (errno == EAGAIN) {
+                       NL_DBG(3, "recvmsg() returned EAGAIN, aborting\n");
+                       goto abort;
+               } else {
+                       free(msg.msg_control);
+                       free(*buf);
+                       return -nl_syserr2nlerr(errno);
+               }
+       }
+
+       if (iov.iov_len < n ||
+           msg.msg_flags & MSG_TRUNC) {
+               /* Provided buffer is not long enough, enlarge it
+                * and try again. */
+               iov.iov_len *= 2;
+               iov.iov_base = *buf = realloc(*buf, iov.iov_len);
+               goto retry;
+       } else if (msg.msg_flags & MSG_CTRUNC) {
+               msg.msg_controllen *= 2;
+               msg.msg_control = realloc(msg.msg_control, msg.msg_controllen);
+               goto retry;
+       } else if (flags != 0) {
+               /* Buffer is big enough, do the actual reading */
+               flags = 0;
+               goto retry;
+       }
+
+       if (msg.msg_namelen != sizeof(struct sockaddr_nl)) {
+               free(msg.msg_control);
+               free(*buf);
+               return -NLE_NOADDR;
+       }
+
+       for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
+               if (cmsg->cmsg_level == SOL_SOCKET &&
+                   cmsg->cmsg_type == SCM_CREDENTIALS) {
+                       *creds = calloc(1, sizeof(struct ucred));
+                       memcpy(*creds, CMSG_DATA(cmsg), sizeof(struct ucred));
+                       break;
+               }
+       }
+
+       free(msg.msg_control);
+       return n;
+
+abort:
+       free(msg.msg_control);
+       free(*buf);
+       return 0;
+}
+
+#define NL_CB_CALL(cb, type, msg) \
+do { \
+       err = nl_cb_call(cb, type, msg); \
+       switch (err) { \
+       case NL_OK: \
+               err = 0; \
+               break; \
+       case NL_SKIP: \
+               goto skip; \
+       case NL_STOP: \
+               goto stop; \
+       default: \
+               goto out; \
+       } \
+} while (0)
+
+static int recvmsgs(struct nl_sock *sk, struct nl_cb *cb)
+{
+       int n, err = 0, multipart = 0;
+       unsigned char *buf = NULL;
+       struct nlmsghdr *hdr;
+       struct sockaddr_nl nla = {0};
+       struct nl_msg *msg = NULL;
+       struct ucred *creds = NULL;
+
+continue_reading:
+       NL_DBG(3, "Attempting to read from %p\n", sk);
+       if (cb->cb_recv_ow)
+               n = cb->cb_recv_ow(sk, &nla, &buf, &creds);
+       else
+               n = nl_recv(sk, &nla, &buf, &creds);
+
+       if (n <= 0)
+               return n;
+
+       NL_DBG(3, "recvmsgs(%p): Read %d bytes\n", sk, n);
+
+       hdr = (struct nlmsghdr *) buf;
+       while (nlmsg_ok(hdr, n)) {
+               NL_DBG(3, "recgmsgs(%p): Processing valid message...\n", sk);
+
+               nlmsg_free(msg);
+               msg = nlmsg_convert(hdr);
+               if (!msg) {
+                       err = -NLE_NOMEM;
+                       goto out;
+               }
+
+               nlmsg_set_proto(msg, sk->s_proto);
+               nlmsg_set_src(msg, &nla);
+               if (creds)
+                       nlmsg_set_creds(msg, creds);
+
+               /* Raw callback is the first, it gives the most control
+                * to the user and he can do his very own parsing. */
+               if (cb->cb_set[NL_CB_MSG_IN])
+                       NL_CB_CALL(cb, NL_CB_MSG_IN, msg);
+
+               /* Sequence number checking. The check may be done by
+                * the user, otherwise a very simple check is applied
+                * enforcing strict ordering */
+               if (cb->cb_set[NL_CB_SEQ_CHECK])
+                       NL_CB_CALL(cb, NL_CB_SEQ_CHECK, msg);
+               else if (hdr->nlmsg_seq != sk->s_seq_expect) {
+                       if (cb->cb_set[NL_CB_INVALID])
+                               NL_CB_CALL(cb, NL_CB_INVALID, msg);
+                       else {
+                               err = -NLE_SEQ_MISMATCH;
+                               goto out;
+                       }
+               }
+
+               if (hdr->nlmsg_type == NLMSG_DONE ||
+                   hdr->nlmsg_type == NLMSG_ERROR ||
+                   hdr->nlmsg_type == NLMSG_NOOP ||
+                   hdr->nlmsg_type == NLMSG_OVERRUN) {
+                       /* We can't check for !NLM_F_MULTI since some netlink
+                        * users in the kernel are broken. */
+                       sk->s_seq_expect++;
+                       NL_DBG(3, "recvmsgs(%p): Increased expected " \
+                              "sequence number to %d\n",
+                              sk, sk->s_seq_expect);
+               }
+
+               if (hdr->nlmsg_flags & NLM_F_MULTI)
+                       multipart = 1;
+       
+               /* Other side wishes to see an ack for this message */
+               if (hdr->nlmsg_flags & NLM_F_ACK) {
+                       if (cb->cb_set[NL_CB_SEND_ACK])
+                               NL_CB_CALL(cb, NL_CB_SEND_ACK, msg);
+                       else {
+                               /* FIXME: implement */
+                       }
+               }
+
+               /* messages terminates a multpart message, this is
+                * usually the end of a message and therefore we slip
+                * out of the loop by default. the user may overrule
+                * this action by skipping this packet. */
+               if (hdr->nlmsg_type == NLMSG_DONE) {
+                       multipart = 0;
+                       if (cb->cb_set[NL_CB_FINISH])
+                               NL_CB_CALL(cb, NL_CB_FINISH, msg);
+               }
+
+               /* Message to be ignored, the default action is to
+                * skip this message if no callback is specified. The
+                * user may overrule this action by returning
+                * NL_PROCEED. */
+               else if (hdr->nlmsg_type == NLMSG_NOOP) {
+                       if (cb->cb_set[NL_CB_SKIPPED])
+                               NL_CB_CALL(cb, NL_CB_SKIPPED, msg);
+                       else
+                               goto skip;
+               }
+
+               /* Data got lost, report back to user. The default action is to
+                * quit parsing. The user may overrule this action by retuning
+                * NL_SKIP or NL_PROCEED (dangerous) */
+               else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
+                       if (cb->cb_set[NL_CB_OVERRUN])
+                               NL_CB_CALL(cb, NL_CB_OVERRUN, msg);
+                       else {
+                               err = -NLE_MSG_OVERFLOW;
+                               goto out;
+                       }
+               }
+
+               /* Message carries a nlmsgerr */
+               else if (hdr->nlmsg_type == NLMSG_ERROR) {
+                       struct nlmsgerr *e = nlmsg_data(hdr);
+
+                       if (hdr->nlmsg_len < nlmsg_msg_size(sizeof(*e))) {
+                               /* Truncated error message, the default action
+                                * is to stop parsing. The user may overrule
+                                * this action by returning NL_SKIP or
+                                * NL_PROCEED (dangerous) */
+                               if (cb->cb_set[NL_CB_INVALID])
+                                       NL_CB_CALL(cb, NL_CB_INVALID, msg);
+                               else {
+                                       err = -NLE_MSG_TRUNC;
+                                       goto out;
+                               }
+                       } else if (e->error) {
+                               /* Error message reported back from kernel. */
+                               if (cb->cb_err) {
+                                       err = cb->cb_err(&nla, e,
+                                                          cb->cb_err_arg);
+                                       if (err < 0)
+                                               goto out;
+                                       else if (err == NL_SKIP)
+                                               goto skip;
+                                       else if (err == NL_STOP) {
+                                               err = -nl_syserr2nlerr(e->error);
+                                               goto out;
+                                       }
+                               } else {
+                                       err = -nl_syserr2nlerr(e->error);
+                                       goto out;
+                               }
+                       } else if (cb->cb_set[NL_CB_ACK])
+                               NL_CB_CALL(cb, NL_CB_ACK, msg);
+               } else {
+                       /* Valid message (not checking for MULTIPART bit to
+                        * get along with broken kernels. NL_SKIP has no
+                        * effect on this.  */
+                       if (cb->cb_set[NL_CB_VALID])
+                               NL_CB_CALL(cb, NL_CB_VALID, msg);
+               }
+skip:
+               err = 0;
+               hdr = nlmsg_next(hdr, &n);
+       }
+       
+       nlmsg_free(msg);
+       free(buf);
+       free(creds);
+       buf = NULL;
+       msg = NULL;
+       creds = NULL;
+
+       if (multipart) {
+               /* Multipart message not yet complete, continue reading */
+               goto continue_reading;
+       }
+stop:
+       err = 0;
+out:
+       nlmsg_free(msg);
+       free(buf);
+       free(creds);
+
+       return err;
+}
+
+/**
+ * Receive a set of messages from a netlink socket.
+ * @arg sk             Netlink socket.
+ * @arg cb             set of callbacks to control behaviour.
+ *
+ * Repeatedly calls nl_recv() or the respective replacement if provided
+ * by the application (see nl_cb_overwrite_recv()) and parses the
+ * received data as netlink messages. Stops reading if one of the
+ * callbacks returns NL_STOP or nl_recv returns either 0 or a negative error code.
+ *
+ * A non-blocking sockets causes the function to return immediately if
+ * no data is available.
+ *
+ * @return 0 on success or a negative error code from nl_recv().
+ */
+int nl_recvmsgs(struct nl_sock *sk, struct nl_cb *cb)
+{
+       if (cb->cb_recvmsgs_ow)
+               return cb->cb_recvmsgs_ow(sk, cb);
+       else
+               return recvmsgs(sk, cb);
+}
+
+
+static int ack_wait_handler(struct nl_msg *msg, void *arg)
+{
+       return NL_STOP;
+}
+
+/**
+ * Wait for ACK.
+ * @arg sk             Netlink socket.
+ * @pre The netlink socket must be in blocking state.
+ *
+ * Waits until an ACK is received for the latest not yet acknowledged
+ * netlink message.
+ */
+int nl_wait_for_ack(struct nl_sock *sk)
+{
+       int err;
+       struct nl_cb *cb;
+
+       cb = nl_cb_clone(sk->s_cb);
+       if (cb == NULL)
+               return -NLE_NOMEM;
+
+       nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL);
+       err = nl_recvmsgs(sk, cb);
+       nl_cb_put(cb);
+
+       return err;
+}
+
+/** @} */
+
+/** @} */
diff --git a/package/libnl-tiny/src/object.c b/package/libnl-tiny/src/object.c
new file mode 100644 (file)
index 0000000..1b18d9a
--- /dev/null
@@ -0,0 +1,309 @@
+/*
+ * lib/object.c                Generic Cacheable Object
+ *
+ *     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 cache
+ * @defgroup object Object
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/cache.h>
+#include <netlink/object.h>
+#include <netlink/utils.h>
+
+static inline struct nl_object_ops *obj_ops(struct nl_object *obj)
+{
+       if (!obj->ce_ops)
+               BUG();
+
+       return obj->ce_ops;
+}
+
+/**
+ * @name Object Creation/Deletion
+ * @{
+ */
+
+/**
+ * Allocate a new object of kind specified by the operations handle
+ * @arg ops            cache operations handle
+ * @return The new object or NULL
+ */
+struct nl_object *nl_object_alloc(struct nl_object_ops *ops)
+{
+       struct nl_object *new;
+
+       if (ops->oo_size < sizeof(*new))
+               BUG();
+
+       new = calloc(1, ops->oo_size);
+       if (!new)
+               return NULL;
+
+       new->ce_refcnt = 1;
+       nl_init_list_head(&new->ce_list);
+
+       new->ce_ops = ops;
+       if (ops->oo_constructor)
+               ops->oo_constructor(new);
+
+       NL_DBG(4, "Allocated new object %p\n", new);
+
+       return new;
+}
+
+#ifdef disabled
+/**
+ * Allocate a new object of kind specified by the name
+ * @arg kind           name of object type
+ * @return The new object or nULL
+ */
+int nl_object_alloc_name(const char *kind, struct nl_object **result)
+{
+       struct nl_cache_ops *ops;
+
+       ops = nl_cache_ops_lookup(kind);
+       if (!ops)
+               return -NLE_OPNOTSUPP;
+
+       if (!(*result = nl_object_alloc(ops->co_obj_ops)))
+               return -NLE_NOMEM;
+
+       return 0;
+}
+#endif
+
+struct nl_derived_object {
+       NLHDR_COMMON
+       char data;
+};
+
+/**
+ * Allocate a new object and copy all data from an existing object
+ * @arg obj            object to inherite data from
+ * @return The new object or NULL.
+ */
+struct nl_object *nl_object_clone(struct nl_object *obj)
+{
+       struct nl_object *new;
+       struct nl_object_ops *ops = obj_ops(obj);
+       int doff = offsetof(struct nl_derived_object, data);
+       int size;
+
+       new = nl_object_alloc(ops);
+       if (!new)
+               return NULL;
+
+       size = ops->oo_size - doff;
+       if (size < 0)
+               BUG();
+
+       new->ce_ops = obj->ce_ops;
+       new->ce_msgtype = obj->ce_msgtype;
+
+       if (size)
+               memcpy((void *)new + doff, (void *)obj + doff, size);
+
+       if (ops->oo_clone) {
+               if (ops->oo_clone(new, obj) < 0) {
+                       nl_object_free(new);
+                       return NULL;
+               }
+       } else if (size && ops->oo_free_data)
+               BUG();
+
+       return new;
+}
+
+/**
+ * Free a cacheable object
+ * @arg obj            object to free
+ *
+ * @return 0 or a negative error code.
+ */
+void nl_object_free(struct nl_object *obj)
+{
+       struct nl_object_ops *ops = obj_ops(obj);
+
+       if (obj->ce_refcnt > 0)
+               NL_DBG(1, "Warning: Freeing object in use...\n");
+
+       if (obj->ce_cache)
+               nl_cache_remove(obj);
+
+       if (ops->oo_free_data)
+               ops->oo_free_data(obj);
+
+       free(obj);
+
+       NL_DBG(4, "Freed object %p\n", obj);
+}
+
+/** @} */
+
+/**
+ * @name Reference Management
+ * @{
+ */
+
+/**
+ * Acquire a reference on a object
+ * @arg obj            object to acquire reference from
+ */
+void nl_object_get(struct nl_object *obj)
+{
+       obj->ce_refcnt++;
+       NL_DBG(4, "New reference to object %p, total %d\n",
+              obj, obj->ce_refcnt);
+}
+
+/**
+ * Release a reference from an object
+ * @arg obj            object to release reference from
+ */
+void nl_object_put(struct nl_object *obj)
+{
+       if (!obj)
+               return;
+
+       obj->ce_refcnt--;
+       NL_DBG(4, "Returned object reference %p, %d remaining\n",
+              obj, obj->ce_refcnt);
+
+       if (obj->ce_refcnt < 0)
+               BUG();
+
+       if (obj->ce_refcnt <= 0)
+               nl_object_free(obj);
+}
+
+/** @} */
+
+/**
+ * @name Utillities
+ * @{
+ */
+
+#ifdef disabled
+/**
+ * Dump this object according to the specified parameters
+ * @arg obj            object to dump
+ * @arg params         dumping parameters
+ */
+void nl_object_dump(struct nl_object *obj, struct nl_dump_params *params)
+{
+       dump_from_ops(obj, params);
+}
+
+/**
+ * Check if the identifiers of two objects are identical 
+ * @arg a              an object
+ * @arg b              another object of same type
+ *
+ * @return true if both objects have equal identifiers, otherwise false.
+ */
+int nl_object_identical(struct nl_object *a, struct nl_object *b)
+{
+       struct nl_object_ops *ops = obj_ops(a);
+       int req_attrs;
+
+       /* Both objects must be of same type */
+       if (ops != obj_ops(b))
+               return 0;
+
+       req_attrs = ops->oo_id_attrs;
+
+       /* Both objects must provide all required attributes to uniquely
+        * identify an object */
+       if ((a->ce_mask & req_attrs) != req_attrs ||
+           (b->ce_mask & req_attrs) != req_attrs)
+               return 0;
+
+       /* Can't judge unless we can compare */
+       if (ops->oo_compare == NULL)
+               return 0;
+
+       return !(ops->oo_compare(a, b, req_attrs, 0));
+}
+#endif
+
+/**
+ * Compute bitmask representing difference in attribute values
+ * @arg a              an object
+ * @arg b              another object of same type
+ *
+ * The bitmask returned is specific to an object type, each bit set represents
+ * an attribute which mismatches in either of the two objects. Unavailability
+ * of an attribute in one object and presence in the other is regarded a
+ * mismatch as well.
+ *
+ * @return Bitmask describing differences or 0 if they are completely identical.
+ */
+uint32_t nl_object_diff(struct nl_object *a, struct nl_object *b)
+{
+       struct nl_object_ops *ops = obj_ops(a);
+
+       if (ops != obj_ops(b) || ops->oo_compare == NULL)
+               return UINT_MAX;
+
+       return ops->oo_compare(a, b, ~0, 0);
+}
+
+/**
+ * Match a filter against an object
+ * @arg obj            object to check
+ * @arg filter         object of same type acting as filter
+ *
+ * @return 1 if the object matches the filter or 0
+ *           if no filter procedure is available or if the
+ *           filter does not match.
+ */
+int nl_object_match_filter(struct nl_object *obj, struct nl_object *filter)
+{
+       struct nl_object_ops *ops = obj_ops(obj);
+
+       if (ops != obj_ops(filter) || ops->oo_compare == NULL)
+               return 0;
+       
+       return !(ops->oo_compare(obj, filter, filter->ce_mask,
+                                LOOSE_COMPARISON));
+}
+
+/**
+ * Convert bitmask of attributes to a character string
+ * @arg obj            object of same type as attribute bitmask
+ * @arg attrs          bitmask of attribute types
+ * @arg buf            destination buffer
+ * @arg len            length of destination buffer
+ *
+ * Converts the bitmask of attribute types into a list of attribute
+ * names separated by comas.
+ *
+ * @return destination buffer.
+ */
+char *nl_object_attrs2str(struct nl_object *obj, uint32_t attrs,
+                         char *buf, size_t len)
+{
+       struct nl_object_ops *ops = obj_ops(obj);
+
+       if (ops->oo_attrs2str != NULL)
+               return ops->oo_attrs2str(attrs, buf, len);
+       else {
+               memset(buf, 0, len);
+               return buf;
+       }
+}
+
+/** @} */
+
+/** @} */
diff --git a/package/libnl-tiny/src/socket.c b/package/libnl-tiny/src/socket.c
new file mode 100644 (file)
index 0000000..6fe56fd
--- /dev/null
@@ -0,0 +1,406 @@
+/*
+ * lib/socket.c                Netlink Socket
+ *
+ *     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 core
+ * @defgroup socket Socket
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink/netlink.h>
+#include <netlink/utils.h>
+#include <netlink/handlers.h>
+#include <netlink/msg.h>
+#include <netlink/attr.h>
+
+static uint32_t used_ports_map[32];
+
+static uint32_t generate_local_port(void)
+{
+       int i, n;
+       uint32_t pid = getpid() & 0x3FFFFF;
+
+       for (i = 0; i < 32; i++) {
+               if (used_ports_map[i] == 0xFFFFFFFF)
+                       continue;
+
+               for (n = 0; n < 32; n++) {
+                       if (1UL & (used_ports_map[i] >> n))
+                               continue;
+
+                       used_ports_map[i] |= (1UL << n);
+                       n += (i * 32);
+
+                       /* PID_MAX_LIMIT is currently at 2^22, leaving 10 bit
+                        * to, i.e. 1024 unique ports per application. */
+                       return pid + (n << 22);
+
+               }
+       }
+
+       /* Out of sockets in our own PID namespace, what to do? FIXME */
+       return UINT_MAX;
+}
+
+static void release_local_port(uint32_t port)
+{
+       int nr;
+
+       if (port == UINT_MAX)
+               return;
+       
+       nr = port >> 22;
+       used_ports_map[nr / 32] &= ~((nr % 32) + 1);
+}
+
+/**
+ * @name Allocation
+ * @{
+ */
+
+static struct nl_sock *__alloc_socket(struct nl_cb *cb)
+{
+       struct nl_sock *sk;
+
+       sk = calloc(1, sizeof(*sk));
+       if (!sk)
+               return NULL;
+
+       sk->s_fd = -1;
+       sk->s_cb = cb;
+       sk->s_local.nl_family = AF_NETLINK;
+       sk->s_peer.nl_family = AF_NETLINK;
+       sk->s_seq_expect = sk->s_seq_next = time(0);
+       sk->s_local.nl_pid = generate_local_port();
+       if (sk->s_local.nl_pid == UINT_MAX) {
+               nl_socket_free(sk);
+               return NULL;
+       }
+
+       return sk;
+}
+
+/**
+ * Allocate new netlink socket
+ *
+ * @return Newly allocated netlink socket or NULL.
+ */
+struct nl_sock *nl_socket_alloc(void)
+{
+       struct nl_cb *cb;
+       
+       cb = nl_cb_alloc(NL_CB_DEFAULT);
+       if (!cb)
+               return NULL;
+
+       return __alloc_socket(cb);
+}
+
+/**
+ * Allocate new socket with custom callbacks
+ * @arg cb             Callback handler
+ *
+ * The reference to the callback handler is taken into account
+ * automatically, it is released again upon calling nl_socket_free().
+ *
+ *@return Newly allocted socket handle or NULL.
+ */
+struct nl_sock *nl_socket_alloc_cb(struct nl_cb *cb)
+{
+       if (cb == NULL)
+               BUG();
+
+       return __alloc_socket(nl_cb_get(cb));
+}
+
+/**
+ * Free a netlink socket.
+ * @arg sk             Netlink socket.
+ */
+void nl_socket_free(struct nl_sock *sk)
+{
+       if (!sk)
+               return;
+
+       if (sk->s_fd >= 0)
+               close(sk->s_fd);
+
+       if (!(sk->s_flags & NL_OWN_PORT))
+               release_local_port(sk->s_local.nl_pid);
+
+       nl_cb_put(sk->s_cb);
+       free(sk);
+}
+
+/** @} */
+
+/**
+ * @name Sequence Numbers
+ * @{
+ */
+
+static int noop_seq_check(struct nl_msg *msg, void *arg)
+{
+       return NL_OK;
+}
+
+
+/**
+ * Disable sequence number checking.
+ * @arg sk             Netlink socket.
+ *
+ * Disables checking of sequence numbers on the netlink socket This is
+ * required to allow messages to be processed which were not requested by
+ * a preceding request message, e.g. netlink events.
+ *
+ * @note This function modifies the NL_CB_SEQ_CHECK configuration in
+ * the callback handle associated with the socket.
+ */
+void nl_socket_disable_seq_check(struct nl_sock *sk)
+{
+       nl_cb_set(sk->s_cb, NL_CB_SEQ_CHECK,
+                 NL_CB_CUSTOM, noop_seq_check, NULL);
+}
+
+/** @} */
+
+/**
+ * Set local port of socket
+ * @arg sk             Netlink socket.
+ * @arg port           Local port identifier
+ *
+ * Assigns a local port identifier to the socket. If port is 0
+ * a unique port identifier will be generated automatically.
+ */
+void nl_socket_set_local_port(struct nl_sock *sk, uint32_t port)
+{
+       if (port == 0) {
+               port = generate_local_port(); 
+               sk->s_flags &= ~NL_OWN_PORT;
+       } else  {
+               if (!(sk->s_flags & NL_OWN_PORT))
+                       release_local_port(sk->s_local.nl_pid);
+               sk->s_flags |= NL_OWN_PORT;
+       }
+
+       sk->s_local.nl_pid = port;
+}
+
+/** @} */
+
+/**
+ * @name Group Subscriptions
+ * @{
+ */
+
+/**
+ * Join groups
+ * @arg sk             Netlink socket
+ * @arg group          Group identifier
+ *
+ * Joins the specified groups using the modern socket option which
+ * is available since kernel version 2.6.14. It allows joining an
+ * almost arbitary number of groups without limitation.  The list
+ * of groups has to be terminated by 0 (%NFNLGRP_NONE).
+ *
+ * Make sure to use the correct group definitions as the older
+ * bitmask definitions for nl_join_groups() are likely to still
+ * be present for backward compatibility reasons.
+ *
+ * @return 0 on sucess or a negative error code.
+ */
+int nl_socket_add_memberships(struct nl_sock *sk, int group, ...)
+{
+       int err;
+       va_list ap;
+
+       if (sk->s_fd == -1)
+               return -NLE_BAD_SOCK;
+
+       va_start(ap, group);
+
+       while (group != 0) {
+               if (group < 0)
+                       return -NLE_INVAL;
+
+               err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP,
+                                                &group, sizeof(group));
+               if (err < 0)
+                       return -nl_syserr2nlerr(errno);
+
+               group = va_arg(ap, int);
+       }
+
+       va_end(ap);
+
+       return 0;
+}
+
+/**
+ * Leave groups
+ * @arg sk             Netlink socket
+ * @arg group          Group identifier
+ *
+ * Leaves the specified groups using the modern socket option
+ * which is available since kernel version 2.6.14. The list of groups
+ * has to terminated by 0 (%NFNLGRP_NONE).
+ *
+ * @see nl_socket_add_membership
+ * @return 0 on success or a negative error code.
+ */
+int nl_socket_drop_memberships(struct nl_sock *sk, int group, ...)
+{
+       int err;
+       va_list ap;
+
+       if (sk->s_fd == -1)
+               return -NLE_BAD_SOCK;
+
+       va_start(ap, group);
+
+       while (group != 0) {
+               if (group < 0)
+                       return -NLE_INVAL;
+
+               err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_DROP_MEMBERSHIP,
+                                                &group, sizeof(group));
+               if (err < 0)
+                       return -nl_syserr2nlerr(errno);
+
+               group = va_arg(ap, int);
+       }
+
+       va_end(ap);
+
+       return 0;
+}
+
+
+/** @} */
+
+/**
+ * Set file descriptor of socket to non-blocking state
+ * @arg sk             Netlink socket.
+ *
+ * @return 0 on success or a negative error code.
+ */
+int nl_socket_set_nonblocking(struct nl_sock *sk)
+{
+       if (sk->s_fd == -1)
+               return -NLE_BAD_SOCK;
+
+       if (fcntl(sk->s_fd, F_SETFL, O_NONBLOCK) < 0)
+               return -nl_syserr2nlerr(errno);
+
+       return 0;
+}
+
+/** @} */
+
+/**
+ * @name Utilities
+ * @{
+ */
+
+/**
+ * Set socket buffer size of netlink socket.
+ * @arg sk             Netlink socket.
+ * @arg rxbuf          New receive socket buffer size in bytes.
+ * @arg txbuf          New transmit socket buffer size in bytes.
+ *
+ * Sets the socket buffer size of a netlink socket to the specified
+ * values \c rxbuf and \c txbuf. Providing a value of \c 0 assumes a
+ * good default value.
+ *
+ * @note It is not required to call this function prior to nl_connect().
+ * @return 0 on sucess or a negative error code.
+ */
+int nl_socket_set_buffer_size(struct nl_sock *sk, int rxbuf, int txbuf)
+{
+       int err;
+
+       if (rxbuf <= 0)
+               rxbuf = 32768;
+
+       if (txbuf <= 0)
+               txbuf = 32768;
+
+       if (sk->s_fd == -1)
+               return -NLE_BAD_SOCK;
+       
+       err = setsockopt(sk->s_fd, SOL_SOCKET, SO_SNDBUF,
+                        &txbuf, sizeof(txbuf));
+       if (err < 0)
+               return -nl_syserr2nlerr(errno);
+
+       err = setsockopt(sk->s_fd, SOL_SOCKET, SO_RCVBUF,
+                        &rxbuf, sizeof(rxbuf));
+       if (err < 0)
+               return -nl_syserr2nlerr(errno);
+
+       sk->s_flags |= NL_SOCK_BUFSIZE_SET;
+
+       return 0;
+}
+
+/**
+ * Enable/disable credential passing on netlink socket.
+ * @arg sk             Netlink socket.
+ * @arg state          New state (0 - disabled, 1 - enabled)
+ *
+ * @return 0 on success or a negative error code
+ */
+int nl_socket_set_passcred(struct nl_sock *sk, int state)
+{
+       int err;
+
+       if (sk->s_fd == -1)
+               return -NLE_BAD_SOCK;
+
+       err = setsockopt(sk->s_fd, SOL_SOCKET, SO_PASSCRED,
+                        &state, sizeof(state));
+       if (err < 0)
+               return -nl_syserr2nlerr(errno);
+
+       if (state)
+               sk->s_flags |= NL_SOCK_PASSCRED;
+       else
+               sk->s_flags &= ~NL_SOCK_PASSCRED;
+
+       return 0;
+}
+
+/**
+ * Enable/disable receival of additional packet information
+ * @arg sk             Netlink socket.
+ * @arg state          New state (0 - disabled, 1 - enabled)
+ *
+ * @return 0 on success or a negative error code
+ */
+int nl_socket_recv_pktinfo(struct nl_sock *sk, int state)
+{
+       int err;
+
+       if (sk->s_fd == -1)
+               return -NLE_BAD_SOCK;
+
+       err = setsockopt(sk->s_fd, SOL_NETLINK, NETLINK_PKTINFO,
+                        &state, sizeof(state));
+       if (err < 0)
+               return -nl_syserr2nlerr(errno);
+
+       return 0;
+}
+
+/** @} */
+
+/** @} */
index c763526..64099f0 100644 (file)
@@ -23,6 +23,7 @@ define Package/libnl
   CATEGORY:=Libraries
   TITLE:=netlink socket library
   URL:=http://people.suug.ch/~tgr/libnl/
+  DEPENDS:=@!LINUX_2_4
 endef
 
 define Package/libnl/description
index 1266395..e56bfdd 100644 (file)
@@ -15,12 +15,6 @@ choice
 config MADWIFI_STABLE
        bool "Use the OpenWrt stable version of madwifi"
 
-config MADWIFI_UPSTREAM
-       depends BROKEN
-       depends !LINUX_2_6_26
-       depends !TARGET_atheros
-       bool "Use the upstream release version 0.9.4"
-
 endchoice
 
 choice
index f787ffb..93a2aa1 100644 (file)
@@ -4,40 +4,27 @@
 # This is free software, licensed under the GNU General Public License v2.
 # See /LICENSE for more information.
 #
-# $Id$
 
 include $(TOPDIR)/rules.mk
 include $(INCLUDE_DIR)/kernel.mk
 
 PKG_NAME:=madwifi
 
-ifneq ($(CONFIG_MADWIFI_UPSTREAM),)
-  PKG_VERSION:=0.9.4
-  PKG_RELEASE:=2.1
+PKG_REV:=3314
+PKG_VERSION:=r$(PKG_REV)
+PKG_RELEASE:=2
 
-  PKG_SOURCE:=madwifi-$(PKG_VERSION).tar.gz
-  PKG_SOURCE_URL:=http://downloads.sourceforge.net/madwifi/
-  PKG_MD5SUM:=399d20de8d855a59f20058857c2178ad
+PKG_SOURCE_PROTO:=svn
+PKG_SOURCE_VERSION:=$(PKG_REV)
+PKG_SOURCE_SUBDIR:=$(if $(PKG_BRANCH),$(PKG_BRANCH),madwifi-trunk)-$(PKG_VERSION)
+PKG_SOURCE_URL:=http://svn.madwifi.org/madwifi/$(if $(PKG_BRANCH),branches/$(PKG_BRANCH),trunk)
+PKG_SOURCE:=$(PKG_SOURCE_SUBDIR).tar.gz
 
-  PKG_BUILD_DIR:=$(KERNEL_BUILD_DIR)/madwifi-$(PKG_VERSION)
+PKG_BUILD_DIR:=$(KERNEL_BUILD_DIR)/$(if $(PKG_BRANCH),$(PKG_BRANCH),madwifi-trunk)-$(PKG_VERSION)
 
-  PATCH_DIR=./patches-upstream
-else
-# PKG_BRANCH:=madwifi-dfs
-  PKG_REV:=3314
-  PKG_VERSION:=r$(PKG_REV)
-  PKG_RELEASE:=2.1
-
-  PKG_SOURCE_PROTO:=svn
-  PKG_SOURCE_VERSION:=$(PKG_REV)
-  PKG_SOURCE_SUBDIR:=$(if $(PKG_BRANCH),$(PKG_BRANCH),madwifi-trunk)-$(PKG_VERSION)
-  PKG_SOURCE_URL:=http://svn.madwifi.org/madwifi/$(if $(PKG_BRANCH),branches/$(PKG_BRANCH),trunk)
-  PKG_SOURCE:=$(PKG_SOURCE_SUBDIR).tar.gz
+PATCH_DIR=./patches
 
-  PKG_BUILD_DIR:=$(KERNEL_BUILD_DIR)/$(if $(PKG_BRANCH),$(PKG_BRANCH),madwifi-trunk)-$(PKG_VERSION)
-
-  PATCH_DIR=./patches
-endif
+PKG_BUILD_DEPENDS:=wprobe
 
 include $(INCLUDE_DIR)/package.mk
 
@@ -150,7 +137,7 @@ define KernelPackage/madwifi
   SUBMENU:=Wireless Drivers
   TITLE:=Driver for Atheros wireless chipsets
   URL:=http://madwifi.org/
-  DEPENDS:=+wireless-tools @PCI_SUPPORT||TARGET_atheros @!TARGET_avr32
+  DEPENDS:=+wireless-tools @PCI_SUPPORT||TARGET_atheros @!TARGET_avr32 @!TARGET_etrax @LINUX_2_6
   FILES:=$(MADWIFI_FILES)
   AUTOLOAD:=$(call AutoLoad,50,$(MADWIFI_AUTOLOAD))
 endef
@@ -163,6 +150,16 @@ define KernelPackage/madwifi/config
        source "$(SOURCE)/Config.in"
 endef
 
+MADWIFI_INC = \
+       -I$(PKG_BUILD_DIR) \
+       -I$(PKG_BUILD_DIR)/include \
+       -I$(PKG_BUILD_DIR)/hal \
+       -I$(PKG_BUILD_DIR)/ath \
+       -I$(PKG_BUILD_DIR)/ath_hal \
+       -I$(PKG_BUILD_DIR)/net80211 \
+       -I$(STAGING_DIR)/usr/include/wprobe \
+       -include $(PKG_BUILD_DIR)/include/compat.h
+
 MAKE_ARGS:= \
        PATH="$(TARGET_PATH)" \
        ARCH="$(LINUX_KARCH)" \
@@ -174,6 +171,7 @@ MAKE_ARGS:= \
        LDOPTS="--no-warn-mismatch " \
        ATH_RATE="ath_rate/$(RATE_CONTROL)" \
        DO_MULTI=1 \
+       INCS="$(MADWIFI_INC)" \
        $(if $(CONFIG_MADWIFI_DEBUG),,DEBUG=) WARNINGS="-Wno-unused"
 
 MAKE_VARS:= \
index 8c4a754..a3cf4d7 100755 (executable)
@@ -67,15 +67,17 @@ disable_atheros() (
 
 enable_atheros() {
        local device="$1"
-       # Can only set the country code to one setting for the entire system. The last country code is the one that will be applied.
+
+       config_get regdomain "$device" regdomain
+       [ -n "$regdomain" ] && echo "$regdomain" > /proc/sys/dev/$device/regdomain
+
        config_get country "$device" country
        [ -z "$country" ] && country="0"
-       local cc="0"
-       [ -e /proc/sys/dev/$device/countrycode ] && cc="$(cat /proc/sys/dev/$device/countrycode)"
-       if [ ! "$cc" = "$country" ] ; then
-               rmmod ath_pci
-               insmod ath_pci countrycode=$country
-       fi
+       echo "$country" > /proc/sys/dev/$device/countrycode
+
+       config_get_bool outdoor "$device" outdoor "0"
+       echo "$outdoor" > /proc/sys/dev/$device/outdoor
+
        config_get channel "$device" channel
        config_get vifs "$device" vifs
        config_get txpower "$device" txpower
diff --git a/package/madwifi/patches-upstream/104-autocreate_none.patch b/package/madwifi/patches-upstream/104-autocreate_none.patch
deleted file mode 100644 (file)
index e290f86..0000000
+++ /dev/null
@@ -1,13 +0,0 @@
-Index: madwifi-0.9.4/ath/if_ath.c
-===================================================================
---- madwifi-0.9.4.old/ath/if_ath.c     2008-02-13 06:13:10.000000000 +0100
-+++ madwifi-0.9.4/ath/if_ath.c 2008-05-06 10:25:15.000000000 +0200
-@@ -404,7 +404,7 @@
-       struct ath_hal *ah;
-       HAL_STATUS status;
-       int error = 0, i;
--      int autocreatemode = IEEE80211_M_STA;
-+      int autocreatemode = -1;
-       u_int8_t csz;
-       sc->devid = devid;
diff --git a/package/madwifi/patches-upstream/111-minstrel_crash.patch b/package/madwifi/patches-upstream/111-minstrel_crash.patch
deleted file mode 100644 (file)
index cc1fbe6..0000000
+++ /dev/null
@@ -1,14 +0,0 @@
-Index: madwifi-0.9.4/ath_rate/minstrel/minstrel.c
-===================================================================
---- madwifi-0.9.4.old/ath_rate/minstrel/minstrel.c     2007-12-12 05:11:07.000000000 +0100
-+++ madwifi-0.9.4/ath_rate/minstrel/minstrel.c 2008-07-24 15:15:41.000000000 +0200
-@@ -394,6 +394,9 @@
-       int rc1, rc2, rc3;         /* Index into the rate table, so for example, it is  0..11 */
-       int rixc1, rixc2, rixc3;   /* The actual bit rate used */
-+      if (sn->num_rates <= 0)
-+              return; 
-+
-       if (sn->is_sampling) {
-               sn->is_sampling = 0;
-               if (sn->rs_sample_rate_slower)
index 71cede7..d9a0ad4 100644 (file)
@@ -1,6 +1,65 @@
 --- a/net80211/ieee80211_crypto_ccmp.c
 +++ b/net80211/ieee80211_crypto_ccmp.c
-@@ -475,6 +475,9 @@ ccmp_encrypt(struct ieee80211_key *key, 
+@@ -115,6 +115,7 @@ ccmp_attach(struct ieee80211vap *vap, st
+ /* This function (crypto_alloc_foo might sleep. Therefore:
+  * Context: process
+  */
++#ifdef CONFIG_CRYPTO
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
+       ctx->cc_tfm = crypto_alloc_tfm("aes", 0);
+ #else
+@@ -123,7 +124,8 @@ ccmp_attach(struct ieee80211vap *vap, st
+       if (IS_ERR(ctx->cc_tfm))
+               ctx->cc_tfm = NULL;
+ #endif
+-      
++#endif
++
+       if (ctx->cc_tfm == NULL) {
+               IEEE80211_DPRINTF(vap, IEEE80211_MSG_CRYPTO,
+                               "%s: unable to load kernel AES crypto support\n",
+@@ -138,12 +140,14 @@ ccmp_detach(struct ieee80211_key *k)
+ {
+       struct ccmp_ctx *ctx = k->wk_private;
++#ifdef CONFIG_CRYPTO
+       if (ctx->cc_tfm != NULL)
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
+               crypto_free_tfm(ctx->cc_tfm);
+ #else
+               crypto_free_cipher(ctx->cc_tfm);
+ #endif
++#endif
+       FREE(ctx, M_DEVBUF);
+       _MOD_DEC_USE(THIS_MODULE);
+@@ -169,7 +173,9 @@ ccmp_setkey(struct ieee80211_key *k)
+                       return 0;
+               }
++#ifdef CONFIG_CRYPTO
+               crypto_cipher_setkey(ctx->cc_tfm, k->wk_key, k->wk_keylen);
++#endif
+       }
+       return 1;
+@@ -324,6 +330,7 @@ xor_block(u8 *b, const u8 *a, size_t len
+ static void
+ rijndael_encrypt(struct crypto_cipher *tfm, const void *src, void *dst)
+ {
++#ifdef CONFIG_CRYPTO
+ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
+       crypto_cipher_encrypt_one(tfm, dst, src);
+ #else
+@@ -339,6 +346,7 @@ rijndael_encrypt(struct crypto_cipher *t
+       sg_dst.length = AES_BLOCK_LEN;
+       crypto_cipher_encrypt(tfm, &sg_dst, &sg_src, AES_BLOCK_LEN);
+ #endif
++#endif
+ }
+ /*
+@@ -475,6 +483,9 @@ ccmp_encrypt(struct ieee80211_key *key, 
        uint8_t *mic, *pos;
        u_int space;
  
@@ -10,7 +69,7 @@
        ctx->cc_vap->iv_stats.is_crypto_ccmp++;
  
        skb = skb0;
-@@ -589,6 +592,9 @@ ccmp_decrypt(struct ieee80211_key *key, 
+@@ -589,6 +600,9 @@ ccmp_decrypt(struct ieee80211_key *key, 
        uint8_t *pos, *mic;
        u_int space;
  
@@ -20,3