[net-next-2.6.git] / include / linux / rtnetlink.h

#ifndef __LINUX_RTNETLINK_H
#define __LINUX_RTNETLINK_H

#include <linux/netlink.h>
#include <linux/if.h>

/****
 *		Routing/neighbour discovery messages.
 ****/

/* Types of messages */

enum {
	RTM_BASE	= 16,
#define RTM_BASE	RTM_BASE

	RTM_NEWLINK	= 16,
#define RTM_NEWLINK	RTM_NEWLINK
	RTM_DELLINK,
#define RTM_DELLINK	RTM_DELLINK
	RTM_GETLINK,
#define RTM_GETLINK	RTM_GETLINK
	RTM_SETLINK,
#define RTM_SETLINK	RTM_SETLINK

	RTM_NEWADDR	= 20,
#define RTM_NEWADDR	RTM_NEWADDR
	RTM_DELADDR,
#define RTM_DELADDR	RTM_DELADDR
	RTM_GETADDR,
#define RTM_GETADDR	RTM_GETADDR

	RTM_NEWROUTE	= 24,
#define RTM_NEWROUTE	RTM_NEWROUTE
	RTM_DELROUTE,
#define RTM_DELROUTE	RTM_DELROUTE
	RTM_GETROUTE,
#define RTM_GETROUTE	RTM_GETROUTE

	RTM_NEWNEIGH	= 28,
#define RTM_NEWNEIGH	RTM_NEWNEIGH
	RTM_DELNEIGH,
#define RTM_DELNEIGH	RTM_DELNEIGH
	RTM_GETNEIGH,
#define RTM_GETNEIGH	RTM_GETNEIGH

	RTM_NEWRULE	= 32,
#define RTM_NEWRULE	RTM_NEWRULE
	RTM_DELRULE,
#define RTM_DELRULE	RTM_DELRULE
	RTM_GETRULE,
#define RTM_GETRULE	RTM_GETRULE

	RTM_NEWQDISC	= 36,
#define RTM_NEWQDISC	RTM_NEWQDISC
	RTM_DELQDISC,
#define RTM_DELQDISC	RTM_DELQDISC
	RTM_GETQDISC,
#define RTM_GETQDISC	RTM_GETQDISC

	RTM_NEWTCLASS	= 40,
#define RTM_NEWTCLASS	RTM_NEWTCLASS
	RTM_DELTCLASS,
#define RTM_DELTCLASS	RTM_DELTCLASS
	RTM_GETTCLASS,
#define RTM_GETTCLASS	RTM_GETTCLASS

	RTM_NEWTFILTER	= 44,
#define RTM_NEWTFILTER	RTM_NEWTFILTER
	RTM_DELTFILTER,
#define RTM_DELTFILTER	RTM_DELTFILTER
	RTM_GETTFILTER,
#define RTM_GETTFILTER	RTM_GETTFILTER

	RTM_NEWACTION	= 48,
#define RTM_NEWACTION   RTM_NEWACTION
	RTM_DELACTION,
#define RTM_DELACTION   RTM_DELACTION
	RTM_GETACTION,
#define RTM_GETACTION   RTM_GETACTION

	RTM_NEWPREFIX	= 52,
#define RTM_NEWPREFIX	RTM_NEWPREFIX
	RTM_GETPREFIX	= 54,
#define RTM_GETPREFIX	RTM_GETPREFIX

	RTM_GETMULTICAST = 58,
#define RTM_GETMULTICAST RTM_GETMULTICAST

	RTM_GETANYCAST	= 62,
#define RTM_GETANYCAST	RTM_GETANYCAST

	RTM_NEWNEIGHTBL	= 64,
#define RTM_NEWNEIGHTBL	RTM_NEWNEIGHTBL
	RTM_GETNEIGHTBL	= 66,
#define RTM_GETNEIGHTBL	RTM_GETNEIGHTBL
	RTM_SETNEIGHTBL,
#define RTM_SETNEIGHTBL	RTM_SETNEIGHTBL

	__RTM_MAX,
#define RTM_MAX		(((__RTM_MAX + 3) & ~3) - 1)
};

#define RTM_NR_MSGTYPES	(RTM_MAX + 1 - RTM_BASE)
#define RTM_NR_FAMILIES	(RTM_NR_MSGTYPES >> 2)
#define RTM_FAM(cmd)	(((cmd) - RTM_BASE) >> 2)

/* 
   Generic structure for encapsulation of optional route information.
   It is reminiscent of sockaddr, but with sa_family replaced
   with attribute type.
 */

struct rtattr
{
	unsigned short	rta_len;
	unsigned short	rta_type;
};

/* Macros to handle rtattributes */

#define RTA_ALIGNTO	4
#define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )
#define RTA_OK(rta,len) ((len) >= (int)sizeof(struct rtattr) && \
			 (rta)->rta_len >= sizeof(struct rtattr) && \
			 (rta)->rta_len <= (len))
#define RTA_NEXT(rta,attrlen)	((attrlen) -= RTA_ALIGN((rta)->rta_len), \
				 (struct rtattr*)(((char*)(rta)) + RTA_ALIGN((rta)->rta_len)))
#define RTA_LENGTH(len)	(RTA_ALIGN(sizeof(struct rtattr)) + (len))
#define RTA_SPACE(len)	RTA_ALIGN(RTA_LENGTH(len))
#define RTA_DATA(rta)   ((void*)(((char*)(rta)) + RTA_LENGTH(0)))
#define RTA_PAYLOAD(rta) ((int)((rta)->rta_len) - RTA_LENGTH(0))


/******************************************************************************
 *		Definitions used in routing table administration.
 ****/

struct rtmsg
{
	unsigned char		rtm_family;
	unsigned char		rtm_dst_len;
	unsigned char		rtm_src_len;
	unsigned char		rtm_tos;

	unsigned char		rtm_table;	/* Routing table id */
	unsigned char		rtm_protocol;	/* Routing protocol; see below	*/
	unsigned char		rtm_scope;	/* See below */	
	unsigned char		rtm_type;	/* See below	*/

	unsigned		rtm_flags;
};

/* rtm_type */

enum
{
	RTN_UNSPEC,
	RTN_UNICAST,		/* Gateway or direct route	*/
	RTN_LOCAL,		/* Accept locally		*/
	RTN_BROADCAST,		/* Accept locally as broadcast,
				   send as broadcast */
	RTN_ANYCAST,		/* Accept locally as broadcast,
				   but send as unicast */
	RTN_MULTICAST,		/* Multicast route		*/
	RTN_BLACKHOLE,		/* Drop				*/
	RTN_UNREACHABLE,	/* Destination is unreachable   */
	RTN_PROHIBIT,		/* Administratively prohibited	*/
	RTN_THROW,		/* Not in this table		*/
	RTN_NAT,		/* Translate this address	*/
	RTN_XRESOLVE,		/* Use external resolver	*/
	__RTN_MAX
};

#define RTN_MAX (__RTN_MAX - 1)


/* rtm_protocol */

#define RTPROT_UNSPEC	0
#define RTPROT_REDIRECT	1	/* Route installed by ICMP redirects;
				   not used by current IPv4 */
#define RTPROT_KERNEL	2	/* Route installed by kernel		*/
#define RTPROT_BOOT	3	/* Route installed during boot		*/
#define RTPROT_STATIC	4	/* Route installed by administrator	*/

