netlink: Move netlink attribute parsing support to lib

Netlink attribute parsing may be used even if CONFIG_NET is not set. Move it from net/netlink to lib and control its inclusion based on the new config symbol CONFIG_NLATTR, which is selected by CONFIG_NET. Signed-off-by: Geert Uytterhoeven <Geert.Uytterhoeven@sonycom.com> Acked-by: David S. Miller <davem@davemloft.net> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

netlink: Move netlink attribute parsing support to lib
Netlink attribute parsing may be used even if CONFIG_NET is not set. Move it from net/netlink to lib and control its inclusion based on the new config symbol CONFIG_NLATTR, which is selected by CONFIG_NET. Signed-off-by: Geert Uytterhoeven <Geert.Uytterhoeven@sonycom.com> Acked-by: David S. Miller <davem@davemloft.net> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Geert Uytterhoeven · Herbert Xu
1 parent 8c882f6413
Showing 6 changed files with 483 additions and 474 deletions Side-by-side Diff
lib/Kconfig
lib/Makefile
lib/nlattr.c
net/Kconfig
net/netlink/Makefile
net/netlink/attr.c
@@ -174,5 +174,11 @@
        bool "Disable obsolete cpumask functions" if DEBUG_PER_CPU_MAPS
        depends on EXPERIMENTAL && BROKEN
  
+#
+# Netlink attribute parsing support is select'ed if needed
+#
+config NLATTR
+	bool
+
 endmenu
@@ -84,6 +84,8 @@
  
 obj-$(CONFIG_DYNAMIC_PRINTK_DEBUG) += dynamic_printk.o
  
+obj-$(CONFIG_NLATTR) += nlattr.o
+
 hostprogs-y	:= gen_crc32table
 clean-files	:= crc32table.h
  
