/* * NETLINK      Netlink attributes * * 		Authors:	Thomas Graf <tgraf@suug.ch> * 				Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> */ #include <linux/config.h>#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_STRING]	= 1,	[NLA_NESTED]	= NLA_HDRLEN,}; static int validate_nla(struct nlattr *nla, int maxtype,			struct nla_policy *policy){	struct nla_policy *pt;	int minlen = 0; 	if (nla->nla_type <= 0 || nla->nla_type > maxtype)		return 0; 	pt = &policy[nla->nla_type]; 	BUG_ON(pt->type > NLA_TYPE_MAX); 	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 -ERANGE; 	if (nla_len(nla) < 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,		 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 * * 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,	      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->nla_type; 		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->nla_type == attrtype)			return nla; 	return NULL;} /** * nla_strlcpy - Copy string attribute payload into a sized buffer * @dst: where to copy the string to * @src: 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, 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 - 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_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 - 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 -1 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 -1; 	__nla_put(skb, attrtype, attrlen, data);	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);EXPORT_SYMBOL(__nla_put);EXPORT_SYMBOL(nla_put);EXPORT_SYMBOL(nla_memcpy);EXPORT_SYMBOL(nla_memcmp);EXPORT_SYMBOL(nla_strcmp);