/* Values of protocol >= RTPROT_STATIC are not interpreted by kernel;
   they are just passed from user and back as is.
   It will be used by hypothetical multiple routing daemons.
   Note that protocol values should be standardized in order to
   avoid conflicts.
 */

#define RTPROT_GATED	8	/* Apparently, GateD */
#define RTPROT_RA	9	/* RDISC/ND router advertisements */
#define RTPROT_MRT	10	/* Merit MRT */
#define RTPROT_ZEBRA	11	/* Zebra */
#define RTPROT_BIRD	12	/* BIRD */
#define RTPROT_DNROUTED	13	/* DECnet routing daemon */
#define RTPROT_XORP	14	/* XORP */
#define RTPROT_NTK	15	/* Netsukuku */

/* rtm_scope

   Really it is not scope, but sort of distance to the destination.
   NOWHERE are reserved for not existing destinations, HOST is our
   local addresses, LINK are destinations, located on directly attached
   link and UNIVERSE is everywhere in the Universe.

   Intermediate values are also possible f.e. interior routes
   could be assigned a value between UNIVERSE and LINK.
*/

enum rt_scope_t
{
	RT_SCOPE_UNIVERSE=0,
/* User defined values  */
	RT_SCOPE_SITE=200,
	RT_SCOPE_LINK=253,
	RT_SCOPE_HOST=254,
	RT_SCOPE_NOWHERE=255
};

/* rtm_flags */

#define RTM_F_NOTIFY		0x100	/* Notify user of route change	*/
#define RTM_F_CLONED		0x200	/* This route is cloned		*/
#define RTM_F_EQUALIZE		0x400	/* Multipath equalizer: NI	*/
#define RTM_F_PREFIX		0x800	/* Prefix addresses		*/

/* Reserved table identifiers */

enum rt_class_t
{
	RT_TABLE_UNSPEC=0,
/* User defined values */
	RT_TABLE_DEFAULT=253,
	RT_TABLE_MAIN=254,
	RT_TABLE_LOCAL=255,
	__RT_TABLE_MAX
};
#define RT_TABLE_MAX (__RT_TABLE_MAX - 1)


/* Routing message attributes */

enum rtattr_type_t
{
	RTA_UNSPEC,
	RTA_DST,
	RTA_SRC,
	RTA_IIF,
	RTA_OIF,
	RTA_GATEWAY,
	RTA_PRIORITY,
	RTA_PREFSRC,
	RTA_METRICS,
	RTA_MULTIPATH,
	RTA_PROTOINFO,
	RTA_FLOW,
	RTA_CACHEINFO,
	RTA_SESSION,
	RTA_MP_ALGO,
	__RTA_MAX
};

#define RTA_MAX (__RTA_MAX - 1)

#define RTM_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct rtmsg))))
#define RTM_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct rtmsg))

/* RTM_MULTIPATH --- array of struct rtnexthop.
 *
 * "struct rtnexthop" describes all necessary nexthop information,
 * i.e. parameters of path to a destination via this nexthop.
 *
 * At the moment it is impossible to set different prefsrc, mtu, window
 * and rtt for different paths from multipath.
 */

struct rtnexthop
{
	unsigned short		rtnh_len;
	unsigned char		rtnh_flags;
	unsigned char		rtnh_hops;
	int			rtnh_ifindex;
};

/* rtnh_flags */

#define RTNH_F_DEAD		1	/* Nexthop is dead (used by multipath)	*/
#define RTNH_F_PERVASIVE	2	/* Do recursive gateway lookup	*/
#define RTNH_F_ONLINK		4	/* Gateway is forced on link	*/

/* Macros to handle hexthops */

#define RTNH_ALIGNTO	4
#define RTNH_ALIGN(len) ( ((len)+RTNH_ALIGNTO-1) & ~(RTNH_ALIGNTO-1) )
#define RTNH_OK(rtnh,len) ((rtnh)->rtnh_len >= sizeof(struct rtnexthop) && \
			   ((int)(rtnh)->rtnh_len) <= (len))
#define RTNH_NEXT(rtnh)	((struct rtnexthop*)(((char*)(rtnh)) + RTNH_ALIGN((rtnh)->rtnh_len)))
#define RTNH_LENGTH(len) (RTNH_ALIGN(sizeof(struct rtnexthop)) + (len))
#define RTNH_SPACE(len)	RTNH_ALIGN(RTNH_LENGTH(len))
#define RTNH_DATA(rtnh)   ((struct rtattr*)(((char*)(rtnh)) + RTNH_LENGTH(0)))

/* RTM_CACHEINFO */

struct rta_cacheinfo
{
	__u32	rta_clntref;
	__u32	rta_lastuse;
	__s32	rta_expires;
	__u32	rta_error;
	__u32	rta_used;

#define RTNETLINK_HAVE_PEERINFO 1
	__u32	rta_id;
	__u32	rta_ts;
	__u32	rta_tsage;
};

/* RTM_METRICS --- array of struct rtattr with types of RTAX_* */

enum
{
	RTAX_UNSPEC,
#define RTAX_UNSPEC RTAX_UNSPEC
	RTAX_LOCK,
#define RTAX_LOCK RTAX_LOCK
	RTAX_MTU,
#define RTAX_MTU RTAX_MTU
	RTAX_WINDOW,
#define RTAX_WINDOW RTAX_WINDOW
	RTAX_RTT,
#define RTAX_RTT RTAX_RTT
	RTAX_RTTVAR,
#define RTAX_RTTVAR RTAX_RTTVAR
	RTAX_SSTHRESH,
#define RTAX_SSTHRESH RTAX_SSTHRESH
	RTAX_CWND,
#define RTAX_CWND RTAX_CWND
	RTAX_ADVMSS,
#define RTAX_ADVMSS RTAX_ADVMSS
	RTAX_REORDERING,
#define RTAX_REORDERING RTAX_REORDERING
	RTAX_HOPLIMIT,
#define RTAX_HOPLIMIT RTAX_HOPLIMIT
	RTAX_INITCWND,
#define RTAX_INITCWND RTAX_INITCWND
	RTAX_FEATURES,
#define RTAX_FEATURES RTAX_FEATURES
	__RTAX_MAX
};

#define RTAX_MAX (__RTAX_MAX - 1)

#define RTAX_FEATURE_ECN	0x00000001
#define RTAX_FEATURE_SACK	0x00000002
#define RTAX_FEATURE_TIMESTAMP	0x00000004
#define RTAX_FEATURE_ALLFRAG	0x00000008

struct rta_session
{
	__u8	proto;
	__u8	pad1;
	__u16	pad2;

	union {
		struct {
			__u16	sport;
			__u16	dport;
		} ports;

		struct {
			__u8	type;
			__u8	code;
			__u16	ident;
		} icmpt;

		__u32		spi;
	} u;
};

/****
 *		General form of address family dependent message.
 ****/

struct rtgenmsg
{
	unsigned char		rtgen_family;
};

/*****************************************************************
 *		Link layer specific messages.
 ****/

/* struct ifinfomsg
 * passes link level specific information, not dependent
 * on network protocol.
 */