+/*
+ * NETLINK      Netlink attributes
+ *
+ * 		Authors:	Thomas Graf <tgraf@suug.ch>
+ * 				Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/jiffies.h>
+#include <linux/netdevice.h>
+#include <linux/skbuff.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <net/netlink.h>
+
+static u16 nla_attr_minlen[NLA_TYPE_MAX+1] __read_mostly = {
+	[NLA_U8]	= sizeof(u8),
+	[NLA_U16]	= sizeof(u16),
+	[NLA_U32]	= sizeof(u32),
+	[NLA_U64]	= sizeof(u64),
+	[NLA_NESTED]	= NLA_HDRLEN,
+};
+
+static int validate_nla(struct nlattr *nla, int maxtype,
+			const struct nla_policy *policy)
+{
+	const struct nla_policy *pt;
+	int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla);
+
+	if (type <= 0 || type > maxtype)
+		return 0;
+
+	pt = &policy[type];
+
+	BUG_ON(pt->type > NLA_TYPE_MAX);
+
+	switch (pt->type) {
+	case NLA_FLAG:
+		if (attrlen > 0)
+			return -ERANGE;
+		break;
+
+	case NLA_NUL_STRING:
+		if (pt->len)
+			minlen = min_t(int, attrlen, pt->len + 1);
+		else
+			minlen = attrlen;
+
+		if (!minlen || memchr(nla_data(nla), '\0', minlen) == NULL)
+			return -EINVAL;
+		/* fall through */
+
+	case NLA_STRING:
+		if (attrlen < 1)
+			return -ERANGE;
+
+		if (pt->len) {
+			char *buf = nla_data(nla);
+
+			if (buf[attrlen - 1] == '\0')
+				attrlen--;
+
+			if (attrlen > pt->len)
+				return -ERANGE;
+		}
+		break;
+
+	case NLA_BINARY:
+		if (pt->len && attrlen > pt->len)
+			return -ERANGE;
+		break;
+
+	case NLA_NESTED_COMPAT:
+		if (attrlen < pt->len)
+			return -ERANGE;
+		if (attrlen < NLA_ALIGN(pt->len))
+			break;
+		if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN)
+			return -ERANGE;
+		nla = nla_data(nla) + NLA_ALIGN(pt->len);
+		if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN + nla_len(nla))
+			return -ERANGE;
+		break;
+	case NLA_NESTED:
+		/* a nested attributes is allowed to be empty; if its not,
+		 * it must have a size of at least NLA_HDRLEN.
+		 */
+		if (attrlen == 0)
+			break;
+	default:
+		if (pt->len)
+			minlen = pt->len;
+		else if (pt->type != NLA_UNSPEC)
+			minlen = nla_attr_minlen[pt->type];
+
+		if (attrlen < minlen)
+			return -ERANGE;
+	}
+
+	return 0;
+}
+
+/**
+ * nla_validate - Validate a stream of attributes
+ * @head: head of attribute stream
+ * @len: length of attribute stream
+ * @maxtype: maximum attribute type to be expected
+ * @policy: validation policy
+ *
+ * Validates all attributes in the specified attribute stream against the
+ * specified policy. Attributes with a type exceeding maxtype will be
+ * ignored. See documenation of struct nla_policy for more details.
+ *
+ * Returns 0 on success or a negative error code.
+ */
+int nla_validate(struct nlattr *head, int len, int maxtype,
+		 const 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;
+}
+
+/**
+ * nla_parse - Parse a stream of attributes into a tb buffer
+ * @tb: destination array with maxtype+1 elements
+ * @maxtype: maximum attribute type to be expected
+ * @head: head of attribute stream
+ * @len: length of attribute stream
+ * @policy: validation policy
+ *
+ * Parses a stream of attributes and stores a pointer to each attribute in
+ * the tb array accessable via the attribute type. Attributes with a type
+ * exceeding maxtype will be silently ignored for backwards compatibility
+ * reasons. policy may be set to NULL if no validation is required.
+ *
+ * Returns 0 on success or a negative error code.
+ */
+int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
+	      const 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) {
+		u16 type = nla_type(nla);
+
+		if (type > 0 && type <= maxtype) {
+			if (policy) {
+				err = validate_nla(nla, maxtype, policy);
+				if (err < 0)
+					goto errout;
+			}
+
+			tb[type] = nla;
+		}
+	}
+
+	if (unlikely(rem > 0))
+		printk(KERN_WARNING "netlink: %d bytes leftover after parsing "
+		       "attributes.\n", rem);
+
+	err = 0;
+errout:
+	return err;
+}
+
+/**
+ * nla_find - Find a specific attribute in a stream of attributes
+ * @head: head of attribute stream
+ * @len: length of attribute stream
+ * @attrtype: type of attribute to look for
+ *
+ * Returns the first attribute in the stream matching the specified type.
+ */
+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;
+}
+
+/**
+ * nla_strlcpy - Copy string attribute payload into a sized buffer
+ * @dst: where to copy the string to
+ * @nla: attribute to copy the string from
+ * @dstsize: size of destination buffer
+ *
+ * Copies at most dstsize - 1 bytes into the destination buffer.
+ * The result is always a valid NUL-terminated string. Unlike
+ * strlcpy the destination buffer is always padded out.
+ *
+ * Returns the length of the source buffer.
+ */
+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;
+}
+
+/**
+ * nla_memcpy - Copy a netlink attribute into another memory area
+ * @dest: where to copy to memcpy
+ * @src: netlink attribute to copy from
+ * @count: size of the destination area
+ *
+ * Note: The number of bytes copied is limited by the length of
+ *       attribute's payload. memcpy
+ *
+ * Returns the number of bytes copied.
+ */
+int nla_memcpy(void *dest, const struct nlattr *src, int count)
+{
+	int minlen = min_t(int, count, nla_len(src));
+
+	memcpy(dest, nla_data(src), minlen);
+
+	return minlen;
+}
+
+/**
+ * nla_memcmp - Compare an attribute with sized memory area
+ * @nla: netlink attribute
+ * @data: memory area
+ * @size: size of memory area
+ */
+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;
+}
+
+/**
+ * nla_strcmp - Compare a string attribute against a string
+ * @nla: netlink string attribute
+ * @str: another string
+ */
+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;
+}
+
+/**
+ * __nla_reserve - reserve room for attribute on the skb
+ * @skb: socket buffer to reserve room on
+ * @attrtype: attribute type
+ * @attrlen: length of attribute payload
+ *
+ * Adds a netlink attribute header to a socket buffer and reserves
+ * room for the payload but does not copy it.
+ *
+ * The caller is responsible to ensure that the skb provides enough
+ * tailroom for the attribute header and payload.
+ */
+struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
+{
+	struct nlattr *nla;
+
+	nla = (struct nlattr *) skb_put(skb, nla_total_size(attrlen));
+	nla->nla_type = attrtype;
+	nla->nla_len = nla_attr_size(attrlen);
+
+	memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
+
+	return nla;
+}
+
+/**
+ * __nla_reserve_nohdr - reserve room for attribute without header
+ * @skb: socket buffer to reserve room on
+ * @attrlen: length of attribute payload
+ *
+ * Reserves room for attribute payload without a header.
+ *
+ * The caller is responsible to ensure that the skb provides enough
+ * tailroom for the payload.
+ */
+void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
+{
+	void *start;
+
+	start = skb_put(skb, NLA_ALIGN(attrlen));
+	memset(start, 0, NLA_ALIGN(attrlen));
+
+	return start;
+}
+
+/**
+ * nla_reserve - reserve room for attribute on the skb
+ * @skb: socket buffer to reserve room on
+ * @attrtype: attribute type
+ * @attrlen: length of attribute payload
+ *
+ * Adds a netlink attribute header to a socket buffer and reserves
+ * room for the payload but does not copy it.
+ *
+ * Returns NULL if the tailroom of the skb is insufficient to store
+ * the attribute header and payload.
+ */
+struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
+{
+	if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
+		return NULL;
+
+	return __nla_reserve(skb, attrtype, attrlen);
+}
+
+/**
+ * nla_reserve_nohdr - reserve room for attribute without header
+ * @skb: socket buffer to reserve room on
+ * @attrlen: length of attribute payload
+ *
+ * Reserves room for attribute payload without a header.
+ *
+ * Returns NULL if the tailroom of the skb is insufficient to store
+ * the attribute payload.
+ */
+void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
+{
+	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
+		return NULL;
+
+	return __nla_reserve_nohdr(skb, attrlen);
+}
+
+/**
+ * __nla_put - Add a netlink attribute to a socket buffer
+ * @skb: socket buffer to add attribute to
+ * @attrtype: attribute type
+ * @attrlen: length of attribute payload
+ * @data: head of attribute payload
+ *
+ * The caller is responsible to ensure that the skb provides enough
+ * tailroom for the attribute header and payload.
+ */
+void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
+			     const void *data)
+{
+	struct nlattr *nla;
+
+	nla = __nla_reserve(skb, attrtype, attrlen);
+	memcpy(nla_data(nla), data, attrlen);
+}
+
+/**
+ * __nla_put_nohdr - Add a netlink attribute without header
+ * @skb: socket buffer to add attribute to
+ * @attrlen: length of attribute payload
+ * @data: head of attribute payload
+ *
+ * The caller is responsible to ensure that the skb provides enough
+ * tailroom for the attribute payload.
+ */
+void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
+{
+	void *start;
+
+	start = __nla_reserve_nohdr(skb, attrlen);
+	memcpy(start, data, attrlen);
+}
+
+/**
+ * nla_put - Add a netlink attribute to a socket buffer
+ * @skb: socket buffer to add attribute to
+ * @attrtype: attribute type
+ * @attrlen: length of attribute payload
+ * @data: head of attribute payload
+ *
+ * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
+ * the attribute header and payload.
+ */
+int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
+{
+	if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
+		return -EMSGSIZE;
+
+	__nla_put(skb, attrtype, attrlen, data);
+	return 0;
+}
+
+/**
+ * nla_put_nohdr - Add a netlink attribute without header
+ * @skb: socket buffer to add attribute to
+ * @attrlen: length of attribute payload
+ * @data: head of attribute payload
+ *
+ * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
+ * the attribute payload.
+ */
+int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
+{
+	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
+		return -EMSGSIZE;
+
+	__nla_put_nohdr(skb, attrlen, data);
+	return 0;
+}
+
+/**
+ * nla_append - Add a netlink attribute without header or padding
+ * @skb: socket buffer to add attribute to
+ * @attrlen: length of attribute payload
+ * @data: head of attribute payload
+ *
+ * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
+ * the attribute payload.
+ */
+int nla_append(struct sk_buff *skb, int attrlen, const void *data)
+{
+	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
+		return -EMSGSIZE;
+
+	memcpy(skb_put(skb, attrlen), data, attrlen);
+	return 0;
+}
+
+EXPORT_SYMBOL(nla_validate);
+EXPORT_SYMBOL(nla_parse);
+EXPORT_SYMBOL(nla_find);
+EXPORT_SYMBOL(nla_strlcpy);
+EXPORT_SYMBOL(__nla_reserve);
+EXPORT_SYMBOL(__nla_reserve_nohdr);
+EXPORT_SYMBOL(nla_reserve);
+EXPORT_SYMBOL(nla_reserve_nohdr);
+EXPORT_SYMBOL(__nla_put);
+EXPORT_SYMBOL(__nla_put_nohdr);
+EXPORT_SYMBOL(nla_put);
+EXPORT_SYMBOL(nla_put_nohdr);
+EXPORT_SYMBOL(nla_memcpy);
+EXPORT_SYMBOL(nla_memcmp);
+EXPORT_SYMBOL(nla_strcmp);
+EXPORT_SYMBOL(nla_append);
@@ -4,6 +4,7 @@
  
 menuconfig NET
 	bool "Networking support"
+	select NLATTR
 	---help---
 	  Unless you really know what you are doing, you should say Y here.
 	  The reason is that some programs need kernel networking support even
@@ -2,5 +2,5 @@
 # Makefile for the netlink driver.
 #
  