struct ifinfomsg
{
	unsigned char	ifi_family;
	unsigned char	__ifi_pad;
	unsigned short	ifi_type;		/* ARPHRD_* */
	int		ifi_index;		/* Link index	*/
	unsigned	ifi_flags;		/* IFF_* flags	*/
	unsigned	ifi_change;		/* IFF_* change mask */
};

/********************************************************************
 *		prefix information 
 ****/

struct prefixmsg
{
	unsigned char	prefix_family;
	unsigned char	prefix_pad1;
	unsigned short	prefix_pad2;
	int		prefix_ifindex;
	unsigned char	prefix_type;
	unsigned char	prefix_len;
	unsigned char	prefix_flags;
	unsigned char	prefix_pad3;
};

enum 
{
	PREFIX_UNSPEC,
	PREFIX_ADDRESS,
	PREFIX_CACHEINFO,
	__PREFIX_MAX
};

#define PREFIX_MAX	(__PREFIX_MAX - 1)

struct prefix_cacheinfo
{
	__u32	preferred_time;
	__u32	valid_time;
};


/*****************************************************************
 *		Traffic control messages.
 ****/

struct tcmsg
{
	unsigned char	tcm_family;
	unsigned char	tcm__pad1;
	unsigned short	tcm__pad2;
	int		tcm_ifindex;
	__u32		tcm_handle;
	__u32		tcm_parent;
	__u32		tcm_info;
};

enum
{
	TCA_UNSPEC,
	TCA_KIND,
	TCA_OPTIONS,
	TCA_STATS,
	TCA_XSTATS,
	TCA_RATE,
	TCA_FCNT,
	TCA_STATS2,
	__TCA_MAX
};

#define TCA_MAX (__TCA_MAX - 1)

#define TCA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcmsg))))
#define TCA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcmsg))

#ifndef __KERNEL__
/* RTnetlink multicast groups - backwards compatibility for userspace */
#define RTMGRP_LINK		1
#define RTMGRP_NOTIFY		2
#define RTMGRP_NEIGH		4
#define RTMGRP_TC		8

#define RTMGRP_IPV4_IFADDR	0x10
#define RTMGRP_IPV4_MROUTE	0x20
#define RTMGRP_IPV4_ROUTE	0x40
#define RTMGRP_IPV4_RULE	0x80

#define RTMGRP_IPV6_IFADDR	0x100
#define RTMGRP_IPV6_MROUTE	0x200
#define RTMGRP_IPV6_ROUTE	0x400
#define RTMGRP_IPV6_IFINFO	0x800

#define RTMGRP_DECnet_IFADDR    0x1000
#define RTMGRP_DECnet_ROUTE     0x4000

#define RTMGRP_IPV6_PREFIX	0x20000
#endif

/* RTnetlink multicast groups */
enum rtnetlink_groups {
	RTNLGRP_NONE,
#define RTNLGRP_NONE		RTNLGRP_NONE
	RTNLGRP_LINK,
#define RTNLGRP_LINK		RTNLGRP_LINK
	RTNLGRP_NOTIFY,
#define RTNLGRP_NOTIFY		RTNLGRP_NOTIFY
	RTNLGRP_NEIGH,
#define RTNLGRP_NEIGH		RTNLGRP_NEIGH
	RTNLGRP_TC,
#define RTNLGRP_TC		RTNLGRP_TC
	RTNLGRP_IPV4_IFADDR,
#define RTNLGRP_IPV4_IFADDR	RTNLGRP_IPV4_IFADDR
	RTNLGRP_IPV4_MROUTE,
#define	RTNLGRP_IPV4_MROUTE	RTNLGRP_IPV4_MROUTE
	RTNLGRP_IPV4_ROUTE,
#define RTNLGRP_IPV4_ROUTE	RTNLGRP_IPV4_ROUTE
	RTNLGRP_IPV4_RULE,
#define RTNLGRP_IPV4_RULE	RTNLGRP_IPV4_RULE
	RTNLGRP_IPV6_IFADDR,
#define RTNLGRP_IPV6_IFADDR	RTNLGRP_IPV6_IFADDR
	RTNLGRP_IPV6_MROUTE,
#define RTNLGRP_IPV6_MROUTE	RTNLGRP_IPV6_MROUTE
	RTNLGRP_IPV6_ROUTE,
#define RTNLGRP_IPV6_ROUTE	RTNLGRP_IPV6_ROUTE
	RTNLGRP_IPV6_IFINFO,
#define RTNLGRP_IPV6_IFINFO	RTNLGRP_IPV6_IFINFO
	RTNLGRP_DECnet_IFADDR,
#define RTNLGRP_DECnet_IFADDR	RTNLGRP_DECnet_IFADDR
	RTNLGRP_NOP2,
	RTNLGRP_DECnet_ROUTE,
#define RTNLGRP_DECnet_ROUTE	RTNLGRP_DECnet_ROUTE
	RTNLGRP_DECnet_RULE,
#define RTNLGRP_DECnet_RULE	RTNLGRP_DECnet_RULE
	RTNLGRP_NOP4,
	RTNLGRP_IPV6_PREFIX,
#define RTNLGRP_IPV6_PREFIX	RTNLGRP_IPV6_PREFIX
	RTNLGRP_IPV6_RULE,
#define RTNLGRP_IPV6_RULE	RTNLGRP_IPV6_RULE
	__RTNLGRP_MAX
};
#define RTNLGRP_MAX	(__RTNLGRP_MAX - 1)

/* TC action piece */
struct tcamsg
{
	unsigned char	tca_family;
	unsigned char	tca__pad1;
	unsigned short	tca__pad2;
};
#define TA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcamsg))))
#define TA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcamsg))
#define TCA_ACT_TAB 1 /* attr type must be >=1 */	
#define TCAA_MAX 1

/* End of information exported to user level */

#ifdef __KERNEL__

#include <linux/mutex.h>

extern size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size);
static __inline__ int rtattr_strcmp(const struct rtattr *rta, const char *str)
{
	int len = strlen(str) + 1;
	return len > rta->rta_len || memcmp(RTA_DATA(rta), str, len);
}

extern int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len);

#define rtattr_parse_nested(tb, max, rta) \
	rtattr_parse((tb), (max), RTA_DATA((rta)), RTA_PAYLOAD((rta)))

extern struct sock *rtnl;

struct rtnetlink_link
{
	int (*doit)(struct sk_buff *, struct nlmsghdr*, void *attr);
	int (*dumpit)(struct sk_buff *, struct netlink_callback *cb);
};

extern struct rtnetlink_link * rtnetlink_links[NPROTO];
extern int rtnetlink_send(struct sk_buff *skb, u32 pid, u32 group, int echo);
extern int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics);

extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data);

#define RTA_PUT(skb, attrtype, attrlen, data) \
({	if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
		 goto rtattr_failure; \
   	__rta_fill(skb, attrtype, attrlen, data); }) 

#define RTA_APPEND(skb, attrlen, data) \
({	if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
		goto rtattr_failure; \
	memcpy(skb_put(skb, attrlen), data, attrlen); })

#define RTA_PUT_NOHDR(skb, attrlen, data) \
({	RTA_APPEND(skb, RTA_ALIGN(attrlen), data); \
	memset(skb->tail - (RTA_ALIGN(attrlen) - attrlen), 0, \
	       RTA_ALIGN(attrlen) - attrlen); })

#define RTA_PUT_U8(skb, attrtype, value) \
({	u8 _tmp = (value); \
	RTA_PUT(skb, attrtype, sizeof(u8), &_tmp); })

#define RTA_PUT_U16(skb, attrtype, value) \
({	u16 _tmp = (value); \
	RTA_PUT(skb, attrtype, sizeof(u16), &_tmp); })

#define RTA_PUT_U32(skb, attrtype, value) \
({	u32 _tmp = (value); \
	RTA_PUT(skb, attrtype, sizeof(u32), &_tmp); })

#define RTA_PUT_U64(skb, attrtype, value) \
({	u64 _tmp = (value); \
	RTA_PUT(skb, attrtype, sizeof(u64), &_tmp); })

#define RTA_PUT_SECS(skb, attrtype, value) \
	RTA_PUT_U64(skb, attrtype, (value) / HZ)

#define RTA_PUT_MSECS(skb, attrtype, value) \
	RTA_PUT_U64(skb, attrtype, jiffies_to_msecs(value))

#define RTA_PUT_STRING(skb, attrtype, value) \
	RTA_PUT(skb, attrtype, strlen(value) + 1, value)

#define RTA_PUT_FLAG(skb, attrtype) \
	RTA_PUT(skb, attrtype, 0, NULL);

#define RTA_NEST(skb, type) \
({	struct rtattr *__start = (struct rtattr *) (skb)->tail; \
	RTA_PUT(skb, type, 0, NULL); \
	__start;  })

#define RTA_NEST_END(skb, start) \
({	(start)->rta_len = ((skb)->tail - (unsigned char *) (start)); \
	(skb)->len; })

#define RTA_NEST_CANCEL(skb, start) \
({	if (start) \
		skb_trim(skb, (unsigned char *) (start) - (skb)->data); \
	-1; })

#define RTA_GET_U8(rta) \
({	if (!rta || RTA_PAYLOAD(rta) < sizeof(u8)) \
		goto rtattr_failure; \
	*(u8 *) RTA_DATA(rta); })

#define RTA_GET_U16(rta) \
({	if (!rta || RTA_PAYLOAD(rta) < sizeof(u16)) \
		goto rtattr_failure; \
	*(u16 *) RTA_DATA(rta); })

#define RTA_GET_U32(rta) \
({	if (!rta || RTA_PAYLOAD(rta) < sizeof(u32)) \
		goto rtattr_failure; \
	*(u32 *) RTA_DATA(rta); })

#define RTA_GET_U64(rta) \
({	u64 _tmp; \
	if (!rta || RTA_PAYLOAD(rta) < sizeof(u64)) \
		goto rtattr_failure; \
	memcpy(&_tmp, RTA_DATA(rta), sizeof(_tmp)); \
	_tmp; })

#define RTA_GET_FLAG(rta) (!!(rta))

#define RTA_GET_SECS(rta) ((unsigned long) RTA_GET_U64(rta) * HZ)
#define RTA_GET_MSECS(rta) (msecs_to_jiffies((unsigned long) RTA_GET_U64(rta)))
		
static inline struct rtattr *
__rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
{
	struct rtattr *rta;
	int size = RTA_LENGTH(attrlen);

	rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
	rta->rta_type = attrtype;
	rta->rta_len = size;
	memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
	return rta;
}

#define __RTA_PUT(skb, attrtype, attrlen) \
({ 	if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
		goto rtattr_failure; \
   	__rta_reserve(skb, attrtype, attrlen); })

extern void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change);

/* RTNL is used as a global lock for all changes to network configuration  */
extern void rtnl_lock(void);
extern void rtnl_unlock(void);
extern int rtnl_trylock(void);

extern void rtnetlink_init(void);
extern void __rtnl_unlock(void);

#define ASSERT_RTNL() do { \
	if (unlikely(rtnl_trylock())) { \
		rtnl_unlock(); \
		printk(KERN_ERR "RTNL: assertion failed at %s (%d)\n", \
		       __FILE__,  __LINE__); \
		dump_stack(); \
	} \
} while(0)

#define BUG_TRAP(x) do { \
	if (unlikely(!(x))) { \
		printk(KERN_ERR "KERNEL: assertion (%s) failed at %s (%d)\n", \
			#x,  __FILE__ , __LINE__); \
	} \
} while(0)

#endif /* __KERNEL__ */


#endif	/* __LINUX_RTNETLINK_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef __LINUX_RTNETLINK_H
	2	#define __LINUX_RTNETLINK_H
	3
	4	#include <linux/netlink.h>