-obj-y  				:= af_netlink.o attr.o genetlink.o
+obj-y  				:= af_netlink.o genetlink.o
-/*
- * NETLINK      Netlink attributes
- *
- * 		Authors:	Thomas Graf <tgraf@suug.ch>
- * 				Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/jiffies.h>
-#include <linux/netdevice.h>
-#include <linux/skbuff.h>
-#include <linux/string.h>
-#include <linux/types.h>
-#include <net/netlink.h>
-
-static u16 nla_attr_minlen[NLA_TYPE_MAX+1] __read_mostly = {
-	[NLA_U8]	= sizeof(u8),
-	[NLA_U16]	= sizeof(u16),
-	[NLA_U32]	= sizeof(u32),
-	[NLA_U64]	= sizeof(u64),
-	[NLA_NESTED]	= NLA_HDRLEN,
-};
-
-static int validate_nla(struct nlattr *nla, int maxtype,
-			const struct nla_policy *policy)
-{
-	const struct nla_policy *pt;
-	int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla);
-
-	if (type <= 0 || type > maxtype)
-		return 0;
-
-	pt = &policy[type];
-
-	BUG_ON(pt->type > NLA_TYPE_MAX);
-
-	switch (pt->type) {
-	case NLA_FLAG:
-		if (attrlen > 0)
-			return -ERANGE;
-		break;
-
-	case NLA_NUL_STRING:
-		if (pt->len)
-			minlen = min_t(int, attrlen, pt->len + 1);
-		else
-			minlen = attrlen;
-
-		if (!minlen || memchr(nla_data(nla), '\0', minlen) == NULL)
-			return -EINVAL;
-		/* fall through */
-
-	case NLA_STRING:
-		if (attrlen < 1)
-			return -ERANGE;
-
-		if (pt->len) {
-			char *buf = nla_data(nla);
-
-			if (buf[attrlen - 1] == '\0')
-				attrlen--;
-
-			if (attrlen > pt->len)
-				return -ERANGE;
-		}
-		break;
-
-	case NLA_BINARY:
-		if (pt->len && attrlen > pt->len)
-			return -ERANGE;
-		break;
-
-	case NLA_NESTED_COMPAT:
-		if (attrlen < pt->len)
-			return -ERANGE;
-		if (attrlen < NLA_ALIGN(pt->len))
-			break;
-		if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN)
-			return -ERANGE;
-		nla = nla_data(nla) + NLA_ALIGN(pt->len);
-		if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN + nla_len(nla))
-			return -ERANGE;
-		break;
-	case NLA_NESTED:
-		/* a nested attributes is allowed to be empty; if its not,
-		 * it must have a size of at least NLA_HDRLEN.
-		 */
-		if (attrlen == 0)
-			break;
-	default:
-		if (pt->len)
-			minlen = pt->len;
-		else if (pt->type != NLA_UNSPEC)
-			minlen = nla_attr_minlen[pt->type];
-
-		if (attrlen < minlen)
-			return -ERANGE;
-	}
-
-	return 0;
-}
-
-/**
- * nla_validate - Validate a stream of attributes
- * @head: head of attribute stream
- * @len: length of attribute stream
- * @maxtype: maximum attribute type to be expected
- * @policy: validation policy
- *
- * Validates all attributes in the specified attribute stream against the
- * specified policy. Attributes with a type exceeding maxtype will be
- * ignored. See documenation of struct nla_policy for more details.
- *
- * Returns 0 on success or a negative error code.
- */
-int nla_validate(struct nlattr *head, int len, int maxtype,
-		 const 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;
-}
-
-/**
- * nla_parse - Parse a stream of attributes into a tb buffer
- * @tb: destination array with maxtype+1 elements
- * @maxtype: maximum attribute type to be expected
- * @head: head of attribute stream
- * @len: length of attribute stream
- * @policy: validation policy
- *
- * Parses a stream of attributes and stores a pointer to each attribute in
- * the tb array accessable via the attribute type. Attributes with a type
- * exceeding maxtype will be silently ignored for backwards compatibility
- * reasons. policy may be set to NULL if no validation is required.
- *
- * Returns 0 on success or a negative error code.
- */
-int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
-	      const 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) {
-		u16 type = nla_type(nla);
-
-		if (type > 0 && type <= maxtype) {
-			if (policy) {
-				err = validate_nla(nla, maxtype, policy);
-				if (err < 0)
-					goto errout;
-			}
-
-			tb[type] = nla;
-		}
-	}
-
-	if (unlikely(rem > 0))
-		printk(KERN_WARNING "netlink: %d bytes leftover after parsing "
-		       "attributes.\n", rem);
-
-	err = 0;
-errout:
-	return err;
-}
-
-/**
- * nla_find - Find a specific attribute in a stream of attributes
- * @head: head of attribute stream
- * @len: length of attribute stream
- * @attrtype: type of attribute to look for
- *
- * Returns the first attribute in the stream matching the specified type.
- */
-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;
-}
-
-/**
- * nla_strlcpy - Copy string attribute payload into a sized buffer
- * @dst: where to copy the string to
- * @nla: attribute to copy the string from
- * @dstsize: size of destination buffer
- *
- * Copies at most dstsize - 1 bytes into the destination buffer.
- * The result is always a valid NUL-terminated string. Unlike
- * strlcpy the destination buffer is always padded out.
- *
- * Returns the length of the source buffer.
- */
-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;
-}
-
-/**
- * nla_memcpy - Copy a netlink attribute into another memory area
- * @dest: where to copy to memcpy
- * @src: netlink attribute to copy from
- * @count: size of the destination area
- *
- * Note: The number of bytes copied is limited by the length of
- *       attribute's payload. memcpy
- *
- * Returns the number of bytes copied.
- */
-int nla_memcpy(void *dest, const struct nlattr *src, int count)
-{
-	int minlen = min_t(int, count, nla_len(src));
-
-	memcpy(dest, nla_data(src), minlen);
-
-	return minlen;
-}
-
-/**
- * nla_memcmp - Compare an attribute with sized memory area
- * @nla: netlink attribute
- * @data: memory area
- * @size: size of memory area
- */
-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;
-}
-
-/**
- * nla_strcmp - Compare a string attribute against a string
- * @nla: netlink string attribute
- * @str: another string
- */
-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;
-}
-
-/**
- * __nla_reserve - reserve room for attribute on the skb
- * @skb: socket buffer to reserve room on
- * @attrtype: attribute type
- * @attrlen: length of attribute payload
- *
- * Adds a netlink attribute header to a socket buffer and reserves
- * room for the payload but does not copy it.
- *
- * The caller is responsible to ensure that the skb provides enough
- * tailroom for the attribute header and payload.
- */
-struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
-{
-	struct nlattr *nla;
-
-	nla = (struct nlattr *) skb_put(skb, nla_total_size(attrlen));
-	nla->nla_type = attrtype;
-	nla->nla_len = nla_attr_size(attrlen);
-
-	memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
-
-	return nla;
-}
-
-/**
- * __nla_reserve_nohdr - reserve room for attribute without header
- * @skb: socket buffer to reserve room on
- * @attrlen: length of attribute payload
- *
- * Reserves room for attribute payload without a header.
- *
- * The caller is responsible to ensure that the skb provides enough
- * tailroom for the payload.
- */
-void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
-{
-	void *start;
-
-	start = skb_put(skb, NLA_ALIGN(attrlen));
-	memset(start, 0, NLA_ALIGN(attrlen));
-
-	return start;
-}
-
-/**
- * nla_reserve - reserve room for attribute on the skb
- * @skb: socket buffer to reserve room on
- * @attrtype: attribute type
- * @attrlen: length of attribute payload
- *
- * Adds a netlink attribute header to a socket buffer and reserves
- * room for the payload but does not copy it.
- *
- * Returns NULL if the tailroom of the skb is insufficient to store
- * the attribute header and payload.
- */
-struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
-{
-	if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
-		return NULL;
-
-	return __nla_reserve(skb, attrtype, attrlen);
-}
-
-/**
- * nla_reserve_nohdr - reserve room for attribute without header
- * @skb: socket buffer to reserve room on
- * @attrlen: length of attribute payload
- *
- * Reserves room for attribute payload without a header.
- *
- * Returns NULL if the tailroom of the skb is insufficient to store
- * the attribute payload.
- */
-void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
-{
-	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
-		return NULL;
-
-	return __nla_reserve_nohdr(skb, attrlen);
-}
-
-/**
- * __nla_put - Add a netlink attribute to a socket buffer
- * @skb: socket buffer to add attribute to
- * @attrtype: attribute type
- * @attrlen: length of attribute payload
- * @data: head of attribute payload
- *
- * The caller is responsible to ensure that the skb provides enough
- * tailroom for the attribute header and payload.
- */
-void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
-			     const void *data)
-{
-	struct nlattr *nla;
-
-	nla = __nla_reserve(skb, attrtype, attrlen);
-	memcpy(nla_data(nla), data, attrlen);
-}
-
-/**
- * __nla_put_nohdr - Add a netlink attribute without header
- * @skb: socket buffer to add attribute to
- * @attrlen: length of attribute payload
- * @data: head of attribute payload
- *
- * The caller is responsible to ensure that the skb provides enough
- * tailroom for the attribute payload.
- */
-void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
-{
-	void *start;
-
-	start = __nla_reserve_nohdr(skb, attrlen);
-	memcpy(start, data, attrlen);
-}
-
-/**
- * nla_put - Add a netlink attribute to a socket buffer
- * @skb: socket buffer to add attribute to
- * @attrtype: attribute type
- * @attrlen: length of attribute payload
- * @data: head of attribute payload
- *
- * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
- * the attribute header and payload.
- */
-int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
-{
-	if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
-		return -EMSGSIZE;
-
-	__nla_put(skb, attrtype, attrlen, data);
-	return 0;
-}
-
-/**
- * nla_put_nohdr - Add a netlink attribute without header
- * @skb: socket buffer to add attribute to
- * @attrlen: length of attribute payload
- * @data: head of attribute payload
- *
- * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
- * the attribute payload.
- */
-int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
-{
-	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
-		return -EMSGSIZE;
-
-	__nla_put_nohdr(skb, attrlen, data);
-	return 0;
-}
-
-/**
- * nla_append - Add a netlink attribute without header or padding
- * @skb: socket buffer to add attribute to
- * @attrlen: length of attribute payload
- * @data: head of attribute payload
- *
- * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
- * the attribute payload.
- */
-int nla_append(struct sk_buff *skb, int attrlen, const void *data)
-{
-	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
-		return -EMSGSIZE;
-
-	memcpy(skb_put(skb, attrlen), data, attrlen);
-	return 0;
-}
-
-EXPORT_SYMBOL(nla_validate);
-EXPORT_SYMBOL(nla_parse);
-EXPORT_SYMBOL(nla_find);
-EXPORT_SYMBOL(nla_strlcpy);
-EXPORT_SYMBOL(__nla_reserve);
-EXPORT_SYMBOL(__nla_reserve_nohdr);
-EXPORT_SYMBOL(nla_reserve);
-EXPORT_SYMBOL(nla_reserve_nohdr);
-EXPORT_SYMBOL(__nla_put);
-EXPORT_SYMBOL(__nla_put_nohdr);
-EXPORT_SYMBOL(nla_put);
-EXPORT_SYMBOL(nla_put_nohdr);
-EXPORT_SYMBOL(nla_memcpy);
-EXPORT_SYMBOL(nla_memcmp);
-EXPORT_SYMBOL(nla_strcmp);
-EXPORT_SYMBOL(nla_append);
...	...	@@ -174,5 +174,11 @@
174	174	bool "Disable obsolete cpumask functions" if DEBUG_PER_CPU_MAPS
175	175	depends on EXPERIMENTAL && BROKEN
176	176
	177	+#
	178	+# Netlink attribute parsing support is select'ed if needed
	179	+#
	180	+config NLATTR
	181	+ bool
	182	+