0844565f	5	#include <linux/if.h>
1da177e4 LT	6
	7	/****
	8	* Routing/neighbour discovery messages.
	9	****/
	10
	11	/* Types of messages */
	12
	13	enum {
	14	RTM_BASE = 16,
	15	#define RTM_BASE RTM_BASE
	16
	17	RTM_NEWLINK = 16,
	18	#define RTM_NEWLINK RTM_NEWLINK
	19	RTM_DELLINK,
	20	#define RTM_DELLINK RTM_DELLINK
	21	RTM_GETLINK,
	22	#define RTM_GETLINK RTM_GETLINK
	23	RTM_SETLINK,
	24	#define RTM_SETLINK RTM_SETLINK
	25
	26	RTM_NEWADDR = 20,
	27	#define RTM_NEWADDR RTM_NEWADDR
	28	RTM_DELADDR,
	29	#define RTM_DELADDR RTM_DELADDR
	30	RTM_GETADDR,
	31	#define RTM_GETADDR RTM_GETADDR
	32
	33	RTM_NEWROUTE = 24,
	34	#define RTM_NEWROUTE RTM_NEWROUTE
	35	RTM_DELROUTE,
	36	#define RTM_DELROUTE RTM_DELROUTE
	37	RTM_GETROUTE,
	38	#define RTM_GETROUTE RTM_GETROUTE
	39
	40	RTM_NEWNEIGH = 28,
	41	#define RTM_NEWNEIGH RTM_NEWNEIGH
	42	RTM_DELNEIGH,
	43	#define RTM_DELNEIGH RTM_DELNEIGH
	44	RTM_GETNEIGH,
	45	#define RTM_GETNEIGH RTM_GETNEIGH
	46
	47	RTM_NEWRULE = 32,
	48	#define RTM_NEWRULE RTM_NEWRULE
	49	RTM_DELRULE,
	50	#define RTM_DELRULE RTM_DELRULE
	51	RTM_GETRULE,
	52	#define RTM_GETRULE RTM_GETRULE
	53
	54	RTM_NEWQDISC = 36,
	55	#define RTM_NEWQDISC RTM_NEWQDISC
	56	RTM_DELQDISC,
	57	#define RTM_DELQDISC RTM_DELQDISC
	58	RTM_GETQDISC,
	59	#define RTM_GETQDISC RTM_GETQDISC
	60
	61	RTM_NEWTCLASS = 40,
	62	#define RTM_NEWTCLASS RTM_NEWTCLASS
	63	RTM_DELTCLASS,
	64	#define RTM_DELTCLASS RTM_DELTCLASS
	65	RTM_GETTCLASS,
	66	#define RTM_GETTCLASS RTM_GETTCLASS
	67
	68	RTM_NEWTFILTER = 44,
	69	#define RTM_NEWTFILTER RTM_NEWTFILTER
70	RTM_DELTFILTER,
71	#define RTM_DELTFILTER RTM_DELTFILTER
72	RTM_GETTFILTER,
73	#define RTM_GETTFILTER RTM_GETTFILTER
74
75	RTM_NEWACTION = 48,
76	#define RTM_NEWACTION RTM_NEWACTION
77	RTM_DELACTION,
78	#define RTM_DELACTION RTM_DELACTION
79	RTM_GETACTION,
80	#define RTM_GETACTION RTM_GETACTION
81
82	RTM_NEWPREFIX = 52,
83	#define RTM_NEWPREFIX RTM_NEWPREFIX
84	RTM_GETPREFIX = 54,
85	#define RTM_GETPREFIX RTM_GETPREFIX
86
87	RTM_GETMULTICAST = 58,
88	#define RTM_GETMULTICAST RTM_GETMULTICAST
89
90	RTM_GETANYCAST = 62,
91	#define RTM_GETANYCAST RTM_GETANYCAST
92
c7fb64db TG	93	RTM_NEWNEIGHTBL = 64,
	94	#define RTM_NEWNEIGHTBL RTM_NEWNEIGHTBL
	95	RTM_GETNEIGHTBL = 66,
	96	#define RTM_GETNEIGHTBL RTM_GETNEIGHTBL
	97	RTM_SETNEIGHTBL,
	98	#define RTM_SETNEIGHTBL RTM_SETNEIGHTBL
	99
d775fc09 TG	100	__RTM_MAX,
d775fc09 TG	101	#define RTM_MAX (((__RTM_MAX + 3) & ~3) - 1)
1da177e4 LT	102	};
1da177e4 LT	103
db46edc6 TG	104	#define RTM_NR_MSGTYPES (RTM_MAX + 1 - RTM_BASE)
db46edc6 TG	105	#define RTM_NR_FAMILIES (RTM_NR_MSGTYPES >> 2)
f90a0a74 TG	106	#define RTM_FAM(cmd) (((cmd) - RTM_BASE) >> 2)
f90a0a74 TG	107
1da177e4 LT	108	/*
	109	Generic structure for encapsulation of optional route information.
	110	It is reminiscent of sockaddr, but with sa_family replaced
	111	with attribute type.
	112	*/
	113
	114	struct rtattr
	115	{
	116	unsigned short rta_len;
	117	unsigned short rta_type;
	118	};
	119
	120	/* Macros to handle rtattributes */
	121
	122	#define RTA_ALIGNTO 4
	123	#define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )
	124	#define RTA_OK(rta,len) ((len) >= (int)sizeof(struct rtattr) && \
	125	(rta)->rta_len >= sizeof(struct rtattr) && \
	126	(rta)->rta_len <= (len))
	127	#define RTA_NEXT(rta,attrlen) ((attrlen) -= RTA_ALIGN((rta)->rta_len), \
	128	(struct rtattr)(((char)(rta)) + RTA_ALIGN((rta)->rta_len)))
	129	#define RTA_LENGTH(len) (RTA_ALIGN(sizeof(struct rtattr)) + (len))
	130	#define RTA_SPACE(len) RTA_ALIGN(RTA_LENGTH(len))
	131	#define RTA_DATA(rta) ((void)(((char)(rta)) + RTA_LENGTH(0)))
	132	#define RTA_PAYLOAD(rta) ((int)((rta)->rta_len) - RTA_LENGTH(0))
	133
	134
	135
	136
	137	/******************************************************************************
	138	* Definitions used in routing table administration.
	139	****/
	140
	141	struct rtmsg
	142	{
	143	unsigned char rtm_family;
	144	unsigned char rtm_dst_len;
	145	unsigned char rtm_src_len;
	146	unsigned char rtm_tos;
	147
	148	unsigned char rtm_table; /* Routing table id */
	149	unsigned char rtm_protocol; /* Routing protocol; see below */
	150	unsigned char rtm_scope; /* See below */
	151	unsigned char rtm_type; /* See below */
	152
	153	unsigned rtm_flags;
	154	};
	155
	156	/* rtm_type */
	157
	158	enum
	159	{
	160	RTN_UNSPEC,
	161	RTN_UNICAST, /* Gateway or direct route */
	162	RTN_LOCAL, /* Accept locally */
	163	RTN_BROADCAST, /* Accept locally as broadcast,
	164	send as broadcast */
	165	RTN_ANYCAST, /* Accept locally as broadcast,
	166	but send as unicast */
	167	RTN_MULTICAST, /* Multicast route */
	168	RTN_BLACKHOLE, /* Drop */
	169	RTN_UNREACHABLE, /* Destination is unreachable */
	170	RTN_PROHIBIT, /* Administratively prohibited */
	171	RTN_THROW, /* Not in this table */
172	RTN_NAT, /* Translate this address */
173	RTN_XRESOLVE, /* Use external resolver */
174	__RTN_MAX
175	};
176
177	#define RTN_MAX (__RTN_MAX - 1)
178
179
180	/* rtm_protocol */
181
182	#define RTPROT_UNSPEC 0
183	#define RTPROT_REDIRECT 1 /* Route installed by ICMP redirects;
184	not used by current IPv4 */
185	#define RTPROT_KERNEL 2 /* Route installed by kernel */
186	#define RTPROT_BOOT 3 /* Route installed during boot */
187	#define RTPROT_STATIC 4 /* Route installed by administrator */
188
189	/* Values of protocol >= RTPROT_STATIC are not interpreted by kernel;
190	they are just passed from user and back as is.
191	It will be used by hypothetical multiple routing daemons.
192	Note that protocol values should be standardized in order to
193	avoid conflicts.
194	*/
195
196	#define RTPROT_GATED 8 /* Apparently, GateD */
197	#define RTPROT_RA 9 /* RDISC/ND router advertisements */
198	#define RTPROT_MRT 10 /* Merit MRT */
199	#define RTPROT_ZEBRA 11 /* Zebra */
200	#define RTPROT_BIRD 12 /* BIRD */
201	#define RTPROT_DNROUTED 13 /* DECnet routing daemon */
202	#define RTPROT_XORP 14 /* XORP */
99cae7fc	203	#define RTPROT_NTK 15 /* Netsukuku */
1da177e4 LT	204
	205	/* rtm_scope
	206
	207	Really it is not scope, but sort of distance to the destination.
	208	NOWHERE are reserved for not existing destinations, HOST is our
	209	local addresses, LINK are destinations, located on directly attached
	210	link and UNIVERSE is everywhere in the Universe.
	211
	212	Intermediate values are also possible f.e. interior routes
	213	could be assigned a value between UNIVERSE and LINK.
	214	*/
	215
	216	enum rt_scope_t
	217	{
	218	RT_SCOPE_UNIVERSE=0,
	219	/* User defined values */
	220	RT_SCOPE_SITE=200,
	221	RT_SCOPE_LINK=253,
	222	RT_SCOPE_HOST=254,
	223	RT_SCOPE_NOWHERE=255
	224	};
	225
	226	/* rtm_flags */
	227
	228	#define RTM_F_NOTIFY 0x100 /* Notify user of route change */
	229	#define RTM_F_CLONED 0x200 /* This route is cloned */
	230	#define RTM_F_EQUALIZE 0x400 /* Multipath equalizer: NI */
	231	#define RTM_F_PREFIX 0x800 /* Prefix addresses */
	232
	233	/* Reserved table identifiers */
	234
	235	enum rt_class_t
	236	{
	237	RT_TABLE_UNSPEC=0,
	238	/* User defined values */
	239	RT_TABLE_DEFAULT=253,
	240	RT_TABLE_MAIN=254,
	241	RT_TABLE_LOCAL=255,
	242	__RT_TABLE_MAX
	243	};
	244	#define RT_TABLE_MAX (__RT_TABLE_MAX - 1)
	245
	246
	247
	248	/* Routing message attributes */
	249
	250	enum rtattr_type_t
	251	{
	252	RTA_UNSPEC,
	253	RTA_DST,
	254	RTA_SRC,
	255	RTA_IIF,
	256	RTA_OIF,
	257	RTA_GATEWAY,
	258	RTA_PRIORITY,
	259	RTA_PREFSRC,
	260	RTA_METRICS,
	261	RTA_MULTIPATH,
	262	RTA_PROTOINFO,
	263	RTA_FLOW,
	264	RTA_CACHEINFO,
	265	RTA_SESSION,
	266	RTA_MP_ALGO,
	267	__RTA_MAX
268	};
269
270	#define RTA_MAX (__RTA_MAX - 1)
271
272	#define RTM_RTA(r) ((struct rtattr)(((char)(r)) + NLMSG_ALIGN(sizeof(struct rtmsg))))
273	#define RTM_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct rtmsg))
274
275	/* RTM_MULTIPATH --- array of struct rtnexthop.
276	*
277	* "struct rtnexthop" describes all necessary nexthop information,
278	* i.e. parameters of path to a destination via this nexthop.
279	*
280	* At the moment it is impossible to set different prefsrc, mtu, window
281	* and rtt for different paths from multipath.
282	*/
283
284	struct rtnexthop
285	{
286	unsigned short rtnh_len;
287	unsigned char rtnh_flags;
288	unsigned char rtnh_hops;
289	int rtnh_ifindex;
290	};
291
292	/* rtnh_flags */
293
294	#define RTNH_F_DEAD 1 /* Nexthop is dead (used by multipath) */
295	#define RTNH_F_PERVASIVE 2 /* Do recursive gateway lookup */
296	#define RTNH_F_ONLINK 4 /* Gateway is forced on link */
297
298	/* Macros to handle hexthops */
299
300	#define RTNH_ALIGNTO 4
301	#define RTNH_ALIGN(len) ( ((len)+RTNH_ALIGNTO-1) & ~(RTNH_ALIGNTO-1) )
302	#define RTNH_OK(rtnh,len) ((rtnh)->rtnh_len >= sizeof(struct rtnexthop) && \
303	((int)(rtnh)->rtnh_len) <= (len))
304	#define RTNH_NEXT(rtnh) ((struct rtnexthop)(((char)(rtnh)) + RTNH_ALIGN((rtnh)->rtnh_len)))
305	#define RTNH_LENGTH(len) (RTNH_ALIGN(sizeof(struct rtnexthop)) + (len))
306	#define RTNH_SPACE(len) RTNH_ALIGN(RTNH_LENGTH(len))
307	#define RTNH_DATA(rtnh) ((struct rtattr)(((char)(rtnh)) + RTNH_LENGTH(0)))
308
309	/* RTM_CACHEINFO */
310
311	struct rta_cacheinfo
312	{
313	__u32 rta_clntref;
314	__u32 rta_lastuse;
315	__s32 rta_expires;
316	__u32 rta_error;
317	__u32 rta_used;
318
319	#define RTNETLINK_HAVE_PEERINFO 1
320	__u32 rta_id;
321	__u32 rta_ts;
322	__u32 rta_tsage;
323	};
324
325	/* RTM_METRICS --- array of struct rtattr with types of RTAX_* */
326
327	enum
328	{
329	RTAX_UNSPEC,
330	#define RTAX_UNSPEC RTAX_UNSPEC
331	RTAX_LOCK,
332	#define RTAX_LOCK RTAX_LOCK
333	RTAX_MTU,
334	#define RTAX_MTU RTAX_MTU
335	RTAX_WINDOW,
336	#define RTAX_WINDOW RTAX_WINDOW
337	RTAX_RTT,
338	#define RTAX_RTT RTAX_RTT
339	RTAX_RTTVAR,
340	#define RTAX_RTTVAR RTAX_RTTVAR
341	RTAX_SSTHRESH,
342	#define RTAX_SSTHRESH RTAX_SSTHRESH
343	RTAX_CWND,
344	#define RTAX_CWND RTAX_CWND
345	RTAX_ADVMSS,
346	#define RTAX_ADVMSS RTAX_ADVMSS
347	RTAX_REORDERING,
348	#define RTAX_REORDERING RTAX_REORDERING
349	RTAX_HOPLIMIT,
350	#define RTAX_HOPLIMIT RTAX_HOPLIMIT
351	RTAX_INITCWND,
352	#define RTAX_INITCWND RTAX_INITCWND
353	RTAX_FEATURES,
354	#define RTAX_FEATURES RTAX_FEATURES
355	__RTAX_MAX
356	};
357
358	#define RTAX_MAX (__RTAX_MAX - 1)
359
360	#define RTAX_FEATURE_ECN 0x00000001
361	#define RTAX_FEATURE_SACK 0x00000002
362	#define RTAX_FEATURE_TIMESTAMP 0x00000004
363	#define RTAX_FEATURE_ALLFRAG 0x00000008
364
365	struct rta_session
366	{
367	__u8 proto;
8a47077a PM	368	__u8 pad1;
8a47077a PM	369	__u16 pad2;
1da177e4 LT	370
	371	union {
	372	struct {
	373	__u16 sport;
	374	__u16 dport;
	375	} ports;
	376
	377	struct {
	378	__u8 type;
	379	__u8 code;
	380	__u16 ident;
	381	} icmpt;
	382
	383	__u32 spi;
	384	} u;
	385	};
	386
1da177e4 LT	387	/****
	388	* General form of address family dependent message.
	389	****/
	390
	391	struct rtgenmsg
	392	{
	393	unsigned char rtgen_family;
	394	};
	395
	396	/*****************************************************************
	397	* Link layer specific messages.
	398	****/
	399
	400	/* struct ifinfomsg
	401	* passes link level specific information, not dependent
	402	* on network protocol.
	403	*/
	404
	405	struct ifinfomsg
	406	{
	407	unsigned char ifi_family;
	408	unsigned char __ifi_pad;
	409	unsigned short ifi_type; /* ARPHRD_* */
	410	int ifi_index; /* Link index */
	411	unsigned ifi_flags; /* IFF_* flags */
	412	unsigned ifi_change; /* IFF_* change mask */
	413	};
	414
	415	/********************************************************************
	416	* prefix information
	417	****/
	418
	419	struct prefixmsg
	420	{
	421	unsigned char prefix_family;
8a47077a PM	422	unsigned char prefix_pad1;
8a47077a PM	423	unsigned short prefix_pad2;
1da177e4 LT	424	int prefix_ifindex;
	425	unsigned char prefix_type;
	426	unsigned char prefix_len;
	427	unsigned char prefix_flags;
8a47077a	428	unsigned char prefix_pad3;
1da177e4 LT	429	};
	430
	431	enum
	432	{
	433	PREFIX_UNSPEC,
	434	PREFIX_ADDRESS,
	435	PREFIX_CACHEINFO,
	436	__PREFIX_MAX
	437	};
	438
	439	#define PREFIX_MAX (__PREFIX_MAX - 1)
	440
	441	struct prefix_cacheinfo
	442	{
	443	__u32 preferred_time;
	444	__u32 valid_time;
	445	};
	446