177	183	endmenu
...	...	@@ -84,6 +84,8 @@
84	84
85	85	obj-$(CONFIG_DYNAMIC_PRINTK_DEBUG) += dynamic_printk.o
86	86
	87	+obj-$(CONFIG_NLATTR) += nlattr.o
	88	+
87	89	hostprogs-y := gen_crc32table
88	90	clean-files := crc32table.h
89	91
	1	+/*
	2	+ * NETLINK Netlink attributes
	3	+ *
	4	+ * Authors: Thomas Graf <tgraf@suug.ch>
	5	+ * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
	6	+ */
	7	+
	8	+#include <linux/module.h>
	9	+#include <linux/kernel.h>
	10	+#include <linux/errno.h>
	11	+#include <linux/jiffies.h>
	12	+#include <linux/netdevice.h>
	13	+#include <linux/skbuff.h>
	14	+#include <linux/string.h>
	15	+#include <linux/types.h>
	16	+#include <net/netlink.h>
	17	+
	18	+static u16 nla_attr_minlen[NLA_TYPE_MAX+1] __read_mostly = {
	19	+ [NLA_U8] = sizeof(u8),
	20	+ [NLA_U16] = sizeof(u16),
	21	+ [NLA_U32] = sizeof(u32),
	22	+ [NLA_U64] = sizeof(u64),
	23	+ [NLA_NESTED] = NLA_HDRLEN,
	24	+};
	25	+
	26	+static int validate_nla(struct nlattr *nla, int maxtype,
	27	+ const struct nla_policy *policy)
	28	+{
	29	+ const struct nla_policy *pt;
	30	+ int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla);
	31	+
	32	+ if (type <= 0 \|\| type > maxtype)
	33	+ return 0;
	34	+
	35	+ pt = &policy[type];
	36	+
	37	+ BUG_ON(pt->type > NLA_TYPE_MAX);
	38	+
	39	+ switch (pt->type) {
	40	+ case NLA_FLAG:
	41	+ if (attrlen > 0)
	42	+ return -ERANGE;
	43	+ break;
	44	+
	45	+ case NLA_NUL_STRING:
	46	+ if (pt->len)
	47	+ minlen = min_t(int, attrlen, pt->len + 1);
	48	+ else
	49	+ minlen = attrlen;
	50	+
	51	+ if (!minlen \|\| memchr(nla_data(nla), '\0', minlen) == NULL)
	52	+ return -EINVAL;
	53	+ /* fall through */
	54	+
	55	+ case NLA_STRING:
	56	+ if (attrlen < 1)
	57	+ return -ERANGE;
	58	+
	59	+ if (pt->len) {
	60	+ char *buf = nla_data(nla);
	61	+
	62	+ if (buf[attrlen - 1] == '\0')
	63	+ attrlen--;
	64	+
	65	+ if (attrlen > pt->len)
	66	+ return -ERANGE;
	67	+ }
	68	+ break;
	69	+
	70	+ case NLA_BINARY:
	71	+ if (pt->len && attrlen > pt->len)
	72	+ return -ERANGE;
	73	+ break;
	74	+
	75	+ case NLA_NESTED_COMPAT:
	76	+ if (attrlen < pt->len)
	77	+ return -ERANGE;
	78	+ if (attrlen < NLA_ALIGN(pt->len))
	79	+ break;
	80	+ if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN)
	81	+ return -ERANGE;
	82	+ nla = nla_data(nla) + NLA_ALIGN(pt->len);
	83	+ if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN + nla_len(nla))
	84	+ return -ERANGE;
	85	+ break;
	86	+ case NLA_NESTED:
	87	+ /* a nested attributes is allowed to be empty; if its not,
	88	+ * it must have a size of at least NLA_HDRLEN.
	89	+ */
	90	+ if (attrlen == 0)
	91	+ break;
	92	+ default:
	93	+ if (pt->len)
	94	+ minlen = pt->len;
	95	+ else if (pt->type != NLA_UNSPEC)
	96	+ minlen = nla_attr_minlen[pt->type];
	97	+
	98	+ if (attrlen < minlen)
	99	+ return -ERANGE;
	100	+ }
	101	+
	102	+ return 0;
	103	+}
	104	+
	105	+/**
	106	+ * nla_validate - Validate a stream of attributes
	107	+ * @head: head of attribute stream
	108	+ * @len: length of attribute stream
	109	+ * @maxtype: maximum attribute type to be expected
	110	+ * @policy: validation policy
	111	+ *
	112	+ * Validates all attributes in the specified attribute stream against the
	113	+ * specified policy. Attributes with a type exceeding maxtype will be
	114	+ * ignored. See documenation of struct nla_policy for more details.
	115	+ *
	116	+ * Returns 0 on success or a negative error code.
	117	+ */
	118	+int nla_validate(struct nlattr *head, int len, int maxtype,
	119	+ const struct nla_policy *policy)
	120	+{
	121	+ struct nlattr *nla;
	122	+ int rem, err;
	123	+
	124	+ nla_for_each_attr(nla, head, len, rem) {
	125	+ err = validate_nla(nla, maxtype, policy);
	126	+ if (err < 0)
	127	+ goto errout;
	128	+ }
	129	+
	130	+ err = 0;
	131	+errout:
	132	+ return err;
	133	+}
	134	+
	135	+/**
	136	+ * nla_parse - Parse a stream of attributes into a tb buffer
	137	+ * @tb: destination array with maxtype+1 elements
	138	+ * @maxtype: maximum attribute type to be expected
	139	+ * @head: head of attribute stream
	140	+ * @len: length of attribute stream
	141	+ * @policy: validation policy
	142	+ *
	143	+ * Parses a stream of attributes and stores a pointer to each attribute in
	144	+ * the tb array accessable via the attribute type. Attributes with a type
	145	+ * exceeding maxtype will be silently ignored for backwards compatibility
	146	+ * reasons. policy may be set to NULL if no validation is required.
	147	+ *
	148	+ * Returns 0 on success or a negative error code.
	149	+ */
	150	+int nla_parse(struct nlattr tb[], int maxtype, struct nlattr head, int len,
	151	+ const struct nla_policy *policy)
	152	+{
	153	+ struct nlattr *nla;
	154	+ int rem, err;
	155	+
	156	+ memset(tb, 0, sizeof(struct nlattr ) (maxtype + 1));
	157	+
	158	+ nla_for_each_attr(nla, head, len, rem) {
	159	+ u16 type = nla_type(nla);
	160	+
	161	+ if (type > 0 && type <= maxtype) {
	162	+ if (policy) {
	163	+ err = validate_nla(nla, maxtype, policy);
	164	+ if (err < 0)
	165	+ goto errout;
	166	+ }
	167	+
	168	+ tb[type] = nla;
	169	+ }
	170	+ }
	171	+
	172	+ if (unlikely(rem > 0))
	173	+ printk(KERN_WARNING "netlink: %d bytes leftover after parsing "
	174	+ "attributes.\n", rem);
	175	+
	176	+ err = 0;
	177	+errout:
	178	+ return err;
	179	+}
	180	+
	181	+/**
	182	+ * nla_find - Find a specific attribute in a stream of attributes
	183	+ * @head: head of attribute stream
	184	+ * @len: length of attribute stream
	185	+ * @attrtype: type of attribute to look for
	186	+ *
	187	+ * Returns the first attribute in the stream matching the specified type.
	188	+ */
	189	+struct nlattr nla_find(struct nlattr head, int len, int attrtype)
	190	+{
	191	+ struct nlattr *nla;
	192	+ int rem;
	193	+
	194	+ nla_for_each_attr(nla, head, len, rem)
	195	+ if (nla_type(nla) == attrtype)
	196	+ return nla;
	197	+
	198	+ return NULL;
	199	+}
	200	+
	201	+/**
	202	+ * nla_strlcpy - Copy string attribute payload into a sized buffer
	203	+ * @dst: where to copy the string to
	204	+ * @nla: attribute to copy the string from
	205	+ * @dstsize: size of destination buffer
	206	+ *
	207	+ * Copies at most dstsize - 1 bytes into the destination buffer.
	208	+ * The result is always a valid NUL-terminated string. Unlike
	209	+ * strlcpy the destination buffer is always padded out.
	210	+ *
	211	+ * Returns the length of the source buffer.
	212	+ */
	213	+size_t nla_strlcpy(char dst, const struct nlattr nla, size_t dstsize)
	214	+{
	215	+ size_t srclen = nla_len(nla);
	216	+ char *src = nla_data(nla);
	217	+
	218	+ if (srclen > 0 && src[srclen - 1] == '\0')
	219	+ srclen--;
	220	+
	221	+ if (dstsize > 0) {
	222	+ size_t len = (srclen >= dstsize) ? dstsize - 1 : srclen;
	223	+
	224	+ memset(dst, 0, dstsize);
	225	+ memcpy(dst, src, len);
	226	+ }
	227	+
	228	+ return srclen;
	229	+}
	230	+
	231	+/**
	232	+ * nla_memcpy - Copy a netlink attribute into another memory area
	233	+ * @dest: where to copy to memcpy
	234	+ * @src: netlink attribute to copy from
	235	+ * @count: size of the destination area
	236	+ *
	237	+ * Note: The number of bytes copied is limited by the length of
	238	+ * attribute's payload. memcpy
	239	+ *
	240	+ * Returns the number of bytes copied.
	241	+ */
	242	+int nla_memcpy(void dest, const struct nlattr src, int count)
	243	+{
	244	+ int minlen = min_t(int, count, nla_len(src));
	245	+
	246	+ memcpy(dest, nla_data(src), minlen);
	247	+
	248	+ return minlen;
	249	+}
	250	+
	251	+/**
	252	+ * nla_memcmp - Compare an attribute with sized memory area
	253	+ * @nla: netlink attribute
	254	+ * @data: memory area
	255	+ * @size: size of memory area
	256	+ */
	257	+int nla_memcmp(const struct nlattr nla, const void data,
	258	+ size_t size)
	259	+{
	260	+ int d = nla_len(nla) - size;
	261	+
	262	+ if (d == 0)
	263	+ d = memcmp(nla_data(nla), data, size);
	264	+
	265	+ return d;
	266	+}
	267	+
	268	+/**
	269	+ * nla_strcmp - Compare a string attribute against a string
	270	+ * @nla: netlink string attribute
	271	+ * @str: another string
	272	+ */
	273	+int nla_strcmp(const struct nlattr nla, const char str)
	274	+{
	275	+ int len = strlen(str) + 1;
	276	+ int d = nla_len(nla) - len;
	277	+
	278	+ if (d == 0)
	279	+ d = memcmp(nla_data(nla), str, len);
	280	+
	281	+ return d;
	282	+}
	283	+
	284	+/**
	285	+ * __nla_reserve - reserve room for attribute on the skb
	286	+ * @skb: socket buffer to reserve room on
	287	+ * @attrtype: attribute type
	288	+ * @attrlen: length of attribute payload
	289	+ *
	290	+ * Adds a netlink attribute header to a socket buffer and reserves
	291	+ * room for the payload but does not copy it.
	292	+ *
	293	+ * The caller is responsible to ensure that the skb provides enough
	294	+ * tailroom for the attribute header and payload.
	295	+ */
	296	+struct nlattr __nla_reserve(struct sk_buff skb, int attrtype, int attrlen)
	297	+{
	298	+ struct nlattr *nla;
	299	+
	300	+ nla = (struct nlattr *) skb_put(skb, nla_total_size(attrlen));
	301	+ nla->nla_type = attrtype;
	302	+ nla->nla_len = nla_attr_size(attrlen);
	303	+
	304	+ memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
	305	+
	306	+ return nla;
	307	+}
	308	+
	309	+/**
	310	+ * __nla_reserve_nohdr - reserve room for attribute without header
	311	+ * @skb: socket buffer to reserve room on
	312	+ * @attrlen: length of attribute payload
	313	+ *
	314	+ * Reserves room for attribute payload without a header.
	315	+ *
	316	+ * The caller is responsible to ensure that the skb provides enough
	317	+ * tailroom for the payload.
	318	+ */
	319	+void __nla_reserve_nohdr(struct sk_buff skb, int attrlen)
	320	+{
	321	+ void *start;
	322	+
	323	+ start = skb_put(skb, NLA_ALIGN(attrlen));
	324	+ memset(start, 0, NLA_ALIGN(attrlen));
	325	+
	326	+ return start;
	327	+}
	328	+
	329	+/**
	330	+ * nla_reserve - reserve room for attribute on the skb
	331	+ * @skb: socket buffer to reserve room on
	332	+ * @attrtype: attribute type
	333	+ * @attrlen: length of attribute payload
	334	+ *
	335	+ * Adds a netlink attribute header to a socket buffer and reserves
	336	+ * room for the payload but does not copy it.
	337	+ *
	338	+ * Returns NULL if the tailroom of the skb is insufficient to store
	339	+ * the attribute header and payload.
	340	+ */
	341	+struct nlattr nla_reserve(struct sk_buff skb, int attrtype, int attrlen)
	342	+{
	343	+ if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
	344	+ return NULL;
	345	+
	346	+ return __nla_reserve(skb, attrtype, attrlen);
	347	+}
	348	+
	349	+/**
	350	+ * nla_reserve_nohdr - reserve room for attribute without header
	351	+ * @skb: socket buffer to reserve room on
	352	+ * @attrlen: length of attribute payload
	353	+ *
	354	+ * Reserves room for attribute payload without a header.
	355	+ *
	356	+ * Returns NULL if the tailroom of the skb is insufficient to store
	357	+ * the attribute payload.
	358	+ */
	359	+void nla_reserve_nohdr(struct sk_buff skb, int attrlen)
	360	+{
	361	+ if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
	362	+ return NULL;
	363	+
	364	+ return __nla_reserve_nohdr(skb, attrlen);
	365	+}
	366	+
	367	+/**
	368	+ * __nla_put - Add a netlink attribute to a socket buffer
	369	+ * @skb: socket buffer to add attribute to
	370	+ * @attrtype: attribute type
	371	+ * @attrlen: length of attribute payload
	372	+ * @data: head of attribute payload
	373	+ *
	374	+ * The caller is responsible to ensure that the skb provides enough
	375	+ * tailroom for the attribute header and payload.
	376	+ */
	377	+void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
	378	+ const void *data)
	379	+{
	380	+ struct nlattr *nla;
	381	+
	382	+ nla = __nla_reserve(skb, attrtype, attrlen);
	383	+ memcpy(nla_data(nla), data, attrlen);
	384	+}
	385	+
	386	+/**
	387	+ * __nla_put_nohdr - Add a netlink attribute without header
	388	+ * @skb: socket buffer to add attribute to
	389	+ * @attrlen: length of attribute payload
	390	+ * @data: head of attribute payload
	391	+ *
	392	+ * The caller is responsible to ensure that the skb provides enough
	393	+ * tailroom for the attribute payload.
	394	+ */
	395	+void __nla_put_nohdr(struct sk_buff skb, int attrlen, const void data)
	396	+{
	397	+ void *start;
	398	+
	399	+ start = __nla_reserve_nohdr(skb, attrlen);
	400	+ memcpy(start, data, attrlen);
	401	+}
	402	+
	403	+/**
	404	+ * nla_put - Add a netlink attribute to a socket buffer
	405	+ * @skb: socket buffer to add attribute to
	406	+ * @attrtype: attribute type
	407	+ * @attrlen: length of attribute payload
	408	+ * @data: head of attribute payload
	409	+ *
	410	+ * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
	411	+ * the attribute header and payload.
	412	+ */
	413	+int nla_put(struct sk_buff skb, int attrtype, int attrlen, const void data)
	414	+{
	415	+ if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
	416	+ return -EMSGSIZE;
	417	+
	418	+ __nla_put(skb, attrtype, attrlen, data);
	419	+ return 0;
	420	+}
	421	+
	422	+/**
	423	+ * nla_put_nohdr - Add a netlink attribute without header
	424	+ * @skb: socket buffer to add attribute to
	425	+ * @attrlen: length of attribute payload
	426	+ * @data: head of attribute payload
	427	+ *
	428	+ * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
	429	+ * the attribute payload.
	430	+ */
	431	+int nla_put_nohdr(struct sk_buff skb, int attrlen, const void data)
	432	+{
	433	+ if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
	434	+ return -EMSGSIZE;
	435	+
	436	+ __nla_put_nohdr(skb, attrlen, data);
	437	+ return 0;
	438	+}
	439	+
	440	+/**
	441	+ * nla_append - Add a netlink attribute without header or padding
	442	+ * @skb: socket buffer to add attribute to
	443	+ * @attrlen: length of attribute payload
	444	+ * @data: head of attribute payload
	445	+ *
	446	+ * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
	447	+ * the attribute payload.
	448	+ */
	449	+int nla_append(struct sk_buff skb, int attrlen, const void data)
	450	+{
	451	+ if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
	452	+ return -EMSGSIZE;
	453	+
	454	+ memcpy(skb_put(skb, attrlen), data, attrlen);
	455	+ return 0;
	456	+}
	457	+
	458	+EXPORT_SYMBOL(nla_validate);
	459	+EXPORT_SYMBOL(nla_parse);
	460	+EXPORT_SYMBOL(nla_find);
	461	+EXPORT_SYMBOL(nla_strlcpy);
	462	+EXPORT_SYMBOL(__nla_reserve);
	463	+EXPORT_SYMBOL(__nla_reserve_nohdr);
	464	+EXPORT_SYMBOL(nla_reserve);
	465	+EXPORT_SYMBOL(nla_reserve_nohdr);
	466	+EXPORT_SYMBOL(__nla_put);
	467	+EXPORT_SYMBOL(__nla_put_nohdr);
	468	+EXPORT_SYMBOL(nla_put);
	469	+EXPORT_SYMBOL(nla_put_nohdr);
	470	+EXPORT_SYMBOL(nla_memcpy);
	471	+EXPORT_SYMBOL(nla_memcmp);
	472	+EXPORT_SYMBOL(nla_strcmp);
	473	+EXPORT_SYMBOL(nla_append);