1da177e4 LT	447
	448	/*****************************************************************
	449	* Traffic control messages.
	450	****/
	451
	452	struct tcmsg
	453	{
	454	unsigned char tcm_family;
	455	unsigned char tcm__pad1;
	456	unsigned short tcm__pad2;
	457	int tcm_ifindex;
	458	__u32 tcm_handle;
	459	__u32 tcm_parent;
	460	__u32 tcm_info;
	461	};
	462
	463	enum
	464	{
	465	TCA_UNSPEC,
	466	TCA_KIND,
	467	TCA_OPTIONS,
	468	TCA_STATS,
	469	TCA_XSTATS,
	470	TCA_RATE,
	471	TCA_FCNT,
	472	TCA_STATS2,
	473	__TCA_MAX
	474	};
	475
	476	#define TCA_MAX (__TCA_MAX - 1)
	477
	478	#define TCA_RTA(r) ((struct rtattr)(((char)(r)) + NLMSG_ALIGN(sizeof(struct tcmsg))))
	479	#define TCA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcmsg))
	480
ac6d439d PM	481	#ifndef __KERNEL__
ac6d439d PM	482	/* RTnetlink multicast groups - backwards compatibility for userspace */
1da177e4 LT	483	#define RTMGRP_LINK 1
	484	#define RTMGRP_NOTIFY 2
	485	#define RTMGRP_NEIGH 4
	486	#define RTMGRP_TC 8
	487
	488	#define RTMGRP_IPV4_IFADDR 0x10
	489	#define RTMGRP_IPV4_MROUTE 0x20
	490	#define RTMGRP_IPV4_ROUTE 0x40
a5cdc030	491	#define RTMGRP_IPV4_RULE 0x80
1da177e4 LT	492
	493	#define RTMGRP_IPV6_IFADDR 0x100
	494	#define RTMGRP_IPV6_MROUTE 0x200
	495	#define RTMGRP_IPV6_ROUTE 0x400
	496	#define RTMGRP_IPV6_IFINFO 0x800
	497
	498	#define RTMGRP_DECnet_IFADDR 0x1000
	499	#define RTMGRP_DECnet_ROUTE 0x4000
	500
	501	#define RTMGRP_IPV6_PREFIX 0x20000
ac6d439d PM	502	#endif
	503
	504	/* RTnetlink multicast groups */
	505	enum rtnetlink_groups {
	506	RTNLGRP_NONE,
	507	#define RTNLGRP_NONE RTNLGRP_NONE
	508	RTNLGRP_LINK,
	509	#define RTNLGRP_LINK RTNLGRP_LINK
	510	RTNLGRP_NOTIFY,
	511	#define RTNLGRP_NOTIFY RTNLGRP_NOTIFY
	512	RTNLGRP_NEIGH,
	513	#define RTNLGRP_NEIGH RTNLGRP_NEIGH
	514	RTNLGRP_TC,
	515	#define RTNLGRP_TC RTNLGRP_TC
	516	RTNLGRP_IPV4_IFADDR,
	517	#define RTNLGRP_IPV4_IFADDR RTNLGRP_IPV4_IFADDR
	518	RTNLGRP_IPV4_MROUTE,
	519	#define RTNLGRP_IPV4_MROUTE RTNLGRP_IPV4_MROUTE
	520	RTNLGRP_IPV4_ROUTE,
	521	#define RTNLGRP_IPV4_ROUTE RTNLGRP_IPV4_ROUTE
a5cdc030 PM	522	RTNLGRP_IPV4_RULE,
a5cdc030 PM	523	#define RTNLGRP_IPV4_RULE RTNLGRP_IPV4_RULE
ac6d439d PM	524	RTNLGRP_IPV6_IFADDR,
	525	#define RTNLGRP_IPV6_IFADDR RTNLGRP_IPV6_IFADDR
	526	RTNLGRP_IPV6_MROUTE,
	527	#define RTNLGRP_IPV6_MROUTE RTNLGRP_IPV6_MROUTE
	528	RTNLGRP_IPV6_ROUTE,
	529	#define RTNLGRP_IPV6_ROUTE RTNLGRP_IPV6_ROUTE
	530	RTNLGRP_IPV6_IFINFO,
	531	#define RTNLGRP_IPV6_IFINFO RTNLGRP_IPV6_IFINFO
	532	RTNLGRP_DECnet_IFADDR,
	533	#define RTNLGRP_DECnet_IFADDR RTNLGRP_DECnet_IFADDR
6b80ebed	534	RTNLGRP_NOP2,
ac6d439d PM	535	RTNLGRP_DECnet_ROUTE,
ac6d439d PM	536	#define RTNLGRP_DECnet_ROUTE RTNLGRP_DECnet_ROUTE
a8731cbf SW	537	RTNLGRP_DECnet_RULE,
a8731cbf SW	538	#define RTNLGRP_DECnet_RULE RTNLGRP_DECnet_RULE
6b80ebed	539	RTNLGRP_NOP4,
ac6d439d PM	540	RTNLGRP_IPV6_PREFIX,
ac6d439d PM	541	#define RTNLGRP_IPV6_PREFIX RTNLGRP_IPV6_PREFIX
101367c2 TG	542	RTNLGRP_IPV6_RULE,
101367c2 TG	543	#define RTNLGRP_IPV6_RULE RTNLGRP_IPV6_RULE
ac6d439d PM	544	__RTNLGRP_MAX
	545	};
	546	#define RTNLGRP_MAX (__RTNLGRP_MAX - 1)
1da177e4 LT	547
	548	/* TC action piece */
	549	struct tcamsg
	550	{
	551	unsigned char tca_family;
	552	unsigned char tca__pad1;
	553	unsigned short tca__pad2;
	554	};
	555	#define TA_RTA(r) ((struct rtattr)(((char)(r)) + NLMSG_ALIGN(sizeof(struct tcamsg))))
	556	#define TA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcamsg))
	557	#define TCA_ACT_TAB 1 /* attr type must be >=1 */
	558	#define TCAA_MAX 1
	559
	560	/* End of information exported to user level */
	561
	562	#ifdef __KERNEL__
	563
6756ae4b	564	#include <linux/mutex.h>
1da177e4 LT	565
	566	extern size_t rtattr_strlcpy(char dest, const struct rtattr rta, size_t size);
	567	static __inline__ int rtattr_strcmp(const struct rtattr rta, const char str)
	568	{
	569	int len = strlen(str) + 1;
	570	return len > rta->rta_len \|\| memcmp(RTA_DATA(rta), str, len);
	571	}
	572
	573	extern int rtattr_parse(struct rtattr tb[], int maxattr, struct rtattr rta, int len);
	574
	575	#define rtattr_parse_nested(tb, max, rta) \
	576	rtattr_parse((tb), (max), RTA_DATA((rta)), RTA_PAYLOAD((rta)))
	577
	578	extern struct sock *rtnl;
	579
	580	struct rtnetlink_link
	581	{
	582	int (doit)(struct sk_buff , struct nlmsghdr, void attr);
	583	int (dumpit)(struct sk_buff , struct netlink_callback *cb);
	584	};
	585
	586	extern struct rtnetlink_link * rtnetlink_links[NPROTO];
	587	extern int rtnetlink_send(struct sk_buff *skb, u32 pid, u32 group, int echo);
	588	extern int rtnetlink_put_metrics(struct sk_buff skb, u32 metrics);
	589
	590	extern void __rta_fill(struct sk_buff skb, int attrtype, int attrlen, const void data);
	591
	592	#define RTA_PUT(skb, attrtype, attrlen, data) \
	593	({ if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
	594	goto rtattr_failure; \
	595	__rta_fill(skb, attrtype, attrlen, data); })
	596
d675c989	597	#define RTA_APPEND(skb, attrlen, data) \
1da177e4 LT	598	({ if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
1da177e4 LT	599	goto rtattr_failure; \
d675c989 TG	600	memcpy(skb_put(skb, attrlen), data, attrlen); })
	601
	602	#define RTA_PUT_NOHDR(skb, attrlen, data) \
b3563c4f PM	603	({ RTA_APPEND(skb, RTA_ALIGN(attrlen), data); \
	604	memset(skb->tail - (RTA_ALIGN(attrlen) - attrlen), 0, \
	605	RTA_ALIGN(attrlen) - attrlen); })
00768244	606
8f48bcd4 TG	607	#define RTA_PUT_U8(skb, attrtype, value) \
	608	({ u8 _tmp = (value); \
	609	RTA_PUT(skb, attrtype, sizeof(u8), &_tmp); })
	610
	611	#define RTA_PUT_U16(skb, attrtype, value) \
	612	({ u16 _tmp = (value); \
	613	RTA_PUT(skb, attrtype, sizeof(u16), &_tmp); })
	614
00768244 TG	615	#define RTA_PUT_U32(skb, attrtype, value) \
	616	({ u32 _tmp = (value); \
	617	RTA_PUT(skb, attrtype, sizeof(u32), &_tmp); })
	618
	619	#define RTA_PUT_U64(skb, attrtype, value) \
	620	({ u64 _tmp = (value); \
	621	RTA_PUT(skb, attrtype, sizeof(u64), &_tmp); })
	622
	623	#define RTA_PUT_SECS(skb, attrtype, value) \
	624	RTA_PUT_U64(skb, attrtype, (value) / HZ)
	625
	626	#define RTA_PUT_MSECS(skb, attrtype, value) \
	627	RTA_PUT_U64(skb, attrtype, jiffies_to_msecs(value))
	628
	629	#define RTA_PUT_STRING(skb, attrtype, value) \
	630	RTA_PUT(skb, attrtype, strlen(value) + 1, value)
	631
8f48bcd4 TG	632	#define RTA_PUT_FLAG(skb, attrtype) \
	633	RTA_PUT(skb, attrtype, 0, NULL);
	634
00768244 TG	635	#define RTA_NEST(skb, type) \
	636	({ struct rtattr __start = (struct rtattr ) (skb)->tail; \
	637	RTA_PUT(skb, type, 0, NULL); \
	638	__start; })
	639
	640	#define RTA_NEST_END(skb, start) \
	641	({ (start)->rta_len = ((skb)->tail - (unsigned char *) (start)); \
	642	(skb)->len; })
	643
	644	#define RTA_NEST_CANCEL(skb, start) \
c52a3f89 TG	645	({ if (start) \
c52a3f89 TG	646	skb_trim(skb, (unsigned char *) (start) - (skb)->data); \
00768244 TG	647	-1; })
00768244 TG	648
8f48bcd4 TG	649	#define RTA_GET_U8(rta) \
	650	({ if (!rta \|\| RTA_PAYLOAD(rta) < sizeof(u8)) \
	651	goto rtattr_failure; \
	652	(u8 ) RTA_DATA(rta); })
	653
	654	#define RTA_GET_U16(rta) \
	655	({ if (!rta \|\| RTA_PAYLOAD(rta) < sizeof(u16)) \
	656	goto rtattr_failure; \
	657	(u16 ) RTA_DATA(rta); })
	658
00768244 TG	659	#define RTA_GET_U32(rta) \
	660	({ if (!rta \|\| RTA_PAYLOAD(rta) < sizeof(u32)) \
	661	goto rtattr_failure; \
	662	(u32 ) RTA_DATA(rta); })
	663
	664	#define RTA_GET_U64(rta) \
	665	({ u64 _tmp; \
	666	if (!rta \|\| RTA_PAYLOAD(rta) < sizeof(u64)) \
	667	goto rtattr_failure; \
	668	memcpy(&_tmp, RTA_DATA(rta), sizeof(_tmp)); \
	669	_tmp; })
	670
8f48bcd4 TG	671	#define RTA_GET_FLAG(rta) (!!(rta))
8f48bcd4 TG	672
00768244 TG	673	#define RTA_GET_SECS(rta) ((unsigned long) RTA_GET_U64(rta) * HZ)
00768244 TG	674	#define RTA_GET_MSECS(rta) (msecs_to_jiffies((unsigned long) RTA_GET_U64(rta)))
1da177e4 LT	675
	676	static inline struct rtattr *
	677	__rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
	678	{
	679	struct rtattr *rta;
	680	int size = RTA_LENGTH(attrlen);
	681
	682	rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
	683	rta->rta_type = attrtype;
	684	rta->rta_len = size;
b3563c4f	685	memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
1da177e4 LT	686	return rta;
	687	}
	688
	689	#define __RTA_PUT(skb, attrtype, attrlen) \
	690	({ if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
	691	goto rtattr_failure; \
	692	__rta_reserve(skb, attrtype, attrlen); })
	693
	694	extern void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change);
	695
6756ae4b	696	/* RTNL is used as a global lock for all changes to network configuration */
1da177e4	697	extern void rtnl_lock(void);
1da177e4	698	extern void rtnl_unlock(void);
6756ae4b SH	699	extern int rtnl_trylock(void);
6756ae4b SH	700
1da177e4	701	extern void rtnetlink_init(void);
6756ae4b	702	extern void __rtnl_unlock(void);
1da177e4 LT	703
1da177e4 LT	704	#define ASSERT_RTNL() do { \
6756ae4b SH	705	if (unlikely(rtnl_trylock())) { \
6756ae4b SH	706	rtnl_unlock(); \
1da177e4 LT	707	printk(KERN_ERR "RTNL: assertion failed at %s (%d)\n", \
	708	__FILE__, __LINE__); \
	709	dump_stack(); \
	710	} \
	711	} while(0)
	712
	713	#define BUG_TRAP(x) do { \
	714	if (unlikely(!(x))) { \
	715	printk(KERN_ERR "KERNEL: assertion (%s) failed at %s (%d)\n", \
	716	#x, __FILE__ , __LINE__); \
	717	} \
	718	} while(0)
	719
	720	#endif /* __KERNEL__ */
	721
	722
	723	#endif /* __LINUX_RTNETLINK_H */