...	...	@@ -4,6 +4,7 @@
4	4
5	5	menuconfig NET
6	6	bool "Networking support"
	7	+ select NLATTR
7	8	---help---
8	9	Unless you really know what you are doing, you should say Y here.
9	10	The reason is that some programs need kernel networking support even
...	...	@@ -2,5 +2,5 @@
2	2	# Makefile for the netlink driver.
3	3	#
4	4
5		-obj-y := af_netlink.o attr.o genetlink.o
	5	+obj-y := af_netlink.o genetlink.o
1		-/*
2		- * NETLINK Netlink attributes
3		- *
4		- * Authors: Thomas Graf <tgraf@suug.ch>
5		- * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
6		- */
7		-
8		-#include <linux/module.h>
9		-#include <linux/kernel.h>
10		-#include <linux/errno.h>
11		-#include <linux/jiffies.h>
12		-#include <linux/netdevice.h>
13		-#include <linux/skbuff.h>
14		-#include <linux/string.h>
15		-#include <linux/types.h>
16		-#include <net/netlink.h>
17		-
18		-static u16 nla_attr_minlen[NLA_TYPE_MAX+1] __read_mostly = {
19		- [NLA_U8] = sizeof(u8),
20		- [NLA_U16] = sizeof(u16),
21		- [NLA_U32] = sizeof(u32),
22		- [NLA_U64] = sizeof(u64),
23		- [NLA_NESTED] = NLA_HDRLEN,
24		-};
25		-
26		-static int validate_nla(struct nlattr *nla, int maxtype,
27		- const struct nla_policy *policy)
28		-{
29		- const struct nla_policy *pt;
30		- int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla);
31		-
32		- if (type <= 0 \|\| type > maxtype)
33		- return 0;
34		-
35		- pt = &policy[type];
36		-
37		- BUG_ON(pt->type > NLA_TYPE_MAX);
38		-
39		- switch (pt->type) {
40		- case NLA_FLAG:
41		- if (attrlen > 0)
42		- return -ERANGE;
43		- break;
44		-
45		- case NLA_NUL_STRING:
46		- if (pt->len)
47		- minlen = min_t(int, attrlen, pt->len + 1);
48		- else
49		- minlen = attrlen;
50		-
51		- if (!minlen \|\| memchr(nla_data(nla), '\0', minlen) == NULL)
52		- return -EINVAL;
53		- /* fall through */
54		-
55		- case NLA_STRING:
56		- if (attrlen < 1)
57		- return -ERANGE;
58		-
59		- if (pt->len) {
60		- char *buf = nla_data(nla);
61		-
62		- if (buf[attrlen - 1] == '\0')
63		- attrlen--;
64		-
65		- if (attrlen > pt->len)
66		- return -ERANGE;
67		- }
68		- break;
69		-
70		- case NLA_BINARY:
71		- if (pt->len && attrlen > pt->len)
72		- return -ERANGE;
73		- break;
74		-
75		- case NLA_NESTED_COMPAT:
76		- if (attrlen < pt->len)
77		- return -ERANGE;
78		- if (attrlen < NLA_ALIGN(pt->len))
79		- break;
80		- if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN)
81		- return -ERANGE;
82		- nla = nla_data(nla) + NLA_ALIGN(pt->len);
83		- if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN + nla_len(nla))
84		- return -ERANGE;
85		- break;
86		- case NLA_NESTED:
87		- /* a nested attributes is allowed to be empty; if its not,
88		- * it must have a size of at least NLA_HDRLEN.
89		- */
90		- if (attrlen == 0)
91		- break;
92		- default:
93		- if (pt->len)
94		- minlen = pt->len;
95		- else if (pt->type != NLA_UNSPEC)
96		- minlen = nla_attr_minlen[pt->type];
97		-
98		- if (attrlen < minlen)
99		- return -ERANGE;
100		- }
101		-
102		- return 0;
103		-}
104		-
105		-/**
106		- * nla_validate - Validate a stream of attributes
107		- * @head: head of attribute stream
108		- * @len: length of attribute stream
109		- * @maxtype: maximum attribute type to be expected
110		- * @policy: validation policy
111		- *
112		- * Validates all attributes in the specified attribute stream against the
113		- * specified policy. Attributes with a type exceeding maxtype will be
114		- * ignored. See documenation of struct nla_policy for more details.
115		- *
116		- * Returns 0 on success or a negative error code.
117		- */
118		-int nla_validate(struct nlattr *head, int len, int maxtype,
119		- const struct nla_policy *policy)
120		-{
121		- struct nlattr *nla;
122		- int rem, err;
123		-
124		- nla_for_each_attr(nla, head, len, rem) {
125		- err = validate_nla(nla, maxtype, policy);
126		- if (err < 0)
127		- goto errout;
128		- }
129		-
130		- err = 0;
131		-errout:
132		- return err;
133		-}
134		-
135		-/**
136		- * nla_parse - Parse a stream of attributes into a tb buffer
137		- * @tb: destination array with maxtype+1 elements
138		- * @maxtype: maximum attribute type to be expected
139		- * @head: head of attribute stream
140		- * @len: length of attribute stream
141		- * @policy: validation policy
142		- *
143		- * Parses a stream of attributes and stores a pointer to each attribute in
144		- * the tb array accessable via the attribute type. Attributes with a type
145		- * exceeding maxtype will be silently ignored for backwards compatibility
146		- * reasons. policy may be set to NULL if no validation is required.
147		- *
148		- * Returns 0 on success or a negative error code.
149		- */
150		-int nla_parse(struct nlattr tb[], int maxtype, struct nlattr head, int len,
151		- const struct nla_policy *policy)
152		-{
153		- struct nlattr *nla;
154		- int rem, err;
155		-
156		- memset(tb, 0, sizeof(struct nlattr ) (maxtype + 1));
157		-
158		- nla_for_each_attr(nla, head, len, rem) {
159		- u16 type = nla_type(nla);
160		-
161		- if (type > 0 && type <= maxtype) {
162		- if (policy) {
163		- err = validate_nla(nla, maxtype, policy);
164		- if (err < 0)
165		- goto errout;
166		- }
167		-
168		- tb[type] = nla;
169		- }
170		- }
171		-
172		- if (unlikely(rem > 0))
173		- printk(KERN_WARNING "netlink: %d bytes leftover after parsing "
174		- "attributes.\n", rem);
175		-
176		- err = 0;
177		-errout:
178		- return err;
179		-}
180		-
181		-/**
182		- * nla_find - Find a specific attribute in a stream of attributes
183		- * @head: head of attribute stream
184		- * @len: length of attribute stream
185		- * @attrtype: type of attribute to look for
186		- *
187		- * Returns the first attribute in the stream matching the specified type.
188		- */
189		-struct nlattr nla_find(struct nlattr head, int len, int attrtype)
190		-{
191		- struct nlattr *nla;
192		- int rem;
193		-
194		- nla_for_each_attr(nla, head, len, rem)
195		- if (nla_type(nla) == attrtype)
196		- return nla;
197		-
198		- return NULL;
199		-}
200		-
201		-/**
202		- * nla_strlcpy - Copy string attribute payload into a sized buffer
203		- * @dst: where to copy the string to
204		- * @nla: attribute to copy the string from
205		- * @dstsize: size of destination buffer
206		- *
207		- * Copies at most dstsize - 1 bytes into the destination buffer.
208		- * The result is always a valid NUL-terminated string. Unlike
209		- * strlcpy the destination buffer is always padded out.
210		- *
211		- * Returns the length of the source buffer.
212		- */
213		-size_t nla_strlcpy(char dst, const struct nlattr nla, size_t dstsize)
214		-{
215		- size_t srclen = nla_len(nla);
216		- char *src = nla_data(nla);
217		-
218		- if (srclen > 0 && src[srclen - 1] == '\0')
219		- srclen--;
220		-
221		- if (dstsize > 0) {
222		- size_t len = (srclen >= dstsize) ? dstsize - 1 : srclen;
223		-
224		- memset(dst, 0, dstsize);
225		- memcpy(dst, src, len);
226		- }
227		-
228		- return srclen;
229		-}
230		-
231		-/**
232		- * nla_memcpy - Copy a netlink attribute into another memory area
233		- * @dest: where to copy to memcpy
234		- * @src: netlink attribute to copy from
235		- * @count: size of the destination area
236		- *
237		- * Note: The number of bytes copied is limited by the length of
238		- * attribute's payload. memcpy
239		- *
240		- * Returns the number of bytes copied.
241		- */
242		-int nla_memcpy(void dest, const struct nlattr src, int count)
243		-{
244		- int minlen = min_t(int, count, nla_len(src));
245		-
246		- memcpy(dest, nla_data(src), minlen);
247		-
248		- return minlen;
249		-}
250		-
251		-/**
252		- * nla_memcmp - Compare an attribute with sized memory area
253		- * @nla: netlink attribute
254		- * @data: memory area
255		- * @size: size of memory area
256		- */
257		-int nla_memcmp(const struct nlattr nla, const void data,
258		- size_t size)
259		-{
260		- int d = nla_len(nla) - size;
261		-
262		- if (d == 0)
263		- d = memcmp(nla_data(nla), data, size);
264		-
265		- return d;
266		-}
267		-
268		-/**
269		- * nla_strcmp - Compare a string attribute against a string
270		- * @nla: netlink string attribute
271		- * @str: another string
272		- */
273		-int nla_strcmp(const struct nlattr nla, const char str)
274		-{
275		- int len = strlen(str) + 1;
276		- int d = nla_len(nla) - len;
277		-
278		- if (d == 0)
279		- d = memcmp(nla_data(nla), str, len);
280		-
281		- return d;
282		-}
283		-
284		-/**
285		- * __nla_reserve - reserve room for attribute on the skb
286		- * @skb: socket buffer to reserve room on
287		- * @attrtype: attribute type
288		- * @attrlen: length of attribute payload
289		- *
290		- * Adds a netlink attribute header to a socket buffer and reserves
291		- * room for the payload but does not copy it.
292		- *
293		- * The caller is responsible to ensure that the skb provides enough
294		- * tailroom for the attribute header and payload.
295		- */
296		-struct nlattr __nla_reserve(struct sk_buff skb, int attrtype, int attrlen)
297		-{
298		- struct nlattr *nla;
299		-
300		- nla = (struct nlattr *) skb_put(skb, nla_total_size(attrlen));
301		- nla->nla_type = attrtype;
302		- nla->nla_len = nla_attr_size(attrlen);
303		-
304		- memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
305		-
306		- return nla;
307		-}
308		-
309		-/**
310		- * __nla_reserve_nohdr - reserve room for attribute without header
311		- * @skb: socket buffer to reserve room on
312		- * @attrlen: length of attribute payload
313		- *
314		- * Reserves room for attribute payload without a header.
315		- *
316		- * The caller is responsible to ensure that the skb provides enough
317		- * tailroom for the payload.
318		- */
319		-void __nla_reserve_nohdr(struct sk_buff skb, int attrlen)
320		-{
321		- void *start;
322		-
323		- start = skb_put(skb, NLA_ALIGN(attrlen));
324		- memset(start, 0, NLA_ALIGN(attrlen));
325		-
326		- return start;
327		-}
328		-
329		-/**
330		- * nla_reserve - reserve room for attribute on the skb
331		- * @skb: socket buffer to reserve room on
332		- * @attrtype: attribute type
333		- * @attrlen: length of attribute payload
334		- *
335		- * Adds a netlink attribute header to a socket buffer and reserves
336		- * room for the payload but does not copy it.
337		- *
338		- * Returns NULL if the tailroom of the skb is insufficient to store
339		- * the attribute header and payload.
340		- */
341		-struct nlattr nla_reserve(struct sk_buff skb, int attrtype, int attrlen)
342		-{
343		- if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
344		- return NULL;
345		-
346		- return __nla_reserve(skb, attrtype, attrlen);
347		-}
348		-
349		-/**
350		- * nla_reserve_nohdr - reserve room for attribute without header
351		- * @skb: socket buffer to reserve room on
352		- * @attrlen: length of attribute payload
353		- *
354		- * Reserves room for attribute payload without a header.
355		- *
356		- * Returns NULL if the tailroom of the skb is insufficient to store
357		- * the attribute payload.
358		- */
359		-void nla_reserve_nohdr(struct sk_buff skb, int attrlen)
360		-{
361		- if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
362		- return NULL;
363		-
364		- return __nla_reserve_nohdr(skb, attrlen);
365		-}
366		-
367		-/**
368		- * __nla_put - Add a netlink attribute to a socket buffer
369		- * @skb: socket buffer to add attribute to
370		- * @attrtype: attribute type
371		- * @attrlen: length of attribute payload
372		- * @data: head of attribute payload
373		- *
374		- * The caller is responsible to ensure that the skb provides enough
375		- * tailroom for the attribute header and payload.
376		- */
377		-void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
378		- const void *data)
379		-{
380		- struct nlattr *nla;
381		-
382		- nla = __nla_reserve(skb, attrtype, attrlen);
383		- memcpy(nla_data(nla), data, attrlen);
384		-}
385		-
386		-/**
387		- * __nla_put_nohdr - Add a netlink attribute without header
388		- * @skb: socket buffer to add attribute to
389		- * @attrlen: length of attribute payload
390		- * @data: head of attribute payload
391		- *
392		- * The caller is responsible to ensure that the skb provides enough
393		- * tailroom for the attribute payload.
394		- */
395		-void __nla_put_nohdr(struct sk_buff skb, int attrlen, const void data)
396		-{
397		- void *start;
398		-
399		- start = __nla_reserve_nohdr(skb, attrlen);
400		- memcpy(start, data, attrlen);
401		-}
402		-
403		-/**
404		- * nla_put - Add a netlink attribute to a socket buffer
405		- * @skb: socket buffer to add attribute to
406		- * @attrtype: attribute type
407		- * @attrlen: length of attribute payload
408		- * @data: head of attribute payload
409		- *
410		- * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
411		- * the attribute header and payload.
412		- */
413		-int nla_put(struct sk_buff skb, int attrtype, int attrlen, const void data)
414		-{
415		- if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
416		- return -EMSGSIZE;
417		-
418		- __nla_put(skb, attrtype, attrlen, data);
419		- return 0;
420		-}
421		-
422		-/**
423		- * nla_put_nohdr - Add a netlink attribute without header
424		- * @skb: socket buffer to add attribute to
425		- * @attrlen: length of attribute payload
426		- * @data: head of attribute payload
427		- *
428		- * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
429		- * the attribute payload.
430		- */
431		-int nla_put_nohdr(struct sk_buff skb, int attrlen, const void data)
432		-{
433		- if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
434		- return -EMSGSIZE;
435		-
436		- __nla_put_nohdr(skb, attrlen, data);
437		- return 0;
438		-}
439		-
440		-/**
441		- * nla_append - Add a netlink attribute without header or padding
442		- * @skb: socket buffer to add attribute to
443		- * @attrlen: length of attribute payload
444		- * @data: head of attribute payload
445		- *
446		- * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
447		- * the attribute payload.
448		- */
449		-int nla_append(struct sk_buff skb, int attrlen, const void data)
450		-{
451		- if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
452		- return -EMSGSIZE;
453		-
454		- memcpy(skb_put(skb, attrlen), data, attrlen);
455		- return 0;
456		-}
457		-
458		-EXPORT_SYMBOL(nla_validate);
459		-EXPORT_SYMBOL(nla_parse);
460		-EXPORT_SYMBOL(nla_find);
461		-EXPORT_SYMBOL(nla_strlcpy);
462		-EXPORT_SYMBOL(__nla_reserve);
463		-EXPORT_SYMBOL(__nla_reserve_nohdr);
464		-EXPORT_SYMBOL(nla_reserve);
465		-EXPORT_SYMBOL(nla_reserve_nohdr);
466		-EXPORT_SYMBOL(__nla_put);
467		-EXPORT_SYMBOL(__nla_put_nohdr);
468		-EXPORT_SYMBOL(nla_put);
469		-EXPORT_SYMBOL(nla_put_nohdr);
470		-EXPORT_SYMBOL(nla_memcpy);
471		-EXPORT_SYMBOL(nla_memcmp);
472		-EXPORT_SYMBOL(nla_strcmp);
473		-EXPORT_SYMBOL(nla_append);