Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 4e9b82693542003b028c8494e9e3c49615b91ce7

Authored by Thomas Graf 2006-11-28 01:25:58 +0800

Committed by David S. Miller 2006-12-03 13:30:43 +0800

Exists in master and in 7 other branches

[NETLINK]: Remove unused dst_pid field in netlink_skb_parms

The destination PID is passed directly to netlink_unicast()
respectively netlink_multicast().

Signed-off-by: Thomas Graf <tgraf@suug.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 7 changed files with 2 additions and 13 deletions Inline Diff

include/linux/netlink.h
net/decnet/dn_route.c
net/ipv4/fib_frontend.c
net/ipv4/netfilter/ip_conntrack_netlink.c
net/netfilter/nf_conntrack_netlink.c
net/netlink/af_netlink.c
net/xfrm/xfrm_user.c

include/linux/netlink.h

Diff comments View file @ 4e9b826

 #ifndef __LINUX_NETLINK_H
 #define __LINUX_NETLINK_H
 #include <linux/socket.h> /* for sa_family_t */
 #include <linux/types.h>
 #define NETLINK_ROUTE		0	/* Routing/device hook				*/
 #define NETLINK_UNUSED		1	/* Unused number				*/
 #define NETLINK_USERSOCK	2	/* Reserved for user mode socket protocols 	*/
 #define NETLINK_FIREWALL	3	/* Firewalling hook				*/
 #define NETLINK_INET_DIAG	4	/* INET socket monitoring			*/
 #define NETLINK_NFLOG		5	/* netfilter/iptables ULOG */
 #define NETLINK_XFRM		6	/* ipsec */
 #define NETLINK_SELINUX		7	/* SELinux event notifications */
 #define NETLINK_ISCSI		8	/* Open-iSCSI */
 #define NETLINK_AUDIT		9	/* auditing */
 #define NETLINK_FIB_LOOKUP	10
 #define NETLINK_CONNECTOR	11
 #define NETLINK_NETFILTER	12	/* netfilter subsystem */
 #define NETLINK_IP6_FW		13
 #define NETLINK_DNRTMSG		14	/* DECnet routing messages */
 #define NETLINK_KOBJECT_UEVENT	15	/* Kernel messages to userspace */
 #define NETLINK_GENERIC		16
 /* leave room for NETLINK_DM (DM Events) */
 #define NETLINK_SCSITRANSPORT	18	/* SCSI Transports */
 #define MAX_LINKS 32
 struct sockaddr_nl
 {
 	sa_family_t	nl_family;	/* AF_NETLINK	*/
 	unsigned short	nl_pad;		/* zero		*/
 	__u32		nl_pid;		/* process pid	*/
        	__u32		nl_groups;	/* multicast groups mask */
 };
 struct nlmsghdr
 {
 	__u32		nlmsg_len;	/* Length of message including header */
 	__u16		nlmsg_type;	/* Message content */
 	__u16		nlmsg_flags;	/* Additional flags */
 	__u32		nlmsg_seq;	/* Sequence number */
 	__u32		nlmsg_pid;	/* Sending process PID */
 };
 /* Flags values */
 #define NLM_F_REQUEST		1	/* It is request message. 	*/
 #define NLM_F_MULTI		2	/* Multipart message, terminated by NLMSG_DONE */
 #define NLM_F_ACK		4	/* Reply with ack, with zero or error code */
 #define NLM_F_ECHO		8	/* Echo this request 		*/
 /* Modifiers to GET request */
 #define NLM_F_ROOT	0x100	/* specify tree	root	*/
 #define NLM_F_MATCH	0x200	/* return all matching	*/
 #define NLM_F_ATOMIC	0x400	/* atomic GET		*/
 #define NLM_F_DUMP	(NLM_F_ROOT|NLM_F_MATCH)
 /* Modifiers to NEW request */
 #define NLM_F_REPLACE	0x100	/* Override existing		*/
 #define NLM_F_EXCL	0x200	/* Do not touch, if it exists	*/
 #define NLM_F_CREATE	0x400	/* Create, if it does not exist	*/
 #define NLM_F_APPEND	0x800	/* Add to end of list		*/
 /*
    4.4BSD ADD		NLM_F_CREATE|NLM_F_EXCL
    4.4BSD CHANGE	NLM_F_REPLACE
    True CHANGE		NLM_F_CREATE|NLM_F_REPLACE
    Append		NLM_F_CREATE
    Check		NLM_F_EXCL
  */
 #define NLMSG_ALIGNTO	4
 #define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )
 #define NLMSG_HDRLEN	 ((int) NLMSG_ALIGN(sizeof(struct nlmsghdr)))
 #define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(NLMSG_HDRLEN))
 #define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len))
 #define NLMSG_DATA(nlh)  ((void*)(((char*)nlh) + NLMSG_LENGTH(0)))
 #define NLMSG_NEXT(nlh,len)	 ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
 				  (struct nlmsghdr*)(((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))
 #define NLMSG_OK(nlh,len) ((len) >= (int)sizeof(struct nlmsghdr) && \
 			   (nlh)->nlmsg_len >= sizeof(struct nlmsghdr) && \
 			   (nlh)->nlmsg_len <= (len))
 #define NLMSG_PAYLOAD(nlh,len) ((nlh)->nlmsg_len - NLMSG_SPACE((len)))
 #define NLMSG_NOOP		0x1	/* Nothing.		*/
 #define NLMSG_ERROR		0x2	/* Error		*/
 #define NLMSG_DONE		0x3	/* End of a dump	*/
 #define NLMSG_OVERRUN		0x4	/* Data lost		*/
 #define NLMSG_MIN_TYPE		0x10	/* < 0x10: reserved control messages */
 struct nlmsgerr
 {
 	int		error;
 	struct nlmsghdr msg;
 };
 #define NETLINK_ADD_MEMBERSHIP	1
 #define NETLINK_DROP_MEMBERSHIP	2
 #define NETLINK_PKTINFO		3
 struct nl_pktinfo
 {
 	__u32	group;
 };
 #define NET_MAJOR 36		/* Major 36 is reserved for networking 						*/
 enum {
 	NETLINK_UNCONNECTED = 0,
 	NETLINK_CONNECTED,
 };
 /*
  *  <------- NLA_HDRLEN ------> <-- NLA_ALIGN(payload)-->
  * +---------------------+- - -+- - - - - - - - - -+- - -+
  * |        Header       | Pad |     Payload       | Pad |
  * |   (struct nlattr)   | ing |                   | ing |
  * +---------------------+- - -+- - - - - - - - - -+- - -+
  *  <-------------- nlattr->nla_len -------------->
  */
 struct nlattr
 {
 	__u16           nla_len;
 	__u16           nla_type;
 };
 #define NLA_ALIGNTO		4
 #define NLA_ALIGN(len)		(((len) + NLA_ALIGNTO - 1) & ~(NLA_ALIGNTO - 1))
 #define NLA_HDRLEN		((int) NLA_ALIGN(sizeof(struct nlattr)))
 #ifdef __KERNEL__
 #include <linux/capability.h>
 #include <linux/skbuff.h>
 struct netlink_skb_parms
 {
 	struct ucred		creds;		/* Skb credentials	*/
 	__u32			pid;
-	__u32			dst_pid;
 	__u32			dst_group;
 	kernel_cap_t		eff_cap;
 	__u32			loginuid;	/* Login (audit) uid */
 	__u32			sid;		/* SELinux security id */
 };
 #define NETLINK_CB(skb)		(*(struct netlink_skb_parms*)&((skb)->cb))
 #define NETLINK_CREDS(skb)	(&NETLINK_CB((skb)).creds)
 extern struct sock *netlink_kernel_create(int unit, unsigned int groups, void (*input)(struct sock *sk, int len), struct module *module);
 extern void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err);
 extern int netlink_has_listeners(struct sock *sk, unsigned int group);
 extern int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 pid, int nonblock);
 extern int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 pid,
 			     __u32 group, gfp_t allocation);
 extern void netlink_set_err(struct sock *ssk, __u32 pid, __u32 group, int code);
 extern int netlink_register_notifier(struct notifier_block *nb);
 extern int netlink_unregister_notifier(struct notifier_block *nb);
 /* finegrained unicast helpers: */
 struct sock *netlink_getsockbyfilp(struct file *filp);
 int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
 		long timeo, struct sock *ssk);
 void netlink_detachskb(struct sock *sk, struct sk_buff *skb);
 int netlink_sendskb(struct sock *sk, struct sk_buff *skb, int protocol);
 /*
  *	skb should fit one page. This choice is good for headerless malloc.
  */
 #define NLMSG_GOODORDER 0
 #define NLMSG_GOODSIZE (SKB_MAX_ORDER(0, NLMSG_GOODORDER))
 #define NLMSG_DEFAULT_SIZE (NLMSG_GOODSIZE - NLMSG_HDRLEN)
 struct netlink_callback
 {
 	struct sk_buff	*skb;
 	struct nlmsghdr	*nlh;
 	int		(*dump)(struct sk_buff * skb, struct netlink_callback *cb);
 	int		(*done)(struct netlink_callback *cb);
 	int		family;
 	long		args[5];
 };
 struct netlink_notify
 {
 	int pid;
 	int protocol;
 };
 static __inline__ struct nlmsghdr *
 __nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len, int flags)
 {
 	struct nlmsghdr *nlh;
 	int size = NLMSG_LENGTH(len);
 	nlh = (struct nlmsghdr*)skb_put(skb, NLMSG_ALIGN(size));
 	nlh->nlmsg_type = type;
 	nlh->nlmsg_len = size;
 	nlh->nlmsg_flags = flags;
 	nlh->nlmsg_pid = pid;
 	nlh->nlmsg_seq = seq;
 	memset(NLMSG_DATA(nlh) + len, 0, NLMSG_ALIGN(size) - size);
 	return nlh;
 }
 #define NLMSG_NEW(skb, pid, seq, type, len, flags) \
 ({	if (skb_tailroom(skb) < (int)NLMSG_SPACE(len)) \
 		goto nlmsg_failure; \
 	__nlmsg_put(skb, pid, seq, type, len, flags); })
 #define NLMSG_PUT(skb, pid, seq, type, len) \
 	NLMSG_NEW(skb, pid, seq, type, len, 0)
 #define NLMSG_NEW_ANSWER(skb, cb, type, len, flags) \
 	NLMSG_NEW(skb, NETLINK_CB((cb)->skb).pid, \
 		  (cb)->nlh->nlmsg_seq, type, len, flags)
 #define NLMSG_END(skb, nlh) \
 ({	(nlh)->nlmsg_len = (skb)->tail - (unsigned char *) (nlh); \
 	(skb)->len; })
 #define NLMSG_CANCEL(skb, nlh) \
 ({	skb_trim(skb, (unsigned char *) (nlh) - (skb)->data); \
 	-1; })
 extern int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
 			      struct nlmsghdr *nlh,
 			      int (*dump)(struct sk_buff *skb, struct netlink_callback*),
 			      int (*done)(struct netlink_callback*));
 #define NL_NONROOT_RECV 0x1
 #define NL_NONROOT_SEND 0x2
 extern void netlink_set_nonroot(int protocol, unsigned flag);
 #endif /* __KERNEL__ */
 #endif	/* __LINUX_NETLINK_H */

net/decnet/dn_route.c

Diff comments View file @ 4e9b826

 /*
  * DECnet       An implementation of the DECnet protocol suite for the LINUX
  *              operating system.  DECnet is implemented using the  BSD Socket
  *              interface as the means of communication with the user level.
  *
  *              DECnet Routing Functions (Endnode and Router)
  *
  * Authors:     Steve Whitehouse <SteveW@ACM.org>
  *              Eduardo Marcelo Serrat <emserrat@geocities.com>
  *
  * Changes:
  *              Steve Whitehouse : Fixes to allow "intra-ethernet" and
  *                                 "return-to-sender" bits on outgoing
  *                                 packets.
  *		Steve Whitehouse : Timeouts for cached routes.
  *              Steve Whitehouse : Use dst cache for input routes too.
  *              Steve Whitehouse : Fixed error values in dn_send_skb.
  *              Steve Whitehouse : Rework routing functions to better fit
  *                                 DECnet routing design
  *              Alexey Kuznetsov : New SMP locking
  *              Steve Whitehouse : More SMP locking changes & dn_cache_dump()
  *              Steve Whitehouse : Prerouting NF hook, now really is prerouting.
  *				   Fixed possible skb leak in rtnetlink funcs.
  *              Steve Whitehouse : Dave Miller's dynamic hash table sizing and
  *                                 Alexey Kuznetsov's finer grained locking
  *                                 from ipv4/route.c.
  *              Steve Whitehouse : Routing is now starting to look like a
  *                                 sensible set of code now, mainly due to
  *                                 my copying the IPv4 routing code. The
  *                                 hooks here are modified and will continue
  *                                 to evolve for a while.
  *              Steve Whitehouse : Real SMP at last :-) Also new netfilter
  *                                 stuff. Look out raw sockets your days
  *                                 are numbered!
  *              Steve Whitehouse : Added return-to-sender functions. Added
  *                                 backlog congestion level return codes.
  *		Steve Whitehouse : Fixed bug where routes were set up with
  *                                 no ref count on net devices.
  *              Steve Whitehouse : RCU for the route cache
  *              Steve Whitehouse : Preparations for the flow cache
  *              Steve Whitehouse : Prepare for nonlinear skbs
  */
 /******************************************************************************
     (c) 1995-1998 E.M. Serrat		emserrat@geocities.com
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     any later version.
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 *******************************************************************************/
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
 #include <linux/netdevice.h>
 #include <linux/inet.h>
 #include <linux/route.h>
 #include <linux/in_route.h>
 #include <net/sock.h>
 #include <linux/mm.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/rtnetlink.h>
 #include <linux/string.h>
 #include <linux/netfilter_decnet.h>
 #include <linux/rcupdate.h>
 #include <linux/times.h>
 #include <asm/errno.h>
 #include <net/neighbour.h>
 #include <net/dst.h>
 #include <net/flow.h>
 #include <net/fib_rules.h>
 #include <net/dn.h>
 #include <net/dn_dev.h>
 #include <net/dn_nsp.h>
 #include <net/dn_route.h>
 #include <net/dn_neigh.h>
 #include <net/dn_fib.h>
 struct dn_rt_hash_bucket
 {
 	struct dn_route *chain;
 	spinlock_t lock;
 } __attribute__((__aligned__(8)));
 extern struct neigh_table dn_neigh_table;
 static unsigned char dn_hiord_addr[6] = {0xAA,0x00,0x04,0x00,0x00,0x00};
 static const int dn_rt_min_delay = 2 * HZ;
 static const int dn_rt_max_delay = 10 * HZ;
 static const int dn_rt_mtu_expires = 10 * 60 * HZ;
 static unsigned long dn_rt_deadline;
 static int dn_dst_gc(void);
 static struct dst_entry *dn_dst_check(struct dst_entry *, __u32);
 static struct dst_entry *dn_dst_negative_advice(struct dst_entry *);
 static void dn_dst_link_failure(struct sk_buff *);
 static void dn_dst_update_pmtu(struct dst_entry *dst, u32 mtu);
 static int dn_route_input(struct sk_buff *);
 static void dn_run_flush(unsigned long dummy);
 static struct dn_rt_hash_bucket *dn_rt_hash_table;
 static unsigned dn_rt_hash_mask;
 static struct timer_list dn_route_timer;
 static DEFINE_TIMER(dn_rt_flush_timer, dn_run_flush, 0, 0);
 int decnet_dst_gc_interval = 2;
 static struct dst_ops dn_dst_ops = {
 	.family =		PF_DECnet,
 	.protocol =		__constant_htons(ETH_P_DNA_RT),
 	.gc_thresh =		128,
 	.gc =			dn_dst_gc,
 	.check =		dn_dst_check,
 	.negative_advice =	dn_dst_negative_advice,
 	.link_failure =		dn_dst_link_failure,
 	.update_pmtu =		dn_dst_update_pmtu,
 	.entry_size =		sizeof(struct dn_route),
 	.entries =		ATOMIC_INIT(0),
 };
 static __inline__ unsigned dn_hash(__le16 src, __le16 dst)
 {
 	__u16 tmp = (__u16 __force)(src ^ dst);
 	tmp ^= (tmp >> 3);
 	tmp ^= (tmp >> 5);
 	tmp ^= (tmp >> 10);
 	return dn_rt_hash_mask & (unsigned)tmp;
 }
 static inline void dnrt_free(struct dn_route *rt)
 {
 	call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
 }
 static inline void dnrt_drop(struct dn_route *rt)
 {
 	dst_release(&rt->u.dst);
 	call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
 }
 static void dn_dst_check_expire(unsigned long dummy)
 {
 	int i;
 	struct dn_route *rt, **rtp;
 	unsigned long now = jiffies;
 	unsigned long expire = 120 * HZ;
 	for(i = 0; i <= dn_rt_hash_mask; i++) {
 		rtp = &dn_rt_hash_table[i].chain;
 		spin_lock(&dn_rt_hash_table[i].lock);
 		while((rt=*rtp) != NULL) {
 			if (atomic_read(&rt->u.dst.__refcnt) ||
 					(now - rt->u.dst.lastuse) < expire) {
 				rtp = &rt->u.rt_next;
 				continue;
 			}
 			*rtp = rt->u.rt_next;
 			rt->u.rt_next = NULL;
 			dnrt_free(rt);
 		}
 		spin_unlock(&dn_rt_hash_table[i].lock);
 		if ((jiffies - now) > 0)
 			break;
 	}
 	mod_timer(&dn_route_timer, now + decnet_dst_gc_interval * HZ);
 }
 static int dn_dst_gc(void)
 {
 	struct dn_route *rt, **rtp;
 	int i;
 	unsigned long now = jiffies;
 	unsigned long expire = 10 * HZ;
 	for(i = 0; i <= dn_rt_hash_mask; i++) {
 		spin_lock_bh(&dn_rt_hash_table[i].lock);
 		rtp = &dn_rt_hash_table[i].chain;
 		while((rt=*rtp) != NULL) {
 			if (atomic_read(&rt->u.dst.__refcnt) ||
 					(now - rt->u.dst.lastuse) < expire) {
 				rtp = &rt->u.rt_next;
 				continue;
 			}
 			*rtp = rt->u.rt_next;
 			rt->u.rt_next = NULL;
 			dnrt_drop(rt);
 			break;
 		}
 		spin_unlock_bh(&dn_rt_hash_table[i].lock);
 	}
 	return 0;
 }
 /*
  * The decnet standards don't impose a particular minimum mtu, what they
  * do insist on is that the routing layer accepts a datagram of at least
  * 230 bytes long. Here we have to subtract the routing header length from
  * 230 to get the minimum acceptable mtu. If there is no neighbour, then we
  * assume the worst and use a long header size.
  *
  * We update both the mtu and the advertised mss (i.e. the segment size we
  * advertise to the other end).
  */
 static void dn_dst_update_pmtu(struct dst_entry *dst, u32 mtu)
 {
 	u32 min_mtu = 230;
 	struct dn_dev *dn = dst->neighbour ?
 			    (struct dn_dev *)dst->neighbour->dev->dn_ptr : NULL;
 	if (dn && dn->use_long == 0)
 		min_mtu -= 6;
 	else
 		min_mtu -= 21;
 	if (dst->metrics[RTAX_MTU-1] > mtu && mtu >= min_mtu) {
 		if (!(dst_metric_locked(dst, RTAX_MTU))) {
 			dst->metrics[RTAX_MTU-1] = mtu;
 			dst_set_expires(dst, dn_rt_mtu_expires);
 		}
 		if (!(dst_metric_locked(dst, RTAX_ADVMSS))) {
 			u32 mss = mtu - DN_MAX_NSP_DATA_HEADER;
 			if (dst->metrics[RTAX_ADVMSS-1] > mss)
 				dst->metrics[RTAX_ADVMSS-1] = mss;
 		}
 	}
 }
 /*
  * When a route has been marked obsolete. (e.g. routing cache flush)
  */
 static struct dst_entry *dn_dst_check(struct dst_entry *dst, __u32 cookie)
 {
 	return NULL;
 }
 static struct dst_entry *dn_dst_negative_advice(struct dst_entry *dst)
 {
 	dst_release(dst);
 	return NULL;
 }
 static void dn_dst_link_failure(struct sk_buff *skb)
 {
 	return;
 }
 static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
 {
 	return ((fl1->nl_u.dn_u.daddr ^ fl2->nl_u.dn_u.daddr) |
 		(fl1->nl_u.dn_u.saddr ^ fl2->nl_u.dn_u.saddr) |
 		(fl1->mark ^ fl2->mark) |
 		(fl1->nl_u.dn_u.scope ^ fl2->nl_u.dn_u.scope) |
 		(fl1->oif ^ fl2->oif) |
 		(fl1->iif ^ fl2->iif)) == 0;
 }
 static int dn_insert_route(struct dn_route *rt, unsigned hash, struct dn_route **rp)
 {
 	struct dn_route *rth, **rthp;
 	unsigned long now = jiffies;
 	rthp = &dn_rt_hash_table[hash].chain;
 	spin_lock_bh(&dn_rt_hash_table[hash].lock);
 	while((rth = *rthp) != NULL) {
 		if (compare_keys(&rth->fl, &rt->fl)) {
 			/* Put it first */
 			*rthp = rth->u.rt_next;
 			rcu_assign_pointer(rth->u.rt_next,
 					   dn_rt_hash_table[hash].chain);
 			rcu_assign_pointer(dn_rt_hash_table[hash].chain, rth);
 			rth->u.dst.__use++;
 			dst_hold(&rth->u.dst);
 			rth->u.dst.lastuse = now;
 			spin_unlock_bh(&dn_rt_hash_table[hash].lock);
 			dnrt_drop(rt);
 			*rp = rth;
 			return 0;
 		}
 		rthp = &rth->u.rt_next;
 	}
 	rcu_assign_pointer(rt->u.rt_next, dn_rt_hash_table[hash].chain);
 	rcu_assign_pointer(dn_rt_hash_table[hash].chain, rt);
 	dst_hold(&rt->u.dst);
 	rt->u.dst.__use++;
 	rt->u.dst.lastuse = now;
 	spin_unlock_bh(&dn_rt_hash_table[hash].lock);
 	*rp = rt;
 	return 0;
 }
 void dn_run_flush(unsigned long dummy)
 {
 	int i;
 	struct dn_route *rt, *next;
 	for(i = 0; i < dn_rt_hash_mask; i++) {
 		spin_lock_bh(&dn_rt_hash_table[i].lock);
 		if ((rt = xchg(&dn_rt_hash_table[i].chain, NULL)) == NULL)
 			goto nothing_to_declare;
 		for(; rt; rt=next) {
 			next = rt->u.rt_next;
 			rt->u.rt_next = NULL;
 			dst_free((struct dst_entry *)rt);
 		}
 nothing_to_declare:
 		spin_unlock_bh(&dn_rt_hash_table[i].lock);
 	}
 }
 static DEFINE_SPINLOCK(dn_rt_flush_lock);
 void dn_rt_cache_flush(int delay)
 {
 	unsigned long now = jiffies;
 	int user_mode = !in_interrupt();
 	if (delay < 0)
 		delay = dn_rt_min_delay;
 	spin_lock_bh(&dn_rt_flush_lock);
 	if (del_timer(&dn_rt_flush_timer) && delay > 0 && dn_rt_deadline) {
 		long tmo = (long)(dn_rt_deadline - now);
 		if (user_mode && tmo < dn_rt_max_delay - dn_rt_min_delay)
 			tmo = 0;
 		if (delay > tmo)
 			delay = tmo;
 	}
 	if (delay <= 0) {
 		spin_unlock_bh(&dn_rt_flush_lock);
 		dn_run_flush(0);
 		return;
 	}
 	if (dn_rt_deadline == 0)
 		dn_rt_deadline = now + dn_rt_max_delay;
 	dn_rt_flush_timer.expires = now + delay;
 	add_timer(&dn_rt_flush_timer);
 	spin_unlock_bh(&dn_rt_flush_lock);
 }
 /**
  * dn_return_short - Return a short packet to its sender
  * @skb: The packet to return
  *
  */
 static int dn_return_short(struct sk_buff *skb)
 {
 	struct dn_skb_cb *cb;
 	unsigned char *ptr;
 	__le16 *src;
 	__le16 *dst;
 	__le16 tmp;
 	/* Add back headers */
 	skb_push(skb, skb->data - skb->nh.raw);
 	if ((skb = skb_unshare(skb, GFP_ATOMIC)) == NULL)
 		return NET_RX_DROP;
 	cb = DN_SKB_CB(skb);
 	/* Skip packet length and point to flags */
 	ptr = skb->data + 2;
 	*ptr++ = (cb->rt_flags & ~DN_RT_F_RQR) | DN_RT_F_RTS;
 	dst = (__le16 *)ptr;
 	ptr += 2;
 	src = (__le16 *)ptr;
 	ptr += 2;
 	*ptr = 0; /* Zero hop count */
 	/* Swap source and destination */
 	tmp  = *src;
 	*src = *dst;
 	*dst = tmp;
 	skb->pkt_type = PACKET_OUTGOING;
 	dn_rt_finish_output(skb, NULL, NULL);
 	return NET_RX_SUCCESS;
 }
 /**
  * dn_return_long - Return a long packet to its sender
  * @skb: The long format packet to return
  *
  */
 static int dn_return_long(struct sk_buff *skb)
 {
 	struct dn_skb_cb *cb;
 	unsigned char *ptr;
 	unsigned char *src_addr, *dst_addr;
 	unsigned char tmp[ETH_ALEN];
 	/* Add back all headers */
 	skb_push(skb, skb->data - skb->nh.raw);
 	if ((skb = skb_unshare(skb, GFP_ATOMIC)) == NULL)
 		return NET_RX_DROP;
 	cb = DN_SKB_CB(skb);
 	/* Ignore packet length and point to flags */
 	ptr = skb->data + 2;
 	/* Skip padding */
 	if (*ptr & DN_RT_F_PF) {
 		char padlen = (*ptr & ~DN_RT_F_PF);
 		ptr += padlen;
 	}
 	*ptr++ = (cb->rt_flags & ~DN_RT_F_RQR) | DN_RT_F_RTS;
 	ptr += 2;
 	dst_addr = ptr;
 	ptr += 8;
 	src_addr = ptr;
 	ptr += 6;
 	*ptr = 0; /* Zero hop count */
 	/* Swap source and destination */
 	memcpy(tmp, src_addr, ETH_ALEN);
 	memcpy(src_addr, dst_addr, ETH_ALEN);
 	memcpy(dst_addr, tmp, ETH_ALEN);
 	skb->pkt_type = PACKET_OUTGOING;
 	dn_rt_finish_output(skb, dst_addr, src_addr);
 	return NET_RX_SUCCESS;
 }
 /**
  * dn_route_rx_packet - Try and find a route for an incoming packet
  * @skb: The packet to find a route for
  *
  * Returns: result of input function if route is found, error code otherwise
  */
 static int dn_route_rx_packet(struct sk_buff *skb)
 {
 	struct dn_skb_cb *cb = DN_SKB_CB(skb);
 	int err;
 	if ((err = dn_route_input(skb)) == 0)
 		return dst_input(skb);
 	if (decnet_debug_level & 4) {
 		char *devname = skb->dev ? skb->dev->name : "???";
 		struct dn_skb_cb *cb = DN_SKB_CB(skb);
 		printk(KERN_DEBUG
 			"DECnet: dn_route_rx_packet: rt_flags=0x%02x dev=%s len=%d src=0x%04hx dst=0x%04hx err=%d type=%d\n",
 			(int)cb->rt_flags, devname, skb->len,
 			dn_ntohs(cb->src), dn_ntohs(cb->dst),
 			err, skb->pkt_type);
 	}
 	if ((skb->pkt_type == PACKET_HOST) && (cb->rt_flags & DN_RT_F_RQR)) {
 		switch(cb->rt_flags & DN_RT_PKT_MSK) {
 			case DN_RT_PKT_SHORT:
 				return dn_return_short(skb);
 			case DN_RT_PKT_LONG:
 				return dn_return_long(skb);
 		}
 	}
 	kfree_skb(skb);
 	return NET_RX_DROP;
 }
 static int dn_route_rx_long(struct sk_buff *skb)
 {
 	struct dn_skb_cb *cb = DN_SKB_CB(skb);
 	unsigned char *ptr = skb->data;
 	if (!pskb_may_pull(skb, 21)) /* 20 for long header, 1 for shortest nsp */
 		goto drop_it;
 	skb_pull(skb, 20);
 	skb->h.raw = skb->data;
         /* Destination info */
         ptr += 2;
 	cb->dst = dn_eth2dn(ptr);
         if (memcmp(ptr, dn_hiord_addr, 4) != 0)
                 goto drop_it;
         ptr += 6;
         /* Source info */
         ptr += 2;
 	cb->src = dn_eth2dn(ptr);
         if (memcmp(ptr, dn_hiord_addr, 4) != 0)
                 goto drop_it;
         ptr += 6;
         /* Other junk */
         ptr++;
         cb->hops = *ptr++; /* Visit Count */
 	return NF_HOOK(PF_DECnet, NF_DN_PRE_ROUTING, skb, skb->dev, NULL, dn_route_rx_packet);
 drop_it:
 	kfree_skb(skb);
 	return NET_RX_DROP;
 }
 static int dn_route_rx_short(struct sk_buff *skb)
 {
 	struct dn_skb_cb *cb = DN_SKB_CB(skb);
 	unsigned char *ptr = skb->data;
 	if (!pskb_may_pull(skb, 6)) /* 5 for short header + 1 for shortest nsp */
 		goto drop_it;
 	skb_pull(skb, 5);
 	skb->h.raw = skb->data;
 	cb->dst = *(__le16 *)ptr;
         ptr += 2;
         cb->src = *(__le16 *)ptr;
         ptr += 2;
         cb->hops = *ptr & 0x3f;
 	return NF_HOOK(PF_DECnet, NF_DN_PRE_ROUTING, skb, skb->dev, NULL, dn_route_rx_packet);
 drop_it:
         kfree_skb(skb);
         return NET_RX_DROP;
 }
 static int dn_route_discard(struct sk_buff *skb)
 {
 	/*
 	 * I know we drop the packet here, but thats considered success in
 	 * this case
 	 */
 	kfree_skb(skb);
 	return NET_RX_SUCCESS;
 }
 static int dn_route_ptp_hello(struct sk_buff *skb)
 {
 	dn_dev_hello(skb);
 	dn_neigh_pointopoint_hello(skb);
 	return NET_RX_SUCCESS;
 }
 int dn_route_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
 {
 	struct dn_skb_cb *cb;
 	unsigned char flags = 0;
 	__u16 len = dn_ntohs(*(__le16 *)skb->data);
 	struct dn_dev *dn = (struct dn_dev *)dev->dn_ptr;
 	unsigned char padlen = 0;
 	if (dn == NULL)
 		goto dump_it;
 	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
 		goto out;
 	if (!pskb_may_pull(skb, 3))
 		goto dump_it;
 	skb_pull(skb, 2);
 	if (len > skb->len)
 		goto dump_it;
 	skb_trim(skb, len);
 	flags = *skb->data;
 	cb = DN_SKB_CB(skb);
 	cb->stamp = jiffies;
 	cb->iif = dev->ifindex;
 	/*
 	 * If we have padding, remove it.
 	 */
 	if (flags & DN_RT_F_PF) {
 		padlen = flags & ~DN_RT_F_PF;
 		if (!pskb_may_pull(skb, padlen + 1))
 			goto dump_it;
 		skb_pull(skb, padlen);
 		flags = *skb->data;
 	}
 	skb->nh.raw = skb->data;
 	/*
 	 * Weed out future version DECnet
 	 */
 	if (flags & DN_RT_F_VER)
 		goto dump_it;
 	cb->rt_flags = flags;
 	if (decnet_debug_level & 1)
 		printk(KERN_DEBUG
 			"dn_route_rcv: got 0x%02x from %s [%d %d %d]\n",
 			(int)flags, (dev) ? dev->name : "???", len, skb->len,
 			padlen);
         if (flags & DN_RT_PKT_CNTL) {
 		if (unlikely(skb_linearize(skb)))
 			goto dump_it;
                 switch(flags & DN_RT_CNTL_MSK) {
         	        case DN_RT_PKT_INIT:
 				dn_dev_init_pkt(skb);
 				break;
                 	case DN_RT_PKT_VERI:
 				dn_dev_veri_pkt(skb);
 				break;
 		}
 		if (dn->parms.state != DN_DEV_S_RU)
 			goto dump_it;
 		switch(flags & DN_RT_CNTL_MSK) {
                 	case DN_RT_PKT_HELO:
 				return NF_HOOK(PF_DECnet, NF_DN_HELLO, skb, skb->dev, NULL, dn_route_ptp_hello);
                 	case DN_RT_PKT_L1RT:
                 	case DN_RT_PKT_L2RT:
                                 return NF_HOOK(PF_DECnet, NF_DN_ROUTE, skb, skb->dev, NULL, dn_route_discard);
                 	case DN_RT_PKT_ERTH:
 				return NF_HOOK(PF_DECnet, NF_DN_HELLO, skb, skb->dev, NULL, dn_neigh_router_hello);
                 	case DN_RT_PKT_EEDH:
 				return NF_HOOK(PF_DECnet, NF_DN_HELLO, skb, skb->dev, NULL, dn_neigh_endnode_hello);
                 }
         } else {
 		if (dn->parms.state != DN_DEV_S_RU)
 			goto dump_it;
 		skb_pull(skb, 1); /* Pull flags */
                 switch(flags & DN_RT_PKT_MSK) {
                 	case DN_RT_PKT_LONG:
                         	return dn_route_rx_long(skb);
                 	case DN_RT_PKT_SHORT:
                         	return dn_route_rx_short(skb);
 		}
         }
 dump_it:
 	kfree_skb(skb);
 out:
 	return NET_RX_DROP;
 }
 static int dn_output(struct sk_buff *skb)
 {
 	struct dst_entry *dst = skb->dst;
 	struct dn_route *rt = (struct dn_route *)dst;
 	struct net_device *dev = dst->dev;
 	struct dn_skb_cb *cb = DN_SKB_CB(skb);
 	struct neighbour *neigh;
 	int err = -EINVAL;
 	if ((neigh = dst->neighbour) == NULL)
 		goto error;
 	skb->dev = dev;
 	cb->src = rt->rt_saddr;
 	cb->dst = rt->rt_daddr;
 	/*
 	 * Always set the Intra-Ethernet bit on all outgoing packets
 	 * originated on this node. Only valid flag from upper layers
 	 * is return-to-sender-requested. Set hop count to 0 too.
 	 */
 	cb->rt_flags &= ~DN_RT_F_RQR;
 	cb->rt_flags |= DN_RT_F_IE;
 	cb->hops = 0;
 	return NF_HOOK(PF_DECnet, NF_DN_LOCAL_OUT, skb, NULL, dev, neigh->output);
 error:
 	if (net_ratelimit())
 		printk(KERN_DEBUG "dn_output: This should not happen\n");
 	kfree_skb(skb);
 	return err;
 }
 static int dn_forward(struct sk_buff *skb)
 {
 	struct dn_skb_cb *cb = DN_SKB_CB(skb);
 	struct dst_entry *dst = skb->dst;
 	struct dn_dev *dn_db = dst->dev->dn_ptr;
 	struct dn_route *rt;
 	struct neighbour *neigh = dst->neighbour;
 	int header_len;
 #ifdef CONFIG_NETFILTER
 	struct net_device *dev = skb->dev;
 #endif
 	if (skb->pkt_type != PACKET_HOST)
 		goto drop;
 	/* Ensure that we have enough space for headers */
 	rt = (struct dn_route *)skb->dst;
 	header_len = dn_db->use_long ? 21 : 6;
 	if (skb_cow(skb, LL_RESERVED_SPACE(rt->u.dst.dev)+header_len))
 		goto drop;
 	/*
 	 * Hop count exceeded.
 	 */
 	if (++cb->hops > 30)
 		goto drop;
 	skb->dev = rt->u.dst.dev;
 	/*
 	 * If packet goes out same interface it came in on, then set
 	 * the Intra-Ethernet bit. This has no effect for short
 	 * packets, so we don't need to test for them here.
 	 */
 	cb->rt_flags &= ~DN_RT_F_IE;
 	if (rt->rt_flags & RTCF_DOREDIRECT)
 		cb->rt_flags |= DN_RT_F_IE;
 	return NF_HOOK(PF_DECnet, NF_DN_FORWARD, skb, dev, skb->dev, neigh->output);
 drop:
 	kfree_skb(skb);
 	return NET_RX_DROP;
 }
 /*
  * Drop packet. This is used for endnodes and for
  * when we should not be forwarding packets from
  * this dest.
  */
 static int dn_blackhole(struct sk_buff *skb)
 {
 	kfree_skb(skb);
 	return NET_RX_DROP;
 }
 /*
  * Used to catch bugs. This should never normally get
  * called.
  */
 static int dn_rt_bug(struct sk_buff *skb)
 {
 	if (net_ratelimit()) {
 		struct dn_skb_cb *cb = DN_SKB_CB(skb);
 		printk(KERN_DEBUG "dn_rt_bug: skb from:%04x to:%04x\n",
 				dn_ntohs(cb->src), dn_ntohs(cb->dst));
 	}
 	kfree_skb(skb);
 	return NET_RX_BAD;
 }
 static int dn_rt_set_next_hop(struct dn_route *rt, struct dn_fib_res *res)
 {
 	struct dn_fib_info *fi = res->fi;
 	struct net_device *dev = rt->u.dst.dev;
 	struct neighbour *n;
 	unsigned mss;
 	if (fi) {
 		if (DN_FIB_RES_GW(*res) &&
 		    DN_FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
 			rt->rt_gateway = DN_FIB_RES_GW(*res);
 		memcpy(rt->u.dst.metrics, fi->fib_metrics,
 		       sizeof(rt->u.dst.metrics));
 	}
 	rt->rt_type = res->type;
 	if (dev != NULL && rt->u.dst.neighbour == NULL) {
 		n = __neigh_lookup_errno(&dn_neigh_table, &rt->rt_gateway, dev);
 		if (IS_ERR(n))
 			return PTR_ERR(n);
 		rt->u.dst.neighbour = n;
 	}
 	if (rt->u.dst.metrics[RTAX_MTU-1] == 0 ||
             rt->u.dst.metrics[RTAX_MTU-1] > rt->u.dst.dev->mtu)
 		rt->u.dst.metrics[RTAX_MTU-1] = rt->u.dst.dev->mtu;
 	mss = dn_mss_from_pmtu(dev, dst_mtu(&rt->u.dst));
 	if (rt->u.dst.metrics[RTAX_ADVMSS-1] == 0 ||
 	    rt->u.dst.metrics[RTAX_ADVMSS-1] > mss)
 		rt->u.dst.metrics[RTAX_ADVMSS-1] = mss;
 	return 0;
 }
 static inline int dn_match_addr(__le16 addr1, __le16 addr2)
 {
 	__u16 tmp = dn_ntohs(addr1) ^ dn_ntohs(addr2);
 	int match = 16;
 	while(tmp) {
 		tmp >>= 1;
 		match--;
 	}
 	return match;
 }
 static __le16 dnet_select_source(const struct net_device *dev, __le16 daddr, int scope)
 {
 	__le16 saddr = 0;
 	struct dn_dev *dn_db = dev->dn_ptr;
 	struct dn_ifaddr *ifa;
 	int best_match = 0;
 	int ret;
 	read_lock(&dev_base_lock);
 	for(ifa = dn_db->ifa_list; ifa; ifa = ifa->ifa_next) {
 		if (ifa->ifa_scope > scope)
 			continue;
 		if (!daddr) {
 			saddr = ifa->ifa_local;
 			break;
 		}
 		ret = dn_match_addr(daddr, ifa->ifa_local);
 		if (ret > best_match)
 			saddr = ifa->ifa_local;
 		if (best_match == 0)
 			saddr = ifa->ifa_local;
 	}
 	read_unlock(&dev_base_lock);
 	return saddr;
 }
 static inline __le16 __dn_fib_res_prefsrc(struct dn_fib_res *res)
 {
 	return dnet_select_source(DN_FIB_RES_DEV(*res), DN_FIB_RES_GW(*res), res->scope);
 }
 static inline __le16 dn_fib_rules_map_destination(__le16 daddr, struct dn_fib_res *res)
 {
 	__le16 mask = dnet_make_mask(res->prefixlen);
 	return (daddr&~mask)|res->fi->fib_nh->nh_gw;
 }
 static int dn_route_output_slow(struct dst_entry **pprt, const struct flowi *oldflp, int try_hard)
 {
 	struct flowi fl = { .nl_u = { .dn_u =
 				      { .daddr = oldflp->fld_dst,
 					.saddr = oldflp->fld_src,
 					.scope = RT_SCOPE_UNIVERSE,
 				     } },
 			    .mark = oldflp->mark,
 			    .iif = loopback_dev.ifindex,
 			    .oif = oldflp->oif };
 	struct dn_route *rt = NULL;
 	struct net_device *dev_out = NULL;
 	struct neighbour *neigh = NULL;
 	unsigned hash;
 	unsigned flags = 0;
 	struct dn_fib_res res = { .fi = NULL, .type = RTN_UNICAST };
 	int err;
 	int free_res = 0;
 	__le16 gateway = 0;
 	if (decnet_debug_level & 16)
 		printk(KERN_DEBUG
 		       "dn_route_output_slow: dst=%04x src=%04x mark=%d"
 		       " iif=%d oif=%d\n", dn_ntohs(oldflp->fld_dst),
 		       dn_ntohs(oldflp->fld_src),
                        oldflp->mark, loopback_dev.ifindex, oldflp->oif);
 	/* If we have an output interface, verify its a DECnet device */
 	if (oldflp->oif) {
 		dev_out = dev_get_by_index(oldflp->oif);
 		err = -ENODEV;
 		if (dev_out && dev_out->dn_ptr == NULL) {
 			dev_put(dev_out);
 			dev_out = NULL;
 		}
 		if (dev_out == NULL)
 			goto out;
 	}
 	/* If we have a source address, verify that its a local address */
 	if (oldflp->fld_src) {
 		err = -EADDRNOTAVAIL;
 		if (dev_out) {
 			if (dn_dev_islocal(dev_out, oldflp->fld_src))
 				goto source_ok;
 			dev_put(dev_out);
 			goto out;
 		}
 		read_lock(&dev_base_lock);
 		for(dev_out = dev_base; dev_out; dev_out = dev_out->next) {
 			if (!dev_out->dn_ptr)
 				continue;
 			if (!dn_dev_islocal(dev_out, oldflp->fld_src))
 				continue;
 			if ((dev_out->flags & IFF_LOOPBACK) &&
 			    oldflp->fld_dst &&
 			    !dn_dev_islocal(dev_out, oldflp->fld_dst))
 				continue;
 			break;
 		}
 		read_unlock(&dev_base_lock);
 		if (dev_out == NULL)
 			goto out;
 		dev_hold(dev_out);
 source_ok:
 		;
 	}
 	/* No destination? Assume its local */
 	if (!fl.fld_dst) {
 		fl.fld_dst = fl.fld_src;
 		err = -EADDRNOTAVAIL;
 		if (dev_out)
 			dev_put(dev_out);
 		dev_out = &loopback_dev;
 		dev_hold(dev_out);
 		if (!fl.fld_dst) {
 			fl.fld_dst =
 			fl.fld_src = dnet_select_source(dev_out, 0,
 						       RT_SCOPE_HOST);
 			if (!fl.fld_dst)
 				goto out;
 		}
 		fl.oif = loopback_dev.ifindex;
 		res.type = RTN_LOCAL;
 		goto make_route;
 	}
 	if (decnet_debug_level & 16)
 		printk(KERN_DEBUG
 		       "dn_route_output_slow: initial checks complete."
 		       " dst=%o4x src=%04x oif=%d try_hard=%d\n",
 		       dn_ntohs(fl.fld_dst), dn_ntohs(fl.fld_src),
 		       fl.oif, try_hard);
 	/*
 	 * N.B. If the kernel is compiled without router support then
 	 * dn_fib_lookup() will evaluate to non-zero so this if () block
 	 * will always be executed.
 	 */
 	err = -ESRCH;
 	if (try_hard || (err = dn_fib_lookup(&fl, &res)) != 0) {
 		struct dn_dev *dn_db;
 		if (err != -ESRCH)
 			goto out;
 		/*
 	 	 * Here the fallback is basically the standard algorithm for
 		 * routing in endnodes which is described in the DECnet routing
 		 * docs
 		 *
 		 * If we are not trying hard, look in neighbour cache.
 		 * The result is tested to ensure that if a specific output
 		 * device/source address was requested, then we honour that
 		 * here
 		 */
 		if (!try_hard) {
 			neigh = neigh_lookup_nodev(&dn_neigh_table, &fl.fld_dst);
 			if (neigh) {
 				if ((oldflp->oif &&
 				    (neigh->dev->ifindex != oldflp->oif)) ||
 				    (oldflp->fld_src &&
 				    (!dn_dev_islocal(neigh->dev,
 						      oldflp->fld_src)))) {
 					neigh_release(neigh);
 					neigh = NULL;
 				} else {
 					if (dev_out)
 						dev_put(dev_out);
 					if (dn_dev_islocal(neigh->dev, fl.fld_dst)) {
 						dev_out = &loopback_dev;
 						res.type = RTN_LOCAL;
 					} else {
 						dev_out = neigh->dev;
 					}
 					dev_hold(dev_out);
 					goto select_source;
 				}
 			}
 		}
 		/* Not there? Perhaps its a local address */
 		if (dev_out == NULL)
 			dev_out = dn_dev_get_default();
 		err = -ENODEV;
 		if (dev_out == NULL)
 			goto out;
 		dn_db = dev_out->dn_ptr;
 		/* Possible improvement - check all devices for local addr */
 		if (dn_dev_islocal(dev_out, fl.fld_dst)) {
 			dev_put(dev_out);
 			dev_out = &loopback_dev;
 			dev_hold(dev_out);
 			res.type = RTN_LOCAL;
 			goto select_source;
 		}
 		/* Not local either.... try sending it to the default router */
 		neigh = neigh_clone(dn_db->router);
 		BUG_ON(neigh && neigh->dev != dev_out);
 		/* Ok then, we assume its directly connected and move on */
 select_source:
 		if (neigh)
 			gateway = ((struct dn_neigh *)neigh)->addr;
 		if (gateway == 0)
 			gateway = fl.fld_dst;
 		if (fl.fld_src == 0) {
 			fl.fld_src = dnet_select_source(dev_out, gateway,
 							 res.type == RTN_LOCAL ?
 							 RT_SCOPE_HOST :
 							 RT_SCOPE_LINK);
 			if (fl.fld_src == 0 && res.type != RTN_LOCAL)
 				goto e_addr;
 		}
 		fl.oif = dev_out->ifindex;
 		goto make_route;
 	}
 	free_res = 1;
 	if (res.type == RTN_NAT)
 		goto e_inval;
 	if (res.type == RTN_LOCAL) {
 		if (!fl.fld_src)
 			fl.fld_src = fl.fld_dst;
 		if (dev_out)
 			dev_put(dev_out);
 		dev_out = &loopback_dev;
 		dev_hold(dev_out);
 		fl.oif = dev_out->ifindex;
 		if (res.fi)
 			dn_fib_info_put(res.fi);
 		res.fi = NULL;
 		goto make_route;
 	}
 	if (res.fi->fib_nhs > 1 && fl.oif == 0)
 		dn_fib_select_multipath(&fl, &res);
 	/*
 	 * We could add some logic to deal with default routes here and
 	 * get rid of some of the special casing above.
 	 */
 	if (!fl.fld_src)
 		fl.fld_src = DN_FIB_RES_PREFSRC(res);
 	if (dev_out)
 		dev_put(dev_out);
 	dev_out = DN_FIB_RES_DEV(res);
 	dev_hold(dev_out);
 	fl.oif = dev_out->ifindex;
 	gateway = DN_FIB_RES_GW(res);
 make_route:
 	if (dev_out->flags & IFF_LOOPBACK)
 		flags |= RTCF_LOCAL;
 	rt = dst_alloc(&dn_dst_ops);
 	if (rt == NULL)
 		goto e_nobufs;
 	atomic_set(&rt->u.dst.__refcnt, 1);
 	rt->u.dst.flags   = DST_HOST;
 	rt->fl.fld_src    = oldflp->fld_src;
 	rt->fl.fld_dst    = oldflp->fld_dst;
 	rt->fl.oif        = oldflp->oif;
 	rt->fl.iif        = 0;
 	rt->fl.mark       = oldflp->mark;
 	rt->rt_saddr      = fl.fld_src;
 	rt->rt_daddr      = fl.fld_dst;
 	rt->rt_gateway    = gateway ? gateway : fl.fld_dst;
 	rt->rt_local_src  = fl.fld_src;
 	rt->rt_dst_map    = fl.fld_dst;
 	rt->rt_src_map    = fl.fld_src;
 	rt->u.dst.dev = dev_out;
 	dev_hold(dev_out);
 	rt->u.dst.neighbour = neigh;
 	neigh = NULL;
 	rt->u.dst.lastuse = jiffies;
 	rt->u.dst.output  = dn_output;
 	rt->u.dst.input   = dn_rt_bug;
 	rt->rt_flags      = flags;
 	if (flags & RTCF_LOCAL)
 		rt->u.dst.input = dn_nsp_rx;
 	err = dn_rt_set_next_hop(rt, &res);
 	if (err)
 		goto e_neighbour;
 	hash = dn_hash(rt->fl.fld_src, rt->fl.fld_dst);
 	dn_insert_route(rt, hash, (struct dn_route **)pprt);
 done:
 	if (neigh)
 		neigh_release(neigh);
 	if (free_res)
 		dn_fib_res_put(&res);
 	if (dev_out)
 		dev_put(dev_out);
 out:
 	return err;
 e_addr:
         err = -EADDRNOTAVAIL;
         goto done;
 e_inval:
 	err = -EINVAL;
 	goto done;
 e_nobufs:
 	err = -ENOBUFS;
 	goto done;
 e_neighbour:
 	dst_free(&rt->u.dst);
 	goto e_nobufs;
 }
 /*
  * N.B. The flags may be moved into the flowi at some future stage.
  */
 static int __dn_route_output_key(struct dst_entry **pprt, const struct flowi *flp, int flags)
 {
 	unsigned hash = dn_hash(flp->fld_src, flp->fld_dst);
 	struct dn_route *rt = NULL;
 	if (!(flags & MSG_TRYHARD)) {
 		rcu_read_lock_bh();
 		for(rt = rcu_dereference(dn_rt_hash_table[hash].chain); rt;
 			rt = rcu_dereference(rt->u.rt_next)) {
 			if ((flp->fld_dst == rt->fl.fld_dst) &&
 			    (flp->fld_src == rt->fl.fld_src) &&
 			    (flp->mark == rt->fl.mark) &&
 			    (rt->fl.iif == 0) &&
 			    (rt->fl.oif == flp->oif)) {
 				rt->u.dst.lastuse = jiffies;
 				dst_hold(&rt->u.dst);
 				rt->u.dst.__use++;
 				rcu_read_unlock_bh();
 				*pprt = &rt->u.dst;
 				return 0;
 			}
 		}
 		rcu_read_unlock_bh();
 	}
 	return dn_route_output_slow(pprt, flp, flags);
 }
 static int dn_route_output_key(struct dst_entry **pprt, struct flowi *flp, int flags)
 {
 	int err;
 	err = __dn_route_output_key(pprt, flp, flags);
 	if (err == 0 && flp->proto) {
 		err = xfrm_lookup(pprt, flp, NULL, 0);
 	}
 	return err;
 }
 int dn_route_output_sock(struct dst_entry **pprt, struct flowi *fl, struct sock *sk, int flags)
 {
 	int err;
 	err = __dn_route_output_key(pprt, fl, flags & MSG_TRYHARD);
 	if (err == 0 && fl->proto) {
 		err = xfrm_lookup(pprt, fl, sk, !(flags & MSG_DONTWAIT));
 	}
 	return err;
 }
 static int dn_route_input_slow(struct sk_buff *skb)
 {
 	struct dn_route *rt = NULL;
 	struct dn_skb_cb *cb = DN_SKB_CB(skb);
 	struct net_device *in_dev = skb->dev;
 	struct net_device *out_dev = NULL;
 	struct dn_dev *dn_db;
 	struct neighbour *neigh = NULL;
 	unsigned hash;
 	int flags = 0;
 	__le16 gateway = 0;
 	__le16 local_src = 0;
 	struct flowi fl = { .nl_u = { .dn_u =
 				     { .daddr = cb->dst,
 				       .saddr = cb->src,
 				       .scope = RT_SCOPE_UNIVERSE,
 				    } },
 			    .mark = skb->mark,
 			    .iif = skb->dev->ifindex };
 	struct dn_fib_res res = { .fi = NULL, .type = RTN_UNREACHABLE };
 	int err = -EINVAL;
 	int free_res = 0;
 	dev_hold(in_dev);
 	if ((dn_db = in_dev->dn_ptr) == NULL)
 		goto out;
 	/* Zero source addresses are not allowed */
 	if (fl.fld_src == 0)
 		goto out;
 	/*
 	 * In this case we've just received a packet from a source
 	 * outside ourselves pretending to come from us. We don't
 	 * allow it any further to prevent routing loops, spoofing and
 	 * other nasties. Loopback packets already have the dst attached
 	 * so this only affects packets which have originated elsewhere.
 	 */
 	err  = -ENOTUNIQ;
 	if (dn_dev_islocal(in_dev, cb->src))
 		goto out;
 	err = dn_fib_lookup(&fl, &res);
 	if (err) {
 		if (err != -ESRCH)
 			goto out;
 		/*
 		 * Is the destination us ?
 		 */
 		if (!dn_dev_islocal(in_dev, cb->dst))
 			goto e_inval;
 		res.type = RTN_LOCAL;
 	} else {
 		__le16 src_map = fl.fld_src;
 		free_res = 1;
 		out_dev = DN_FIB_RES_DEV(res);
 		if (out_dev == NULL) {
 			if (net_ratelimit())
 				printk(KERN_CRIT "Bug in dn_route_input_slow() "
 						 "No output device\n");
 			goto e_inval;
 		}
 		dev_hold(out_dev);
 		if (res.r)
 			src_map = fl.fld_src; /* no NAT support for now */
 		gateway = DN_FIB_RES_GW(res);
 		if (res.type == RTN_NAT) {
 			fl.fld_dst = dn_fib_rules_map_destination(fl.fld_dst, &res);
 			dn_fib_res_put(&res);
 			free_res = 0;
 			if (dn_fib_lookup(&fl, &res))
 				goto e_inval;
 			free_res = 1;
 			if (res.type != RTN_UNICAST)
 				goto e_inval;
 			flags |= RTCF_DNAT;
 			gateway = fl.fld_dst;
 		}
 		fl.fld_src = src_map;
 	}
 	switch(res.type) {
 	case RTN_UNICAST:
 		/*
 		 * Forwarding check here, we only check for forwarding
 		 * being turned off, if you want to only forward intra
 		 * area, its up to you to set the routing tables up
 		 * correctly.
 		 */
 		if (dn_db->parms.forwarding == 0)
 			goto e_inval;
 		if (res.fi->fib_nhs > 1 && fl.oif == 0)
 			dn_fib_select_multipath(&fl, &res);
 		/*
 		 * Check for out_dev == in_dev. We use the RTCF_DOREDIRECT
 		 * flag as a hint to set the intra-ethernet bit when
 		 * forwarding. If we've got NAT in operation, we don't do
 		 * this optimisation.
 		 */
 		if (out_dev == in_dev && !(flags & RTCF_NAT))
 			flags |= RTCF_DOREDIRECT;
 		local_src = DN_FIB_RES_PREFSRC(res);
 	case RTN_BLACKHOLE:
 	case RTN_UNREACHABLE:
 		break;
 	case RTN_LOCAL:
 		flags |= RTCF_LOCAL;
 		fl.fld_src = cb->dst;
 		fl.fld_dst = cb->src;
 		/* Routing tables gave us a gateway */
 		if (gateway)
 			goto make_route;
 		/* Packet was intra-ethernet, so we know its on-link */
 		if (cb->rt_flags & DN_RT_F_IE) {
 			gateway = cb->src;
 			flags |= RTCF_DIRECTSRC;
 			goto make_route;
 		}
 		/* Use the default router if there is one */
 		neigh = neigh_clone(dn_db->router);
 		if (neigh) {
 			gateway = ((struct dn_neigh *)neigh)->addr;
 			goto make_route;
 		}
 		/* Close eyes and pray */
 		gateway = cb->src;
 		flags |= RTCF_DIRECTSRC;
 		goto make_route;
 	default:
 		goto e_inval;
 	}
 make_route:
 	rt = dst_alloc(&dn_dst_ops);
 	if (rt == NULL)
 		goto e_nobufs;
 	rt->rt_saddr      = fl.fld_src;
 	rt->rt_daddr      = fl.fld_dst;
 	rt->rt_gateway    = fl.fld_dst;
 	if (gateway)
 		rt->rt_gateway = gateway;
 	rt->rt_local_src  = local_src ? local_src : rt->rt_saddr;
 	rt->rt_dst_map    = fl.fld_dst;
 	rt->rt_src_map    = fl.fld_src;
 	rt->fl.fld_src    = cb->src;
 	rt->fl.fld_dst    = cb->dst;
 	rt->fl.oif        = 0;
 	rt->fl.iif        = in_dev->ifindex;
 	rt->fl.mark       = fl.mark;
 	rt->u.dst.flags = DST_HOST;
 	rt->u.dst.neighbour = neigh;
 	rt->u.dst.dev = out_dev;
 	rt->u.dst.lastuse = jiffies;
 	rt->u.dst.output = dn_rt_bug;
 	switch(res.type) {
 		case RTN_UNICAST:
 			rt->u.dst.input = dn_forward;
 			break;
 		case RTN_LOCAL:
 			rt->u.dst.output = dn_output;
 			rt->u.dst.input = dn_nsp_rx;
 			rt->u.dst.dev = in_dev;
 			flags |= RTCF_LOCAL;
 			break;
 		default:
 		case RTN_UNREACHABLE:
 		case RTN_BLACKHOLE:
 			rt->u.dst.input = dn_blackhole;
 	}
 	rt->rt_flags = flags;
 	if (rt->u.dst.dev)
 		dev_hold(rt->u.dst.dev);
 	err = dn_rt_set_next_hop(rt, &res);
 	if (err)
 		goto e_neighbour;
 	hash = dn_hash(rt->fl.fld_src, rt->fl.fld_dst);
 	dn_insert_route(rt, hash, (struct dn_route **)&skb->dst);
 done:
 	if (neigh)
 		neigh_release(neigh);
 	if (free_res)
 		dn_fib_res_put(&res);
 	dev_put(in_dev);
 	if (out_dev)
 		dev_put(out_dev);
 out:
 	return err;
 e_inval:
 	err = -EINVAL;
 	goto done;
 e_nobufs:
 	err = -ENOBUFS;
 	goto done;
 e_neighbour:
 	dst_free(&rt->u.dst);
 	goto done;
 }
 int dn_route_input(struct sk_buff *skb)
 {
 	struct dn_route *rt;
 	struct dn_skb_cb *cb = DN_SKB_CB(skb);
 	unsigned hash = dn_hash(cb->src, cb->dst);
 	if (skb->dst)
 		return 0;
 	rcu_read_lock();
 	for(rt = rcu_dereference(dn_rt_hash_table[hash].chain); rt != NULL;
 	    rt = rcu_dereference(rt->u.rt_next)) {
 		if ((rt->fl.fld_src == cb->src) &&
 	 	    (rt->fl.fld_dst == cb->dst) &&
 		    (rt->fl.oif == 0) &&
 		    (rt->fl.mark == skb->mark) &&
 		    (rt->fl.iif == cb->iif)) {
 			rt->u.dst.lastuse = jiffies;
 			dst_hold(&rt->u.dst);
 			rt->u.dst.__use++;
 			rcu_read_unlock();
 			skb->dst = (struct dst_entry *)rt;
 			return 0;
 		}
 	}
 	rcu_read_unlock();
 	return dn_route_input_slow(skb);
 }
 static int dn_rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
 			   int event, int nowait, unsigned int flags)
 {
 	struct dn_route *rt = (struct dn_route *)skb->dst;
 	struct rtmsg *r;
 	struct nlmsghdr *nlh;
 	unsigned char *b = skb->tail;
 	struct rta_cacheinfo ci;
 	nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*r), flags);
 	r = NLMSG_DATA(nlh);
 	r->rtm_family = AF_DECnet;
 	r->rtm_dst_len = 16;
 	r->rtm_src_len = 0;
 	r->rtm_tos = 0;
 	r->rtm_table = RT_TABLE_MAIN;
 	RTA_PUT_U32(skb, RTA_TABLE, RT_TABLE_MAIN);
 	r->rtm_type = rt->rt_type;
 	r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
 	r->rtm_scope = RT_SCOPE_UNIVERSE;
 	r->rtm_protocol = RTPROT_UNSPEC;
 	if (rt->rt_flags & RTCF_NOTIFY)
 		r->rtm_flags |= RTM_F_NOTIFY;
 	RTA_PUT(skb, RTA_DST, 2, &rt->rt_daddr);
 	if (rt->fl.fld_src) {
 		r->rtm_src_len = 16;
 		RTA_PUT(skb, RTA_SRC, 2, &rt->fl.fld_src);
 	}
 	if (rt->u.dst.dev)
 		RTA_PUT(skb, RTA_OIF, sizeof(int), &rt->u.dst.dev->ifindex);
 	/*
 	 * Note to self - change this if input routes reverse direction when
 	 * they deal only with inputs and not with replies like they do
 	 * currently.
 	 */
 	RTA_PUT(skb, RTA_PREFSRC, 2, &rt->rt_local_src);
 	if (rt->rt_daddr != rt->rt_gateway)
 		RTA_PUT(skb, RTA_GATEWAY, 2, &rt->rt_gateway);
 	if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
 		goto rtattr_failure;
 	ci.rta_lastuse = jiffies_to_clock_t(jiffies - rt->u.dst.lastuse);
 	ci.rta_used     = rt->u.dst.__use;
 	ci.rta_clntref  = atomic_read(&rt->u.dst.__refcnt);
 	if (rt->u.dst.expires)
 		ci.rta_expires = jiffies_to_clock_t(rt->u.dst.expires - jiffies);
 	else
 		ci.rta_expires = 0;
 	ci.rta_error    = rt->u.dst.error;
 	ci.rta_id       = ci.rta_ts = ci.rta_tsage = 0;
 	RTA_PUT(skb, RTA_CACHEINFO, sizeof(ci), &ci);
 	if (rt->fl.iif)
 		RTA_PUT(skb, RTA_IIF, sizeof(int), &rt->fl.iif);
 	nlh->nlmsg_len = skb->tail - b;
 	return skb->len;
 nlmsg_failure:
 rtattr_failure:
         skb_trim(skb, b - skb->data);
         return -1;
 }
 /*
  * This is called by both endnodes and routers now.
  */
 int dn_cache_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh, void *arg)
 {
 	struct rtattr **rta = arg;
 	struct rtmsg *rtm = NLMSG_DATA(nlh);
 	struct dn_route *rt = NULL;
 	struct dn_skb_cb *cb;
 	int err;
 	struct sk_buff *skb;
 	struct flowi fl;
 	memset(&fl, 0, sizeof(fl));
 	fl.proto = DNPROTO_NSP;
 	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (skb == NULL)
 		return -ENOBUFS;
 	skb->mac.raw = skb->data;
 	cb = DN_SKB_CB(skb);
 	if (rta[RTA_SRC-1])
 		memcpy(&fl.fld_src, RTA_DATA(rta[RTA_SRC-1]), 2);
 	if (rta[RTA_DST-1])
 		memcpy(&fl.fld_dst, RTA_DATA(rta[RTA_DST-1]), 2);
 	if (rta[RTA_IIF-1])
 		memcpy(&fl.iif, RTA_DATA(rta[RTA_IIF-1]), sizeof(int));
 	if (fl.iif) {
 		struct net_device *dev;
 		if ((dev = dev_get_by_index(fl.iif)) == NULL) {
 			kfree_skb(skb);
 			return -ENODEV;
 		}
 		if (!dev->dn_ptr) {
 			dev_put(dev);
 			kfree_skb(skb);
 			return -ENODEV;
 		}
 		skb->protocol = __constant_htons(ETH_P_DNA_RT);
 		skb->dev = dev;
 		cb->src = fl.fld_src;
 		cb->dst = fl.fld_dst;
 		local_bh_disable();
 		err = dn_route_input(skb);
 		local_bh_enable();
 		memset(cb, 0, sizeof(struct dn_skb_cb));
 		rt = (struct dn_route *)skb->dst;
 		if (!err && -rt->u.dst.error)
 			err = rt->u.dst.error;
 	} else {
 		int oif = 0;
 		if (rta[RTA_OIF - 1])
 			memcpy(&oif, RTA_DATA(rta[RTA_OIF - 1]), sizeof(int));
 		fl.oif = oif;
 		err = dn_route_output_key((struct dst_entry **)&rt, &fl, 0);
 	}
 	if (skb->dev)
 		dev_put(skb->dev);
 	skb->dev = NULL;
 	if (err)
 		goto out_free;
 	skb->dst = &rt->u.dst;
 	if (rtm->rtm_flags & RTM_F_NOTIFY)
 		rt->rt_flags |= RTCF_NOTIFY;
-	NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
 	err = dn_rt_fill_info(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq, RTM_NEWROUTE, 0, 0);
 	if (err == 0)
 		goto out_free;
 	if (err < 0) {
 		err = -EMSGSIZE;
 		goto out_free;
 	}
 	return rtnl_unicast(skb, NETLINK_CB(in_skb).pid);
 out_free:
 	kfree_skb(skb);
 	return err;
 }
 /*
  * For routers, this is called from dn_fib_dump, but for endnodes its
  * called directly from the rtnetlink dispatch table.
  */
 int dn_cache_dump(struct sk_buff *skb, struct netlink_callback *cb)
 {
 	struct dn_route *rt;
 	int h, s_h;
 	int idx, s_idx;
 	if (NLMSG_PAYLOAD(cb->nlh, 0) < sizeof(struct rtmsg))
 		return -EINVAL;
 	if (!(((struct rtmsg *)NLMSG_DATA(cb->nlh))->rtm_flags&RTM_F_CLONED))
 		return 0;
 	s_h = cb->args[0];
 	s_idx = idx = cb->args[1];
 	for(h = 0; h <= dn_rt_hash_mask; h++) {
 		if (h < s_h)
 			continue;
 		if (h > s_h)
 			s_idx = 0;
 		rcu_read_lock_bh();
 		for(rt = rcu_dereference(dn_rt_hash_table[h].chain), idx = 0;
 			rt;
 			rt = rcu_dereference(rt->u.rt_next), idx++) {
 			if (idx < s_idx)
 				continue;
 			skb->dst = dst_clone(&rt->u.dst);
 			if (dn_rt_fill_info(skb, NETLINK_CB(cb->skb).pid,
 					cb->nlh->nlmsg_seq, RTM_NEWROUTE,
 					1, NLM_F_MULTI) <= 0) {
 				dst_release(xchg(&skb->dst, NULL));
 				rcu_read_unlock_bh();
 				goto done;
 			}
 			dst_release(xchg(&skb->dst, NULL));
 		}
 		rcu_read_unlock_bh();
 	}
 done:
 	cb->args[0] = h;
 	cb->args[1] = idx;
 	return skb->len;
 }
 #ifdef CONFIG_PROC_FS
 struct dn_rt_cache_iter_state {
 	int bucket;
 };
 static struct dn_route *dn_rt_cache_get_first(struct seq_file *seq)
 {
 	struct dn_route *rt = NULL;
 	struct dn_rt_cache_iter_state *s = seq->private;
 	for(s->bucket = dn_rt_hash_mask; s->bucket >= 0; --s->bucket) {
 		rcu_read_lock_bh();
 		rt = dn_rt_hash_table[s->bucket].chain;
 		if (rt)
 			break;
 		rcu_read_unlock_bh();
 	}
 	return rt;
 }
 static struct dn_route *dn_rt_cache_get_next(struct seq_file *seq, struct dn_route *rt)
 {
 	struct dn_rt_cache_iter_state *s = rcu_dereference(seq->private);
 	rt = rt->u.rt_next;
 	while(!rt) {
 		rcu_read_unlock_bh();
 		if (--s->bucket < 0)
 			break;
 		rcu_read_lock_bh();
 		rt = dn_rt_hash_table[s->bucket].chain;
 	}
 	return rt;
 }
 static void *dn_rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
 {
 	struct dn_route *rt = dn_rt_cache_get_first(seq);
 	if (rt) {
 		while(*pos && (rt = dn_rt_cache_get_next(seq, rt)))
 			--*pos;
 	}
 	return *pos ? NULL : rt;
 }
 static void *dn_rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
 	struct dn_route *rt = dn_rt_cache_get_next(seq, v);
 	++*pos;
 	return rt;
 }
 static void dn_rt_cache_seq_stop(struct seq_file *seq, void *v)
 {
 	if (v)
 		rcu_read_unlock_bh();
 }
 static int dn_rt_cache_seq_show(struct seq_file *seq, void *v)
 {
 	struct dn_route *rt = v;
 	char buf1[DN_ASCBUF_LEN], buf2[DN_ASCBUF_LEN];
 	seq_printf(seq, "%-8s %-7s %-7s %04d %04d %04d\n",
 			rt->u.dst.dev ? rt->u.dst.dev->name : "*",
 			dn_addr2asc(dn_ntohs(rt->rt_daddr), buf1),
 			dn_addr2asc(dn_ntohs(rt->rt_saddr), buf2),
 			atomic_read(&rt->u.dst.__refcnt),
 			rt->u.dst.__use,
 			(int) dst_metric(&rt->u.dst, RTAX_RTT));
 	return 0;
 }
 static struct seq_operations dn_rt_cache_seq_ops = {
 	.start	= dn_rt_cache_seq_start,
 	.next	= dn_rt_cache_seq_next,
 	.stop	= dn_rt_cache_seq_stop,
 	.show	= dn_rt_cache_seq_show,
 };
 static int dn_rt_cache_seq_open(struct inode *inode, struct file *file)
 {
 	struct seq_file *seq;
 	int rc = -ENOMEM;
 	struct dn_rt_cache_iter_state *s = kmalloc(sizeof(*s), GFP_KERNEL);
 	if (!s)
 		goto out;
 	rc = seq_open(file, &dn_rt_cache_seq_ops);
 	if (rc)
 		goto out_kfree;
 	seq		= file->private_data;
 	seq->private	= s;
 	memset(s, 0, sizeof(*s));
 out:
 	return rc;
 out_kfree:
 	kfree(s);
 	goto out;
 }
 static struct file_operations dn_rt_cache_seq_fops = {
 	.owner	 = THIS_MODULE,
 	.open	 = dn_rt_cache_seq_open,
 	.read	 = seq_read,
 	.llseek	 = seq_lseek,
 	.release = seq_release_private,
 };
 #endif /* CONFIG_PROC_FS */
 void __init dn_route_init(void)
 {
 	int i, goal, order;
 	dn_dst_ops.kmem_cachep =
 		kmem_cache_create("dn_dst_cache", sizeof(struct dn_route), 0,
 				  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
 	init_timer(&dn_route_timer);
 	dn_route_timer.function = dn_dst_check_expire;
 	dn_route_timer.expires = jiffies + decnet_dst_gc_interval * HZ;
 	add_timer(&dn_route_timer);
 	goal = num_physpages >> (26 - PAGE_SHIFT);
 	for(order = 0; (1UL << order) < goal; order++)
 		/* NOTHING */;
         /*
          * Only want 1024 entries max, since the table is very, very unlikely
          * to be larger than that.
          */
         while(order && ((((1UL << order) * PAGE_SIZE) /
                                 sizeof(struct dn_rt_hash_bucket)) >= 2048))
                 order--;
         do {
                 dn_rt_hash_mask = (1UL << order) * PAGE_SIZE /
                         sizeof(struct dn_rt_hash_bucket);
                 while(dn_rt_hash_mask & (dn_rt_hash_mask - 1))
                         dn_rt_hash_mask--;
                 dn_rt_hash_table = (struct dn_rt_hash_bucket *)
                         __get_free_pages(GFP_ATOMIC, order);
         } while (dn_rt_hash_table == NULL && --order > 0);
 	if (!dn_rt_hash_table)
                 panic("Failed to allocate DECnet route cache hash table\n");
 	printk(KERN_INFO
 		"DECnet: Routing cache hash table of %u buckets, %ldKbytes\n",
 		dn_rt_hash_mask,
 		(long)(dn_rt_hash_mask*sizeof(struct dn_rt_hash_bucket))/1024);
 	dn_rt_hash_mask--;
         for(i = 0; i <= dn_rt_hash_mask; i++) {
                 spin_lock_init(&dn_rt_hash_table[i].lock);
                 dn_rt_hash_table[i].chain = NULL;
         }
         dn_dst_ops.gc_thresh = (dn_rt_hash_mask + 1);
 	proc_net_fops_create("decnet_cache", S_IRUGO, &dn_rt_cache_seq_fops);
 }
 void __exit dn_route_cleanup(void)
 {
 	del_timer(&dn_route_timer);
 	dn_run_flush(0);
 	proc_net_remove("decnet_cache");
 }

net/ipv4/fib_frontend.c

Diff comments View file @ 4e9b826

 /*
  * INET		An implementation of the TCP/IP protocol suite for the LINUX
  *		operating system.  INET is implemented using the  BSD Socket
  *		interface as the means of communication with the user level.
  *
  *		IPv4 Forwarding Information Base: FIB frontend.
  *
  * Version:	$Id: fib_frontend.c,v 1.26 2001/10/31 21:55:54 davem Exp $
  *
  * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  *
  *		This program is free software; you can redistribute it and/or
  *		modify it under the terms of the GNU General Public License
  *		as published by the Free Software Foundation; either version
  *		2 of the License, or (at your option) any later version.
  */
 #include <linux/module.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <linux/bitops.h>
 #include <linux/capability.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
 #include <linux/errno.h>
 #include <linux/in.h>
 #include <linux/inet.h>
 #include <linux/inetdevice.h>
 #include <linux/netdevice.h>
 #include <linux/if_addr.h>
 #include <linux/if_arp.h>
 #include <linux/skbuff.h>
 #include <linux/netlink.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <net/ip.h>
 #include <net/protocol.h>
 #include <net/route.h>
 #include <net/tcp.h>
 #include <net/sock.h>
 #include <net/icmp.h>
 #include <net/arp.h>
 #include <net/ip_fib.h>
 #define FFprint(a...) printk(KERN_DEBUG a)
 #ifndef CONFIG_IP_MULTIPLE_TABLES
 struct fib_table *ip_fib_local_table;
 struct fib_table *ip_fib_main_table;
 #define FIB_TABLE_HASHSZ 1
 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
 #else
 #define FIB_TABLE_HASHSZ 256
 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
 struct fib_table *fib_new_table(u32 id)
 {
 	struct fib_table *tb;
 	unsigned int h;
 	if (id == 0)
 		id = RT_TABLE_MAIN;
 	tb = fib_get_table(id);
 	if (tb)
 		return tb;
 	tb = fib_hash_init(id);
 	if (!tb)
 		return NULL;
 	h = id & (FIB_TABLE_HASHSZ - 1);
 	hlist_add_head_rcu(&tb->tb_hlist, &fib_table_hash[h]);
 	return tb;
 }
 struct fib_table *fib_get_table(u32 id)
 {
 	struct fib_table *tb;
 	struct hlist_node *node;
 	unsigned int h;
 	if (id == 0)
 		id = RT_TABLE_MAIN;
 	h = id & (FIB_TABLE_HASHSZ - 1);
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(tb, node, &fib_table_hash[h], tb_hlist) {
 		if (tb->tb_id == id) {
 			rcu_read_unlock();
 			return tb;
 		}
 	}
 	rcu_read_unlock();
 	return NULL;
 }
 #endif /* CONFIG_IP_MULTIPLE_TABLES */
 static void fib_flush(void)
 {
 	int flushed = 0;
 	struct fib_table *tb;
 	struct hlist_node *node;
 	unsigned int h;
 	for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
 		hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist)
 			flushed += tb->tb_flush(tb);
 	}
 	if (flushed)
 		rt_cache_flush(-1);
 }
 /*
  *	Find the first device with a given source address.
  */
 struct net_device * ip_dev_find(__be32 addr)
 {
 	struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
 	struct fib_result res;
 	struct net_device *dev = NULL;
 #ifdef CONFIG_IP_MULTIPLE_TABLES
 	res.r = NULL;
 #endif
 	if (!ip_fib_local_table ||
 	    ip_fib_local_table->tb_lookup(ip_fib_local_table, &fl, &res))
 		return NULL;
 	if (res.type != RTN_LOCAL)
 		goto out;
 	dev = FIB_RES_DEV(res);
 	if (dev)
 		dev_hold(dev);
 out:
 	fib_res_put(&res);
 	return dev;
 }
 unsigned inet_addr_type(__be32 addr)
 {
 	struct flowi		fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
 	struct fib_result	res;
 	unsigned ret = RTN_BROADCAST;
 	if (ZERONET(addr) || BADCLASS(addr))
 		return RTN_BROADCAST;
 	if (MULTICAST(addr))
 		return RTN_MULTICAST;
 #ifdef CONFIG_IP_MULTIPLE_TABLES
 	res.r = NULL;
 #endif
 	if (ip_fib_local_table) {
 		ret = RTN_UNICAST;
 		if (!ip_fib_local_table->tb_lookup(ip_fib_local_table,
 						   &fl, &res)) {
 			ret = res.type;
 			fib_res_put(&res);
 		}
 	}
 	return ret;
 }
 /* Given (packet source, input interface) and optional (dst, oif, tos):
    - (main) check, that source is valid i.e. not broadcast or our local
      address.
    - figure out what "logical" interface this packet arrived
      and calculate "specific destination" address.
    - check, that packet arrived from expected physical interface.
  */
 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
 			struct net_device *dev, __be32 *spec_dst, u32 *itag)
 {
 	struct in_device *in_dev;
 	struct flowi fl = { .nl_u = { .ip4_u =
 				      { .daddr = src,
 					.saddr = dst,
 					.tos = tos } },
 			    .iif = oif };
 	struct fib_result res;
 	int no_addr, rpf;
 	int ret;
 	no_addr = rpf = 0;
 	rcu_read_lock();
 	in_dev = __in_dev_get_rcu(dev);
 	if (in_dev) {
 		no_addr = in_dev->ifa_list == NULL;
 		rpf = IN_DEV_RPFILTER(in_dev);
 	}
 	rcu_read_unlock();
 	if (in_dev == NULL)
 		goto e_inval;
 	if (fib_lookup(&fl, &res))
 		goto last_resort;
 	if (res.type != RTN_UNICAST)
 		goto e_inval_res;
 	*spec_dst = FIB_RES_PREFSRC(res);
 	fib_combine_itag(itag, &res);
 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 	if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
 #else
 	if (FIB_RES_DEV(res) == dev)
 #endif
 	{
 		ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
 		fib_res_put(&res);
 		return ret;
 	}
 	fib_res_put(&res);
 	if (no_addr)
 		goto last_resort;
 	if (rpf)
 		goto e_inval;
 	fl.oif = dev->ifindex;
 	ret = 0;
 	if (fib_lookup(&fl, &res) == 0) {
 		if (res.type == RTN_UNICAST) {
 			*spec_dst = FIB_RES_PREFSRC(res);
 			ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
 		}
 		fib_res_put(&res);
 	}
 	return ret;
 last_resort:
 	if (rpf)
 		goto e_inval;
 	*spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
 	*itag = 0;
 	return 0;
 e_inval_res:
 	fib_res_put(&res);
 e_inval:
 	return -EINVAL;
 }
 #ifndef CONFIG_IP_NOSIOCRT
 static inline __be32 sk_extract_addr(struct sockaddr *addr)
 {
 	return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
 }
 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
 {
 	struct nlattr *nla;
 	nla = (struct nlattr *) ((char *) mx + len);
 	nla->nla_type = type;
 	nla->nla_len = nla_attr_size(4);
 	*(u32 *) nla_data(nla) = value;
 	return len + nla_total_size(4);
 }
 static int rtentry_to_fib_config(int cmd, struct rtentry *rt,
 				 struct fib_config *cfg)
 {
 	__be32 addr;
 	int plen;
 	memset(cfg, 0, sizeof(*cfg));
 	if (rt->rt_dst.sa_family != AF_INET)
 		return -EAFNOSUPPORT;
 	/*
 	 * Check mask for validity:
 	 * a) it must be contiguous.
 	 * b) destination must have all host bits clear.
 	 * c) if application forgot to set correct family (AF_INET),
 	 *    reject request unless it is absolutely clear i.e.
 	 *    both family and mask are zero.
 	 */
 	plen = 32;
 	addr = sk_extract_addr(&rt->rt_dst);
 	if (!(rt->rt_flags & RTF_HOST)) {
 		__be32 mask = sk_extract_addr(&rt->rt_genmask);
 		if (rt->rt_genmask.sa_family != AF_INET) {
 			if (mask || rt->rt_genmask.sa_family)
 				return -EAFNOSUPPORT;
 		}
 		if (bad_mask(mask, addr))
 			return -EINVAL;
 		plen = inet_mask_len(mask);
 	}
 	cfg->fc_dst_len = plen;
 	cfg->fc_dst = addr;
 	if (cmd != SIOCDELRT) {
 		cfg->fc_nlflags = NLM_F_CREATE;
 		cfg->fc_protocol = RTPROT_BOOT;
 	}
 	if (rt->rt_metric)
 		cfg->fc_priority = rt->rt_metric - 1;
 	if (rt->rt_flags & RTF_REJECT) {
 		cfg->fc_scope = RT_SCOPE_HOST;
 		cfg->fc_type = RTN_UNREACHABLE;
 		return 0;
 	}
 	cfg->fc_scope = RT_SCOPE_NOWHERE;
 	cfg->fc_type = RTN_UNICAST;
 	if (rt->rt_dev) {
 		char *colon;
 		struct net_device *dev;
 		char devname[IFNAMSIZ];
 		if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
 			return -EFAULT;
 		devname[IFNAMSIZ-1] = 0;
 		colon = strchr(devname, ':');
 		if (colon)
 			*colon = 0;
 		dev = __dev_get_by_name(devname);
 		if (!dev)
 			return -ENODEV;
 		cfg->fc_oif = dev->ifindex;
 		if (colon) {
 			struct in_ifaddr *ifa;
 			struct in_device *in_dev = __in_dev_get_rtnl(dev);
 			if (!in_dev)
 				return -ENODEV;
 			*colon = ':';
 			for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
 				if (strcmp(ifa->ifa_label, devname) == 0)
 					break;
 			if (ifa == NULL)
 				return -ENODEV;
 			cfg->fc_prefsrc = ifa->ifa_local;
 		}
 	}
 	addr = sk_extract_addr(&rt->rt_gateway);
 	if (rt->rt_gateway.sa_family == AF_INET && addr) {
 		cfg->fc_gw = addr;
 		if (rt->rt_flags & RTF_GATEWAY &&
 		    inet_addr_type(addr) == RTN_UNICAST)
 			cfg->fc_scope = RT_SCOPE_UNIVERSE;
 	}
 	if (cmd == SIOCDELRT)
 		return 0;
 	if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
 		return -EINVAL;
 	if (cfg->fc_scope == RT_SCOPE_NOWHERE)
 		cfg->fc_scope = RT_SCOPE_LINK;
 	if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
 		struct nlattr *mx;
 		int len = 0;
 		mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
  		if (mx == NULL)
 			return -ENOMEM;
 		if (rt->rt_flags & RTF_MTU)
 			len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
 		if (rt->rt_flags & RTF_WINDOW)
 			len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
 		if (rt->rt_flags & RTF_IRTT)
 			len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
 		cfg->fc_mx = mx;
 		cfg->fc_mx_len = len;
 	}
 	return 0;
 }
 /*
  *	Handle IP routing ioctl calls. These are used to manipulate the routing tables
  */
 int ip_rt_ioctl(unsigned int cmd, void __user *arg)
 {
 	struct fib_config cfg;
 	struct rtentry rt;
 	int err;
 	switch (cmd) {
 	case SIOCADDRT:		/* Add a route */
 	case SIOCDELRT:		/* Delete a route */
 		if (!capable(CAP_NET_ADMIN))
 			return -EPERM;
 		if (copy_from_user(&rt, arg, sizeof(rt)))
 			return -EFAULT;
 		rtnl_lock();
 		err = rtentry_to_fib_config(cmd, &rt, &cfg);
 		if (err == 0) {
 			struct fib_table *tb;
 			if (cmd == SIOCDELRT) {
 				tb = fib_get_table(cfg.fc_table);
 				if (tb)
 					err = tb->tb_delete(tb, &cfg);
 				else
 					err = -ESRCH;
 			} else {
 				tb = fib_new_table(cfg.fc_table);
 				if (tb)
 					err = tb->tb_insert(tb, &cfg);
 				else
 					err = -ENOBUFS;
 			}
 			/* allocated by rtentry_to_fib_config() */
 			kfree(cfg.fc_mx);
 		}
 		rtnl_unlock();
 		return err;
 	}
 	return -EINVAL;
 }
 #else
 int ip_rt_ioctl(unsigned int cmd, void *arg)
 {
 	return -EINVAL;
 }
 #endif
 struct nla_policy rtm_ipv4_policy[RTA_MAX+1] __read_mostly = {
 	[RTA_DST]		= { .type = NLA_U32 },
 	[RTA_SRC]		= { .type = NLA_U32 },
 	[RTA_IIF]		= { .type = NLA_U32 },
 	[RTA_OIF]		= { .type = NLA_U32 },
 	[RTA_GATEWAY]		= { .type = NLA_U32 },
 	[RTA_PRIORITY]		= { .type = NLA_U32 },
 	[RTA_PREFSRC]		= { .type = NLA_U32 },
 	[RTA_METRICS]		= { .type = NLA_NESTED },
 	[RTA_MULTIPATH]		= { .len = sizeof(struct rtnexthop) },
 	[RTA_PROTOINFO]		= { .type = NLA_U32 },
 	[RTA_FLOW]		= { .type = NLA_U32 },
 	[RTA_MP_ALGO]		= { .type = NLA_U32 },
 };
 static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,
 			     struct fib_config *cfg)
 {
 	struct nlattr *attr;
 	int err, remaining;
 	struct rtmsg *rtm;
 	err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
 	if (err < 0)
 		goto errout;
 	memset(cfg, 0, sizeof(*cfg));
 	rtm = nlmsg_data(nlh);
 	cfg->fc_dst_len = rtm->rtm_dst_len;
 	cfg->fc_tos = rtm->rtm_tos;
 	cfg->fc_table = rtm->rtm_table;
 	cfg->fc_protocol = rtm->rtm_protocol;
 	cfg->fc_scope = rtm->rtm_scope;
 	cfg->fc_type = rtm->rtm_type;
 	cfg->fc_flags = rtm->rtm_flags;
 	cfg->fc_nlflags = nlh->nlmsg_flags;
 	cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
 	cfg->fc_nlinfo.nlh = nlh;
 	nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
 		switch (attr->nla_type) {
 		case RTA_DST:
 			cfg->fc_dst = nla_get_be32(attr);
 			break;
 		case RTA_OIF:
 			cfg->fc_oif = nla_get_u32(attr);
 			break;
 		case RTA_GATEWAY:
 			cfg->fc_gw = nla_get_be32(attr);
 			break;
 		case RTA_PRIORITY:
 			cfg->fc_priority = nla_get_u32(attr);
 			break;
 		case RTA_PREFSRC:
 			cfg->fc_prefsrc = nla_get_be32(attr);
 			break;
 		case RTA_METRICS:
 			cfg->fc_mx = nla_data(attr);
 			cfg->fc_mx_len = nla_len(attr);
 			break;
 		case RTA_MULTIPATH:
 			cfg->fc_mp = nla_data(attr);
 			cfg->fc_mp_len = nla_len(attr);
 			break;
 		case RTA_FLOW:
 			cfg->fc_flow = nla_get_u32(attr);
 			break;
 		case RTA_MP_ALGO:
 			cfg->fc_mp_alg = nla_get_u32(attr);
 			break;
 		case RTA_TABLE:
 			cfg->fc_table = nla_get_u32(attr);
 			break;
 		}
 	}
 	return 0;
 errout:
 	return err;
 }
 int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 {
 	struct fib_config cfg;
 	struct fib_table *tb;
 	int err;
 	err = rtm_to_fib_config(skb, nlh, &cfg);
 	if (err < 0)
 		goto errout;
 	tb = fib_get_table(cfg.fc_table);
 	if (tb == NULL) {
 		err = -ESRCH;
 		goto errout;
 	}
 	err = tb->tb_delete(tb, &cfg);
 errout:
 	return err;
 }
 int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 {
 	struct fib_config cfg;
 	struct fib_table *tb;
 	int err;
 	err = rtm_to_fib_config(skb, nlh, &cfg);
 	if (err < 0)
 		goto errout;
 	tb = fib_new_table(cfg.fc_table);
 	if (tb == NULL) {
 		err = -ENOBUFS;
 		goto errout;
 	}
 	err = tb->tb_insert(tb, &cfg);
 errout:
 	return err;
 }
 int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
 {
 	unsigned int h, s_h;
 	unsigned int e = 0, s_e;
 	struct fib_table *tb;
 	struct hlist_node *node;
 	int dumped = 0;
 	if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
 	    ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
 		return ip_rt_dump(skb, cb);
 	s_h = cb->args[0];
 	s_e = cb->args[1];
 	for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
 		e = 0;
 		hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist) {
 			if (e < s_e)
 				goto next;
 			if (dumped)
 				memset(&cb->args[2], 0, sizeof(cb->args) -
 				                 2 * sizeof(cb->args[0]));
 			if (tb->tb_dump(tb, skb, cb) < 0)
 				goto out;
 			dumped = 1;
 next:
 			e++;
 		}
 	}
 out:
 	cb->args[1] = e;
 	cb->args[0] = h;
 	return skb->len;
 }
 /* Prepare and feed intra-kernel routing request.
    Really, it should be netlink message, but :-( netlink
    can be not configured, so that we feed it directly
    to fib engine. It is legal, because all events occur
    only when netlink is already locked.
  */
 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
 {
 	struct fib_table *tb;
 	struct fib_config cfg = {
 		.fc_protocol = RTPROT_KERNEL,
 		.fc_type = type,
 		.fc_dst = dst,
 		.fc_dst_len = dst_len,
 		.fc_prefsrc = ifa->ifa_local,
 		.fc_oif = ifa->ifa_dev->dev->ifindex,
 		.fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
 	};
 	if (type == RTN_UNICAST)
 		tb = fib_new_table(RT_TABLE_MAIN);
 	else
 		tb = fib_new_table(RT_TABLE_LOCAL);
 	if (tb == NULL)
 		return;
 	cfg.fc_table = tb->tb_id;
 	if (type != RTN_LOCAL)
 		cfg.fc_scope = RT_SCOPE_LINK;
 	else
 		cfg.fc_scope = RT_SCOPE_HOST;
 	if (cmd == RTM_NEWROUTE)
 		tb->tb_insert(tb, &cfg);
 	else
 		tb->tb_delete(tb, &cfg);
 }
 void fib_add_ifaddr(struct in_ifaddr *ifa)
 {
 	struct in_device *in_dev = ifa->ifa_dev;
 	struct net_device *dev = in_dev->dev;
 	struct in_ifaddr *prim = ifa;
 	__be32 mask = ifa->ifa_mask;
 	__be32 addr = ifa->ifa_local;
 	__be32 prefix = ifa->ifa_address&mask;
 	if (ifa->ifa_flags&IFA_F_SECONDARY) {
 		prim = inet_ifa_byprefix(in_dev, prefix, mask);
 		if (prim == NULL) {
 			printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULL\n");
 			return;
 		}
 	}
 	fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
 	if (!(dev->flags&IFF_UP))
 		return;
 	/* Add broadcast address, if it is explicitly assigned. */
 	if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
 		fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
 	if (!ZERONET(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
 	    (prefix != addr || ifa->ifa_prefixlen < 32)) {
 		fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
 			  RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
 		/* Add network specific broadcasts, when it takes a sense */
 		if (ifa->ifa_prefixlen < 31) {
 			fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
 			fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
 		}
 	}
 }
 static void fib_del_ifaddr(struct in_ifaddr *ifa)
 {
 	struct in_device *in_dev = ifa->ifa_dev;
 	struct net_device *dev = in_dev->dev;
 	struct in_ifaddr *ifa1;
 	struct in_ifaddr *prim = ifa;
 	__be32 brd = ifa->ifa_address|~ifa->ifa_mask;
 	__be32 any = ifa->ifa_address&ifa->ifa_mask;
 #define LOCAL_OK	1
 #define BRD_OK		2
 #define BRD0_OK		4
 #define BRD1_OK		8
 	unsigned ok = 0;
 	if (!(ifa->ifa_flags&IFA_F_SECONDARY))
 		fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
 			  RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
 	else {
 		prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
 		if (prim == NULL) {
 			printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULL\n");
 			return;
 		}
 	}
 	/* Deletion is more complicated than add.
 	   We should take care of not to delete too much :-)
 	   Scan address list to be sure that addresses are really gone.
 	 */
 	for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
 		if (ifa->ifa_local == ifa1->ifa_local)
 			ok |= LOCAL_OK;
 		if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
 			ok |= BRD_OK;
 		if (brd == ifa1->ifa_broadcast)
 			ok |= BRD1_OK;
 		if (any == ifa1->ifa_broadcast)
 			ok |= BRD0_OK;
 	}
 	if (!(ok&BRD_OK))
 		fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
 	if (!(ok&BRD1_OK))
 		fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
 	if (!(ok&BRD0_OK))
 		fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
 	if (!(ok&LOCAL_OK)) {
 		fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
 		/* Check, that this local address finally disappeared. */
 		if (inet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
 			/* And the last, but not the least thing.
 			   We must flush stray FIB entries.
 			   First of all, we scan fib_info list searching
 			   for stray nexthop entries, then ignite fib_flush.
 			*/
 			if (fib_sync_down(ifa->ifa_local, NULL, 0))
 				fib_flush();
 		}
 	}
 #undef LOCAL_OK
 #undef BRD_OK
 #undef BRD0_OK
 #undef BRD1_OK
 }
 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
 {
 	struct fib_result       res;
 	struct flowi            fl = { .mark = frn->fl_mark,
 				       .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
 							    .tos = frn->fl_tos,
 							    .scope = frn->fl_scope } } };
 	if (tb) {
 		local_bh_disable();
 		frn->tb_id = tb->tb_id;
 		frn->err = tb->tb_lookup(tb, &fl, &res);
 		if (!frn->err) {
 			frn->prefixlen = res.prefixlen;
 			frn->nh_sel = res.nh_sel;
 			frn->type = res.type;
 			frn->scope = res.scope;
 		}
 		local_bh_enable();
 	}
 }
 static void nl_fib_input(struct sock *sk, int len)
 {
 	struct sk_buff *skb = NULL;
         struct nlmsghdr *nlh = NULL;
 	struct fib_result_nl *frn;
 	u32 pid;
 	struct fib_table *tb;
 	skb = skb_dequeue(&sk->sk_receive_queue);
 	nlh = (struct nlmsghdr *)skb->data;
 	if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
 	    nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn))) {
 		kfree_skb(skb);
 		return;
 	}
 	frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
 	tb = fib_get_table(frn->tb_id_in);
 	nl_fib_lookup(frn, tb);
 	pid = nlh->nlmsg_pid;           /*pid of sending process */
 	NETLINK_CB(skb).pid = 0;         /* from kernel */
-	NETLINK_CB(skb).dst_pid = pid;
 	NETLINK_CB(skb).dst_group = 0;  /* unicast */
 	netlink_unicast(sk, skb, pid, MSG_DONTWAIT);
 }
 static void nl_fib_lookup_init(void)
 {
       netlink_kernel_create(NETLINK_FIB_LOOKUP, 0, nl_fib_input, THIS_MODULE);
 }
 static void fib_disable_ip(struct net_device *dev, int force)
 {
 	if (fib_sync_down(0, dev, force))
 		fib_flush();
 	rt_cache_flush(0);
 	arp_ifdown(dev);
 }
 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
 	struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
 	switch (event) {
 	case NETDEV_UP:
 		fib_add_ifaddr(ifa);
 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 		fib_sync_up(ifa->ifa_dev->dev);
 #endif
 		rt_cache_flush(-1);
 		break;
 	case NETDEV_DOWN:
 		fib_del_ifaddr(ifa);
 		if (ifa->ifa_dev->ifa_list == NULL) {
 			/* Last address was deleted from this interface.
 			   Disable IP.
 			 */
 			fib_disable_ip(ifa->ifa_dev->dev, 1);
 		} else {
 			rt_cache_flush(-1);
 		}
 		break;
 	}
 	return NOTIFY_DONE;
 }
 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
 	struct net_device *dev = ptr;
 	struct in_device *in_dev = __in_dev_get_rtnl(dev);
 	if (event == NETDEV_UNREGISTER) {
 		fib_disable_ip(dev, 2);
 		return NOTIFY_DONE;
 	}
 	if (!in_dev)
 		return NOTIFY_DONE;
 	switch (event) {
 	case NETDEV_UP:
 		for_ifa(in_dev) {
 			fib_add_ifaddr(ifa);
 		} endfor_ifa(in_dev);
 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 		fib_sync_up(dev);
 #endif
 		rt_cache_flush(-1);
 		break;
 	case NETDEV_DOWN:
 		fib_disable_ip(dev, 0);
 		break;
 	case NETDEV_CHANGEMTU:
 	case NETDEV_CHANGE:
 		rt_cache_flush(0);
 		break;
 	}
 	return NOTIFY_DONE;
 }
 static struct notifier_block fib_inetaddr_notifier = {
 	.notifier_call =fib_inetaddr_event,
 };
 static struct notifier_block fib_netdev_notifier = {
 	.notifier_call =fib_netdev_event,
 };
 void __init ip_fib_init(void)
 {
 	unsigned int i;
 	for (i = 0; i < FIB_TABLE_HASHSZ; i++)
 		INIT_HLIST_HEAD(&fib_table_hash[i]);
 #ifndef CONFIG_IP_MULTIPLE_TABLES
 	ip_fib_local_table = fib_hash_init(RT_TABLE_LOCAL);
 	hlist_add_head_rcu(&ip_fib_local_table->tb_hlist, &fib_table_hash[0]);
 	ip_fib_main_table  = fib_hash_init(RT_TABLE_MAIN);
 	hlist_add_head_rcu(&ip_fib_main_table->tb_hlist, &fib_table_hash[0]);
 #else
 	fib4_rules_init();
 #endif
 	register_netdevice_notifier(&fib_netdev_notifier);
 	register_inetaddr_notifier(&fib_inetaddr_notifier);
 	nl_fib_lookup_init();
 }
 EXPORT_SYMBOL(inet_addr_type);
 EXPORT_SYMBOL(ip_dev_find);

net/ipv4/netfilter/ip_conntrack_netlink.c

Diff comments View file @ 4e9b826

1	/* Connection tracking via netlink socket. Allows for user space	1	/* Connection tracking via netlink socket. Allows for user space
2	* protocol helpers and general trouble making from userspace.	2	* protocol helpers and general trouble making from userspace.
3	*	3	*
4	* (C) 2001 by Jay Schulist <jschlst@samba.org>	4	* (C) 2001 by Jay Schulist <jschlst@samba.org>
5	* (C) 2002-2005 by Harald Welte <laforge@gnumonks.org>	5	* (C) 2002-2005 by Harald Welte <laforge@gnumonks.org>
6	* (C) 2003 by Patrick Mchardy <kaber@trash.net>	6	* (C) 2003 by Patrick Mchardy <kaber@trash.net>
7	* (C) 2005-2006 by Pablo Neira Ayuso <pablo@eurodev.net>	7	* (C) 2005-2006 by Pablo Neira Ayuso <pablo@eurodev.net>
8	*	8	*
9	* I've reworked this stuff to use attributes instead of conntrack	9	* I've reworked this stuff to use attributes instead of conntrack
10	* structures. 5.44 am. I need more tea. --pablo 05/07/11.	10	* structures. 5.44 am. I need more tea. --pablo 05/07/11.
11	*	11	*
12	* Initial connection tracking via netlink development funded and	12	* Initial connection tracking via netlink development funded and
13	* generally made possible by Network Robots, Inc. (www.networkrobots.com)	13	* generally made possible by Network Robots, Inc. (www.networkrobots.com)
14	*	14	*
15	* Further development of this code funded by Astaro AG (http://www.astaro.com)	15	* Further development of this code funded by Astaro AG (http://www.astaro.com)
16	*	16	*
17	* This software may be used and distributed according to the terms	17	* This software may be used and distributed according to the terms
18	* of the GNU General Public License, incorporated herein by reference.	18	* of the GNU General Public License, incorporated herein by reference.
19	*/	19	*/
20		20
21	#include <linux/init.h>	21	#include <linux/init.h>
22	#include <linux/module.h>	22	#include <linux/module.h>
23	#include <linux/kernel.h>	23	#include <linux/kernel.h>
24	#include <linux/types.h>	24	#include <linux/types.h>
25	#include <linux/timer.h>	25	#include <linux/timer.h>
26	#include <linux/skbuff.h>	26	#include <linux/skbuff.h>
27	#include <linux/errno.h>	27	#include <linux/errno.h>
28	#include <linux/netlink.h>	28	#include <linux/netlink.h>
29	#include <linux/spinlock.h>	29	#include <linux/spinlock.h>
30	#include <linux/interrupt.h>	30	#include <linux/interrupt.h>
31	#include <linux/notifier.h>	31	#include <linux/notifier.h>
32		32
33	#include <linux/netfilter.h>	33	#include <linux/netfilter.h>
34	#include <linux/netfilter_ipv4/ip_conntrack.h>	34	#include <linux/netfilter_ipv4/ip_conntrack.h>
35	#include <linux/netfilter_ipv4/ip_conntrack_core.h>	35	#include <linux/netfilter_ipv4/ip_conntrack_core.h>
36	#include <linux/netfilter_ipv4/ip_conntrack_helper.h>	36	#include <linux/netfilter_ipv4/ip_conntrack_helper.h>
37	#include <linux/netfilter_ipv4/ip_conntrack_protocol.h>	37	#include <linux/netfilter_ipv4/ip_conntrack_protocol.h>
38	#include <linux/netfilter_ipv4/ip_nat_protocol.h>	38	#include <linux/netfilter_ipv4/ip_nat_protocol.h>
39		39
40	#include <linux/netfilter/nfnetlink.h>	40	#include <linux/netfilter/nfnetlink.h>
41	#include <linux/netfilter/nfnetlink_conntrack.h>	41	#include <linux/netfilter/nfnetlink_conntrack.h>
42		42
43	MODULE_LICENSE("GPL");	43	MODULE_LICENSE("GPL");
44		44
45	static char __initdata version[] = "0.90";	45	static char __initdata version[] = "0.90";
46		46
47	static inline int	47	static inline int
48	ctnetlink_dump_tuples_proto(struct sk_buff *skb,	48	ctnetlink_dump_tuples_proto(struct sk_buff *skb,
49	const struct ip_conntrack_tuple *tuple,	49	const struct ip_conntrack_tuple *tuple,
50	struct ip_conntrack_protocol *proto)	50	struct ip_conntrack_protocol *proto)
51	{	51	{
52	int ret = 0;	52	int ret = 0;
53	struct nfattr *nest_parms = NFA_NEST(skb, CTA_TUPLE_PROTO);	53	struct nfattr *nest_parms = NFA_NEST(skb, CTA_TUPLE_PROTO);
54		54
55	NFA_PUT(skb, CTA_PROTO_NUM, sizeof(u_int8_t), &tuple->dst.protonum);	55	NFA_PUT(skb, CTA_PROTO_NUM, sizeof(u_int8_t), &tuple->dst.protonum);
56		56
57	if (likely(proto->tuple_to_nfattr))	57	if (likely(proto->tuple_to_nfattr))
58	ret = proto->tuple_to_nfattr(skb, tuple);	58	ret = proto->tuple_to_nfattr(skb, tuple);
59		59
60	NFA_NEST_END(skb, nest_parms);	60	NFA_NEST_END(skb, nest_parms);
61		61
62	return ret;	62	return ret;
63		63
64	nfattr_failure:	64	nfattr_failure:
65	return -1;	65	return -1;
66	}	66	}
67		67
68	static inline int	68	static inline int
69	ctnetlink_dump_tuples_ip(struct sk_buff *skb,	69	ctnetlink_dump_tuples_ip(struct sk_buff *skb,
70	const struct ip_conntrack_tuple *tuple)	70	const struct ip_conntrack_tuple *tuple)
71	{	71	{
72	struct nfattr *nest_parms = NFA_NEST(skb, CTA_TUPLE_IP);	72	struct nfattr *nest_parms = NFA_NEST(skb, CTA_TUPLE_IP);
73		73
74	NFA_PUT(skb, CTA_IP_V4_SRC, sizeof(__be32), &tuple->src.ip);	74	NFA_PUT(skb, CTA_IP_V4_SRC, sizeof(__be32), &tuple->src.ip);
75	NFA_PUT(skb, CTA_IP_V4_DST, sizeof(__be32), &tuple->dst.ip);	75	NFA_PUT(skb, CTA_IP_V4_DST, sizeof(__be32), &tuple->dst.ip);
76		76
77	NFA_NEST_END(skb, nest_parms);	77	NFA_NEST_END(skb, nest_parms);
78		78
79	return 0;	79	return 0;
80		80
81	nfattr_failure:	81	nfattr_failure:
82	return -1;	82	return -1;
83	}	83	}
84		84
85	static inline int	85	static inline int
86	ctnetlink_dump_tuples(struct sk_buff *skb,	86	ctnetlink_dump_tuples(struct sk_buff *skb,
87	const struct ip_conntrack_tuple *tuple)	87	const struct ip_conntrack_tuple *tuple)
88	{	88	{
89	int ret;	89	int ret;
90	struct ip_conntrack_protocol *proto;	90	struct ip_conntrack_protocol *proto;
91		91
92	ret = ctnetlink_dump_tuples_ip(skb, tuple);	92	ret = ctnetlink_dump_tuples_ip(skb, tuple);
93	if (unlikely(ret < 0))	93	if (unlikely(ret < 0))
94	return ret;	94	return ret;
95		95
96	proto = ip_conntrack_proto_find_get(tuple->dst.protonum);	96	proto = ip_conntrack_proto_find_get(tuple->dst.protonum);
97	ret = ctnetlink_dump_tuples_proto(skb, tuple, proto);	97	ret = ctnetlink_dump_tuples_proto(skb, tuple, proto);
98	ip_conntrack_proto_put(proto);	98	ip_conntrack_proto_put(proto);
99		99
100	return ret;	100	return ret;
101	}	101	}
102		102
103	static inline int	103	static inline int
104	ctnetlink_dump_status(struct sk_buff skb, const struct ip_conntrack ct)	104	ctnetlink_dump_status(struct sk_buff skb, const struct ip_conntrack ct)
105	{	105	{
106	__be32 status = htonl((u_int32_t) ct->status);	106	__be32 status = htonl((u_int32_t) ct->status);
107	NFA_PUT(skb, CTA_STATUS, sizeof(status), &status);	107	NFA_PUT(skb, CTA_STATUS, sizeof(status), &status);
108	return 0;	108	return 0;
109		109
110	nfattr_failure:	110	nfattr_failure:
111	return -1;	111	return -1;
112	}	112	}
113		113
114	static inline int	114	static inline int
115	ctnetlink_dump_timeout(struct sk_buff skb, const struct ip_conntrack ct)	115	ctnetlink_dump_timeout(struct sk_buff skb, const struct ip_conntrack ct)
116	{	116	{
117	long timeout_l = ct->timeout.expires - jiffies;	117	long timeout_l = ct->timeout.expires - jiffies;
118	__be32 timeout;	118	__be32 timeout;
119		119
120	if (timeout_l < 0)	120	if (timeout_l < 0)
121	timeout = 0;	121	timeout = 0;
122	else	122	else
123	timeout = htonl(timeout_l / HZ);	123	timeout = htonl(timeout_l / HZ);
124		124
125	NFA_PUT(skb, CTA_TIMEOUT, sizeof(timeout), &timeout);	125	NFA_PUT(skb, CTA_TIMEOUT, sizeof(timeout), &timeout);
126	return 0;	126	return 0;
127		127
128	nfattr_failure:	128	nfattr_failure:
129	return -1;	129	return -1;
130	}	130	}
131		131
132	static inline int	132	static inline int
133	ctnetlink_dump_protoinfo(struct sk_buff skb, const struct ip_conntrack ct)	133	ctnetlink_dump_protoinfo(struct sk_buff skb, const struct ip_conntrack ct)
134	{	134	{
135	struct ip_conntrack_protocol *proto = ip_conntrack_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum);	135	struct ip_conntrack_protocol *proto = ip_conntrack_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum);
136		136
137	struct nfattr *nest_proto;	137	struct nfattr *nest_proto;
138	int ret;	138	int ret;
139		139
140	if (!proto->to_nfattr) {	140	if (!proto->to_nfattr) {
141	ip_conntrack_proto_put(proto);	141	ip_conntrack_proto_put(proto);
142	return 0;	142	return 0;
143	}	143	}
144		144
145	nest_proto = NFA_NEST(skb, CTA_PROTOINFO);	145	nest_proto = NFA_NEST(skb, CTA_PROTOINFO);
146		146
147	ret = proto->to_nfattr(skb, nest_proto, ct);	147	ret = proto->to_nfattr(skb, nest_proto, ct);
148		148
149	ip_conntrack_proto_put(proto);	149	ip_conntrack_proto_put(proto);
150		150
151	NFA_NEST_END(skb, nest_proto);	151	NFA_NEST_END(skb, nest_proto);
152		152
153	return ret;	153	return ret;
154		154
155	nfattr_failure:	155	nfattr_failure:
156	ip_conntrack_proto_put(proto);	156	ip_conntrack_proto_put(proto);
157	return -1;	157	return -1;
158	}	158	}
159		159
160	static inline int	160	static inline int
161	ctnetlink_dump_helpinfo(struct sk_buff skb, const struct ip_conntrack ct)	161	ctnetlink_dump_helpinfo(struct sk_buff skb, const struct ip_conntrack ct)
162	{	162	{
163	struct nfattr *nest_helper;	163	struct nfattr *nest_helper;
164		164
165	if (!ct->helper)	165	if (!ct->helper)
166	return 0;	166	return 0;
167		167
168	nest_helper = NFA_NEST(skb, CTA_HELP);	168	nest_helper = NFA_NEST(skb, CTA_HELP);
169	NFA_PUT(skb, CTA_HELP_NAME, strlen(ct->helper->name), ct->helper->name);	169	NFA_PUT(skb, CTA_HELP_NAME, strlen(ct->helper->name), ct->helper->name);
170		170
171	if (ct->helper->to_nfattr)	171	if (ct->helper->to_nfattr)
172	ct->helper->to_nfattr(skb, ct);	172	ct->helper->to_nfattr(skb, ct);
173		173
174	NFA_NEST_END(skb, nest_helper);	174	NFA_NEST_END(skb, nest_helper);
175		175
176	return 0;	176	return 0;
177		177
178	nfattr_failure:	178	nfattr_failure:
179	return -1;	179	return -1;
180	}	180	}
181		181
182	#ifdef CONFIG_IP_NF_CT_ACCT	182	#ifdef CONFIG_IP_NF_CT_ACCT
183	static inline int	183	static inline int
184	ctnetlink_dump_counters(struct sk_buff skb, const struct ip_conntrack ct,	184	ctnetlink_dump_counters(struct sk_buff skb, const struct ip_conntrack ct,
185	enum ip_conntrack_dir dir)	185	enum ip_conntrack_dir dir)
186	{	186	{
187	enum ctattr_type type = dir ? CTA_COUNTERS_REPLY: CTA_COUNTERS_ORIG;	187	enum ctattr_type type = dir ? CTA_COUNTERS_REPLY: CTA_COUNTERS_ORIG;
188	struct nfattr *nest_count = NFA_NEST(skb, type);	188	struct nfattr *nest_count = NFA_NEST(skb, type);
189	__be32 tmp;	189	__be32 tmp;
190		190
191	tmp = htonl(ct->counters[dir].packets);	191	tmp = htonl(ct->counters[dir].packets);
192	NFA_PUT(skb, CTA_COUNTERS32_PACKETS, sizeof(__be32), &tmp);	192	NFA_PUT(skb, CTA_COUNTERS32_PACKETS, sizeof(__be32), &tmp);
193		193
194	tmp = htonl(ct->counters[dir].bytes);	194	tmp = htonl(ct->counters[dir].bytes);
195	NFA_PUT(skb, CTA_COUNTERS32_BYTES, sizeof(__be32), &tmp);	195	NFA_PUT(skb, CTA_COUNTERS32_BYTES, sizeof(__be32), &tmp);
196		196
197	NFA_NEST_END(skb, nest_count);	197	NFA_NEST_END(skb, nest_count);
198		198
199	return 0;	199	return 0;
200		200
201	nfattr_failure:	201	nfattr_failure:
202	return -1;	202	return -1;
203	}	203	}
204	#else	204	#else
205	#define ctnetlink_dump_counters(a, b, c) (0)	205	#define ctnetlink_dump_counters(a, b, c) (0)
206	#endif	206	#endif
207		207
208	#ifdef CONFIG_IP_NF_CONNTRACK_MARK	208	#ifdef CONFIG_IP_NF_CONNTRACK_MARK
209	static inline int	209	static inline int
210	ctnetlink_dump_mark(struct sk_buff skb, const struct ip_conntrack ct)	210	ctnetlink_dump_mark(struct sk_buff skb, const struct ip_conntrack ct)
211	{	211	{
212	__be32 mark = htonl(ct->mark);	212	__be32 mark = htonl(ct->mark);
213		213
214	NFA_PUT(skb, CTA_MARK, sizeof(__be32), &mark);	214	NFA_PUT(skb, CTA_MARK, sizeof(__be32), &mark);
215	return 0;	215	return 0;
216		216
217	nfattr_failure:	217	nfattr_failure:
218	return -1;	218	return -1;
219	}	219	}
220	#else	220	#else
221	#define ctnetlink_dump_mark(a, b) (0)	221	#define ctnetlink_dump_mark(a, b) (0)
222	#endif	222	#endif
223		223
224	static inline int	224	static inline int
225	ctnetlink_dump_id(struct sk_buff skb, const struct ip_conntrack ct)	225	ctnetlink_dump_id(struct sk_buff skb, const struct ip_conntrack ct)
226	{	226	{
227	__be32 id = htonl(ct->id);	227	__be32 id = htonl(ct->id);
228	NFA_PUT(skb, CTA_ID, sizeof(__be32), &id);	228	NFA_PUT(skb, CTA_ID, sizeof(__be32), &id);
229	return 0;	229	return 0;
230		230
231	nfattr_failure:	231	nfattr_failure:
232	return -1;	232	return -1;
233	}	233	}
234		234
235	static inline int	235	static inline int
236	ctnetlink_dump_use(struct sk_buff skb, const struct ip_conntrack ct)	236	ctnetlink_dump_use(struct sk_buff skb, const struct ip_conntrack ct)
237	{	237	{
238	__be32 use = htonl(atomic_read(&ct->ct_general.use));	238	__be32 use = htonl(atomic_read(&ct->ct_general.use));
239		239
240	NFA_PUT(skb, CTA_USE, sizeof(__be32), &use);	240	NFA_PUT(skb, CTA_USE, sizeof(__be32), &use);
241	return 0;	241	return 0;
242		242
243	nfattr_failure:	243	nfattr_failure:
244	return -1;	244	return -1;
245	}	245	}
246		246
247	#define tuple(ct, dir) (&(ct)->tuplehash[dir].tuple)	247	#define tuple(ct, dir) (&(ct)->tuplehash[dir].tuple)
248		248
249	static int	249	static int
250	ctnetlink_fill_info(struct sk_buff *skb, u32 pid, u32 seq,	250	ctnetlink_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
251	int event, int nowait,	251	int event, int nowait,
252	const struct ip_conntrack *ct)	252	const struct ip_conntrack *ct)
253	{	253	{
254	struct nlmsghdr *nlh;	254	struct nlmsghdr *nlh;
255	struct nfgenmsg *nfmsg;	255	struct nfgenmsg *nfmsg;
256	struct nfattr *nest_parms;	256	struct nfattr *nest_parms;
257	unsigned char *b;	257	unsigned char *b;
258		258
259	b = skb->tail;	259	b = skb->tail;
260		260
261	event \|= NFNL_SUBSYS_CTNETLINK << 8;	261	event \|= NFNL_SUBSYS_CTNETLINK << 8;
262	nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));	262	nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));
263	nfmsg = NLMSG_DATA(nlh);	263	nfmsg = NLMSG_DATA(nlh);
264		264
265	nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0;	265	nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0;
266	nfmsg->nfgen_family = AF_INET;	266	nfmsg->nfgen_family = AF_INET;
267	nfmsg->version = NFNETLINK_V0;	267	nfmsg->version = NFNETLINK_V0;
268	nfmsg->res_id = 0;	268	nfmsg->res_id = 0;
269		269
270	nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG);	270	nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG);
271	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)	271	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)
272	goto nfattr_failure;	272	goto nfattr_failure;
273	NFA_NEST_END(skb, nest_parms);	273	NFA_NEST_END(skb, nest_parms);
274		274
275	nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY);	275	nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY);
276	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)	276	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)
277	goto nfattr_failure;	277	goto nfattr_failure;
278	NFA_NEST_END(skb, nest_parms);	278	NFA_NEST_END(skb, nest_parms);
279		279
280	if (ctnetlink_dump_status(skb, ct) < 0 \|\|	280	if (ctnetlink_dump_status(skb, ct) < 0 \|\|
281	ctnetlink_dump_timeout(skb, ct) < 0 \|\|	281	ctnetlink_dump_timeout(skb, ct) < 0 \|\|
282	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 \|\|	282	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 \|\|
283	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0 \|\|	283	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0 \|\|
284	ctnetlink_dump_protoinfo(skb, ct) < 0 \|\|	284	ctnetlink_dump_protoinfo(skb, ct) < 0 \|\|
285	ctnetlink_dump_helpinfo(skb, ct) < 0 \|\|	285	ctnetlink_dump_helpinfo(skb, ct) < 0 \|\|
286	ctnetlink_dump_mark(skb, ct) < 0 \|\|	286	ctnetlink_dump_mark(skb, ct) < 0 \|\|
287	ctnetlink_dump_id(skb, ct) < 0 \|\|	287	ctnetlink_dump_id(skb, ct) < 0 \|\|
288	ctnetlink_dump_use(skb, ct) < 0)	288	ctnetlink_dump_use(skb, ct) < 0)
289	goto nfattr_failure;	289	goto nfattr_failure;
290		290
291	nlh->nlmsg_len = skb->tail - b;	291	nlh->nlmsg_len = skb->tail - b;
292	return skb->len;	292	return skb->len;
293		293
294	nlmsg_failure:	294	nlmsg_failure:
295	nfattr_failure:	295	nfattr_failure:
296	skb_trim(skb, b - skb->data);	296	skb_trim(skb, b - skb->data);
297	return -1;	297	return -1;
298	}	298	}
299		299
300	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS	300	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS
301	static int ctnetlink_conntrack_event(struct notifier_block *this,	301	static int ctnetlink_conntrack_event(struct notifier_block *this,
302	unsigned long events, void *ptr)	302	unsigned long events, void *ptr)
303	{	303	{
304	struct nlmsghdr *nlh;	304	struct nlmsghdr *nlh;
305	struct nfgenmsg *nfmsg;	305	struct nfgenmsg *nfmsg;
306	struct nfattr *nest_parms;	306	struct nfattr *nest_parms;
307	struct ip_conntrack ct = (struct ip_conntrack )ptr;	307	struct ip_conntrack ct = (struct ip_conntrack )ptr;
308	struct sk_buff *skb;	308	struct sk_buff *skb;
309	unsigned int type;	309	unsigned int type;
310	unsigned char *b;	310	unsigned char *b;
311	unsigned int flags = 0, group;	311	unsigned int flags = 0, group;
312		312
313	/* ignore our fake conntrack entry */	313	/* ignore our fake conntrack entry */
314	if (ct == &ip_conntrack_untracked)	314	if (ct == &ip_conntrack_untracked)
315	return NOTIFY_DONE;	315	return NOTIFY_DONE;
316		316
317	if (events & IPCT_DESTROY) {	317	if (events & IPCT_DESTROY) {
318	type = IPCTNL_MSG_CT_DELETE;	318	type = IPCTNL_MSG_CT_DELETE;
319	group = NFNLGRP_CONNTRACK_DESTROY;	319	group = NFNLGRP_CONNTRACK_DESTROY;
320	} else if (events & (IPCT_NEW \| IPCT_RELATED)) {	320	} else if (events & (IPCT_NEW \| IPCT_RELATED)) {
321	type = IPCTNL_MSG_CT_NEW;	321	type = IPCTNL_MSG_CT_NEW;
322	flags = NLM_F_CREATE\|NLM_F_EXCL;	322	flags = NLM_F_CREATE\|NLM_F_EXCL;
323	/* dump everything */	323	/* dump everything */
324	events = ~0UL;	324	events = ~0UL;
325	group = NFNLGRP_CONNTRACK_NEW;	325	group = NFNLGRP_CONNTRACK_NEW;
326	} else if (events & (IPCT_STATUS \| IPCT_PROTOINFO)) {	326	} else if (events & (IPCT_STATUS \| IPCT_PROTOINFO)) {
327	type = IPCTNL_MSG_CT_NEW;	327	type = IPCTNL_MSG_CT_NEW;
328	group = NFNLGRP_CONNTRACK_UPDATE;	328	group = NFNLGRP_CONNTRACK_UPDATE;
329	} else	329	} else
330	return NOTIFY_DONE;	330	return NOTIFY_DONE;
331		331
332	if (!nfnetlink_has_listeners(group))	332	if (!nfnetlink_has_listeners(group))
333	return NOTIFY_DONE;	333	return NOTIFY_DONE;
334		334
335	skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);	335	skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
336	if (!skb)	336	if (!skb)
337	return NOTIFY_DONE;	337	return NOTIFY_DONE;
338		338
339	b = skb->tail;	339	b = skb->tail;
340		340
341	type \|= NFNL_SUBSYS_CTNETLINK << 8;	341	type \|= NFNL_SUBSYS_CTNETLINK << 8;
342	nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg));	342	nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg));
343	nfmsg = NLMSG_DATA(nlh);	343	nfmsg = NLMSG_DATA(nlh);
344		344
345	nlh->nlmsg_flags = flags;	345	nlh->nlmsg_flags = flags;
346	nfmsg->nfgen_family = AF_INET;	346	nfmsg->nfgen_family = AF_INET;
347	nfmsg->version = NFNETLINK_V0;	347	nfmsg->version = NFNETLINK_V0;
348	nfmsg->res_id = 0;	348	nfmsg->res_id = 0;
349		349
350	nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG);	350	nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG);
351	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)	351	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)
352	goto nfattr_failure;	352	goto nfattr_failure;
353	NFA_NEST_END(skb, nest_parms);	353	NFA_NEST_END(skb, nest_parms);
354		354
355	nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY);	355	nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY);
356	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)	356	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)
357	goto nfattr_failure;	357	goto nfattr_failure;
358	NFA_NEST_END(skb, nest_parms);	358	NFA_NEST_END(skb, nest_parms);
359		359
360	/* NAT stuff is now a status flag */	360	/* NAT stuff is now a status flag */
361	if ((events & IPCT_STATUS \|\| events & IPCT_NATINFO)	361	if ((events & IPCT_STATUS \|\| events & IPCT_NATINFO)
362	&& ctnetlink_dump_status(skb, ct) < 0)	362	&& ctnetlink_dump_status(skb, ct) < 0)
363	goto nfattr_failure;	363	goto nfattr_failure;
364	if (events & IPCT_REFRESH	364	if (events & IPCT_REFRESH
365	&& ctnetlink_dump_timeout(skb, ct) < 0)	365	&& ctnetlink_dump_timeout(skb, ct) < 0)
366	goto nfattr_failure;	366	goto nfattr_failure;
367	if (events & IPCT_PROTOINFO	367	if (events & IPCT_PROTOINFO
368	&& ctnetlink_dump_protoinfo(skb, ct) < 0)	368	&& ctnetlink_dump_protoinfo(skb, ct) < 0)
369	goto nfattr_failure;	369	goto nfattr_failure;
370	if (events & IPCT_HELPINFO	370	if (events & IPCT_HELPINFO
371	&& ctnetlink_dump_helpinfo(skb, ct) < 0)	371	&& ctnetlink_dump_helpinfo(skb, ct) < 0)
372	goto nfattr_failure;	372	goto nfattr_failure;
373		373
374	if (ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 \|\|	374	if (ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 \|\|
375	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0)	375	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0)
376	goto nfattr_failure;	376	goto nfattr_failure;
377		377
378	if (events & IPCT_MARK	378	if (events & IPCT_MARK
379	&& ctnetlink_dump_mark(skb, ct) < 0)	379	&& ctnetlink_dump_mark(skb, ct) < 0)
380	goto nfattr_failure;	380	goto nfattr_failure;
381		381
382	nlh->nlmsg_len = skb->tail - b;	382	nlh->nlmsg_len = skb->tail - b;
383	nfnetlink_send(skb, 0, group, 0);	383	nfnetlink_send(skb, 0, group, 0);
384	return NOTIFY_DONE;	384	return NOTIFY_DONE;
385		385
386	nlmsg_failure:	386	nlmsg_failure:
387	nfattr_failure:	387	nfattr_failure:
388	kfree_skb(skb);	388	kfree_skb(skb);
389	return NOTIFY_DONE;	389	return NOTIFY_DONE;
390	}	390	}
391	#endif /* CONFIG_IP_NF_CONNTRACK_EVENTS */	391	#endif /* CONFIG_IP_NF_CONNTRACK_EVENTS */
392		392
393	static int ctnetlink_done(struct netlink_callback *cb)	393	static int ctnetlink_done(struct netlink_callback *cb)
394	{	394	{
395	if (cb->args[1])	395	if (cb->args[1])
396	ip_conntrack_put((struct ip_conntrack *)cb->args[1]);	396	ip_conntrack_put((struct ip_conntrack *)cb->args[1]);
397	return 0;	397	return 0;
398	}	398	}
399		399
400	static int	400	static int
401	ctnetlink_dump_table(struct sk_buff skb, struct netlink_callback cb)	401	ctnetlink_dump_table(struct sk_buff skb, struct netlink_callback cb)
402	{	402	{
403	struct ip_conntrack ct, last;	403	struct ip_conntrack ct, last;
404	struct ip_conntrack_tuple_hash *h;	404	struct ip_conntrack_tuple_hash *h;
405	struct list_head *i;	405	struct list_head *i;
406		406
407	read_lock_bh(&ip_conntrack_lock);	407	read_lock_bh(&ip_conntrack_lock);
408	last = (struct ip_conntrack *)cb->args[1];	408	last = (struct ip_conntrack *)cb->args[1];
409	for (; cb->args[0] < ip_conntrack_htable_size; cb->args[0]++) {	409	for (; cb->args[0] < ip_conntrack_htable_size; cb->args[0]++) {
410	restart:	410	restart:
411	list_for_each_prev(i, &ip_conntrack_hash[cb->args[0]]) {	411	list_for_each_prev(i, &ip_conntrack_hash[cb->args[0]]) {
412	h = (struct ip_conntrack_tuple_hash *) i;	412	h = (struct ip_conntrack_tuple_hash *) i;
413	if (DIRECTION(h) != IP_CT_DIR_ORIGINAL)	413	if (DIRECTION(h) != IP_CT_DIR_ORIGINAL)
414	continue;	414	continue;
415	ct = tuplehash_to_ctrack(h);	415	ct = tuplehash_to_ctrack(h);
416	if (cb->args[1]) {	416	if (cb->args[1]) {
417	if (ct != last)	417	if (ct != last)
418	continue;	418	continue;
419	cb->args[1] = 0;	419	cb->args[1] = 0;
420	}	420	}
421	if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid,	421	if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid,
422	cb->nlh->nlmsg_seq,	422	cb->nlh->nlmsg_seq,
423	IPCTNL_MSG_CT_NEW,	423	IPCTNL_MSG_CT_NEW,
424	1, ct) < 0) {	424	1, ct) < 0) {
425	nf_conntrack_get(&ct->ct_general);	425	nf_conntrack_get(&ct->ct_general);
426	cb->args[1] = (unsigned long)ct;	426	cb->args[1] = (unsigned long)ct;
427	goto out;	427	goto out;
428	}	428	}
429	#ifdef CONFIG_NF_CT_ACCT	429	#ifdef CONFIG_NF_CT_ACCT
430	if (NFNL_MSG_TYPE(cb->nlh->nlmsg_type) ==	430	if (NFNL_MSG_TYPE(cb->nlh->nlmsg_type) ==
431	IPCTNL_MSG_CT_GET_CTRZERO)	431	IPCTNL_MSG_CT_GET_CTRZERO)
432	memset(&ct->counters, 0, sizeof(ct->counters));	432	memset(&ct->counters, 0, sizeof(ct->counters));
433	#endif	433	#endif
434	}	434	}
435	if (cb->args[1]) {	435	if (cb->args[1]) {
436	cb->args[1] = 0;	436	cb->args[1] = 0;
437	goto restart;	437	goto restart;
438	}	438	}
439	}	439	}
440	out:	440	out:
441	read_unlock_bh(&ip_conntrack_lock);	441	read_unlock_bh(&ip_conntrack_lock);
442	if (last)	442	if (last)
443	ip_conntrack_put(last);	443	ip_conntrack_put(last);
444		444
445	return skb->len;	445	return skb->len;
446	}	446	}
447		447
448	static const size_t cta_min_ip[CTA_IP_MAX] = {	448	static const size_t cta_min_ip[CTA_IP_MAX] = {
449	[CTA_IP_V4_SRC-1] = sizeof(__be32),	449	[CTA_IP_V4_SRC-1] = sizeof(__be32),
450	[CTA_IP_V4_DST-1] = sizeof(__be32),	450	[CTA_IP_V4_DST-1] = sizeof(__be32),
451	};	451	};
452		452
453	static inline int	453	static inline int
454	ctnetlink_parse_tuple_ip(struct nfattr attr, struct ip_conntrack_tuple tuple)	454	ctnetlink_parse_tuple_ip(struct nfattr attr, struct ip_conntrack_tuple tuple)
455	{	455	{
456	struct nfattr *tb[CTA_IP_MAX];	456	struct nfattr *tb[CTA_IP_MAX];
457		457
458	nfattr_parse_nested(tb, CTA_IP_MAX, attr);	458	nfattr_parse_nested(tb, CTA_IP_MAX, attr);
459		459
460	if (nfattr_bad_size(tb, CTA_IP_MAX, cta_min_ip))	460	if (nfattr_bad_size(tb, CTA_IP_MAX, cta_min_ip))
461	return -EINVAL;	461	return -EINVAL;
462		462
463	if (!tb[CTA_IP_V4_SRC-1])	463	if (!tb[CTA_IP_V4_SRC-1])
464	return -EINVAL;	464	return -EINVAL;
465	tuple->src.ip = (__be32 )NFA_DATA(tb[CTA_IP_V4_SRC-1]);	465	tuple->src.ip = (__be32 )NFA_DATA(tb[CTA_IP_V4_SRC-1]);
466		466
467	if (!tb[CTA_IP_V4_DST-1])	467	if (!tb[CTA_IP_V4_DST-1])
468	return -EINVAL;	468	return -EINVAL;
469	tuple->dst.ip = (__be32 )NFA_DATA(tb[CTA_IP_V4_DST-1]);	469	tuple->dst.ip = (__be32 )NFA_DATA(tb[CTA_IP_V4_DST-1]);
470		470
471	return 0;	471	return 0;
472	}	472	}
473		473
474	static const size_t cta_min_proto[CTA_PROTO_MAX] = {	474	static const size_t cta_min_proto[CTA_PROTO_MAX] = {
475	[CTA_PROTO_NUM-1] = sizeof(u_int8_t),	475	[CTA_PROTO_NUM-1] = sizeof(u_int8_t),
476	[CTA_PROTO_SRC_PORT-1] = sizeof(u_int16_t),	476	[CTA_PROTO_SRC_PORT-1] = sizeof(u_int16_t),
477	[CTA_PROTO_DST_PORT-1] = sizeof(u_int16_t),	477	[CTA_PROTO_DST_PORT-1] = sizeof(u_int16_t),
478	[CTA_PROTO_ICMP_TYPE-1] = sizeof(u_int8_t),	478	[CTA_PROTO_ICMP_TYPE-1] = sizeof(u_int8_t),
479	[CTA_PROTO_ICMP_CODE-1] = sizeof(u_int8_t),	479	[CTA_PROTO_ICMP_CODE-1] = sizeof(u_int8_t),
480	[CTA_PROTO_ICMP_ID-1] = sizeof(u_int16_t),	480	[CTA_PROTO_ICMP_ID-1] = sizeof(u_int16_t),
481	};	481	};
482		482
483	static inline int	483	static inline int
484	ctnetlink_parse_tuple_proto(struct nfattr *attr,	484	ctnetlink_parse_tuple_proto(struct nfattr *attr,
485	struct ip_conntrack_tuple *tuple)	485	struct ip_conntrack_tuple *tuple)
486	{	486	{
487	struct nfattr *tb[CTA_PROTO_MAX];	487	struct nfattr *tb[CTA_PROTO_MAX];
488	struct ip_conntrack_protocol *proto;	488	struct ip_conntrack_protocol *proto;
489	int ret = 0;	489	int ret = 0;
490		490
491	nfattr_parse_nested(tb, CTA_PROTO_MAX, attr);	491	nfattr_parse_nested(tb, CTA_PROTO_MAX, attr);
492		492
493	if (nfattr_bad_size(tb, CTA_PROTO_MAX, cta_min_proto))	493	if (nfattr_bad_size(tb, CTA_PROTO_MAX, cta_min_proto))
494	return -EINVAL;	494	return -EINVAL;
495		495
496	if (!tb[CTA_PROTO_NUM-1])	496	if (!tb[CTA_PROTO_NUM-1])
497	return -EINVAL;	497	return -EINVAL;
498	tuple->dst.protonum = (u_int8_t )NFA_DATA(tb[CTA_PROTO_NUM-1]);	498	tuple->dst.protonum = (u_int8_t )NFA_DATA(tb[CTA_PROTO_NUM-1]);
499		499
500	proto = ip_conntrack_proto_find_get(tuple->dst.protonum);	500	proto = ip_conntrack_proto_find_get(tuple->dst.protonum);
501		501
502	if (likely(proto->nfattr_to_tuple))	502	if (likely(proto->nfattr_to_tuple))
503	ret = proto->nfattr_to_tuple(tb, tuple);	503	ret = proto->nfattr_to_tuple(tb, tuple);
504		504
505	ip_conntrack_proto_put(proto);	505	ip_conntrack_proto_put(proto);
506		506
507	return ret;	507	return ret;
508	}	508	}
509		509
510	static inline int	510	static inline int
511	ctnetlink_parse_tuple(struct nfattr cda[], struct ip_conntrack_tuple tuple,	511	ctnetlink_parse_tuple(struct nfattr cda[], struct ip_conntrack_tuple tuple,
512	enum ctattr_tuple type)	512	enum ctattr_tuple type)
513	{	513	{
514	struct nfattr *tb[CTA_TUPLE_MAX];	514	struct nfattr *tb[CTA_TUPLE_MAX];
515	int err;	515	int err;
516		516
517	memset(tuple, 0, sizeof(*tuple));	517	memset(tuple, 0, sizeof(*tuple));
518		518
519	nfattr_parse_nested(tb, CTA_TUPLE_MAX, cda[type-1]);	519	nfattr_parse_nested(tb, CTA_TUPLE_MAX, cda[type-1]);
520		520
521	if (!tb[CTA_TUPLE_IP-1])	521	if (!tb[CTA_TUPLE_IP-1])
522	return -EINVAL;	522	return -EINVAL;
523		523
524	err = ctnetlink_parse_tuple_ip(tb[CTA_TUPLE_IP-1], tuple);	524	err = ctnetlink_parse_tuple_ip(tb[CTA_TUPLE_IP-1], tuple);
525	if (err < 0)	525	if (err < 0)
526	return err;	526	return err;
527		527
528	if (!tb[CTA_TUPLE_PROTO-1])	528	if (!tb[CTA_TUPLE_PROTO-1])
529	return -EINVAL;	529	return -EINVAL;
530		530
531	err = ctnetlink_parse_tuple_proto(tb[CTA_TUPLE_PROTO-1], tuple);	531	err = ctnetlink_parse_tuple_proto(tb[CTA_TUPLE_PROTO-1], tuple);
532	if (err < 0)	532	if (err < 0)
533	return err;	533	return err;
534		534
535	/* orig and expect tuples get DIR_ORIGINAL */	535	/* orig and expect tuples get DIR_ORIGINAL */
536	if (type == CTA_TUPLE_REPLY)	536	if (type == CTA_TUPLE_REPLY)
537	tuple->dst.dir = IP_CT_DIR_REPLY;	537	tuple->dst.dir = IP_CT_DIR_REPLY;
538	else	538	else
539	tuple->dst.dir = IP_CT_DIR_ORIGINAL;	539	tuple->dst.dir = IP_CT_DIR_ORIGINAL;
540		540
541	return 0;	541	return 0;
542	}	542	}
543		543
544	#ifdef CONFIG_IP_NF_NAT_NEEDED	544	#ifdef CONFIG_IP_NF_NAT_NEEDED
545	static const size_t cta_min_protonat[CTA_PROTONAT_MAX] = {	545	static const size_t cta_min_protonat[CTA_PROTONAT_MAX] = {
546	[CTA_PROTONAT_PORT_MIN-1] = sizeof(u_int16_t),	546	[CTA_PROTONAT_PORT_MIN-1] = sizeof(u_int16_t),
547	[CTA_PROTONAT_PORT_MAX-1] = sizeof(u_int16_t),	547	[CTA_PROTONAT_PORT_MAX-1] = sizeof(u_int16_t),
548	};	548	};
549		549
550	static int ctnetlink_parse_nat_proto(struct nfattr *attr,	550	static int ctnetlink_parse_nat_proto(struct nfattr *attr,
551	const struct ip_conntrack *ct,	551	const struct ip_conntrack *ct,
552	struct ip_nat_range *range)	552	struct ip_nat_range *range)
553	{	553	{
554	struct nfattr *tb[CTA_PROTONAT_MAX];	554	struct nfattr *tb[CTA_PROTONAT_MAX];
555	struct ip_nat_protocol *npt;	555	struct ip_nat_protocol *npt;
556		556
557	nfattr_parse_nested(tb, CTA_PROTONAT_MAX, attr);	557	nfattr_parse_nested(tb, CTA_PROTONAT_MAX, attr);
558		558
559	if (nfattr_bad_size(tb, CTA_PROTONAT_MAX, cta_min_protonat))	559	if (nfattr_bad_size(tb, CTA_PROTONAT_MAX, cta_min_protonat))
560	return -EINVAL;	560	return -EINVAL;
561		561
562	npt = ip_nat_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum);	562	npt = ip_nat_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum);
563		563
564	if (!npt->nfattr_to_range) {	564	if (!npt->nfattr_to_range) {
565	ip_nat_proto_put(npt);	565	ip_nat_proto_put(npt);
566	return 0;	566	return 0;
567	}	567	}
568		568
569	/* nfattr_to_range returns 1 if it parsed, 0 if not, neg. on error */	569	/* nfattr_to_range returns 1 if it parsed, 0 if not, neg. on error */
570	if (npt->nfattr_to_range(tb, range) > 0)	570	if (npt->nfattr_to_range(tb, range) > 0)
571	range->flags \|= IP_NAT_RANGE_PROTO_SPECIFIED;	571	range->flags \|= IP_NAT_RANGE_PROTO_SPECIFIED;
572		572
573	ip_nat_proto_put(npt);	573	ip_nat_proto_put(npt);
574		574
575	return 0;	575	return 0;
576	}	576	}
577		577
578	static const size_t cta_min_nat[CTA_NAT_MAX] = {	578	static const size_t cta_min_nat[CTA_NAT_MAX] = {
579	[CTA_NAT_MINIP-1] = sizeof(__be32),	579	[CTA_NAT_MINIP-1] = sizeof(__be32),
580	[CTA_NAT_MAXIP-1] = sizeof(__be32),	580	[CTA_NAT_MAXIP-1] = sizeof(__be32),
581	};	581	};
582		582
583	static inline int	583	static inline int
584	ctnetlink_parse_nat(struct nfattr *nat,	584	ctnetlink_parse_nat(struct nfattr *nat,
585	const struct ip_conntrack ct, struct ip_nat_range range)	585	const struct ip_conntrack ct, struct ip_nat_range range)
586	{	586	{
587	struct nfattr *tb[CTA_NAT_MAX];	587	struct nfattr *tb[CTA_NAT_MAX];
588	int err;	588	int err;
589		589
590	memset(range, 0, sizeof(*range));	590	memset(range, 0, sizeof(*range));
591		591
592	nfattr_parse_nested(tb, CTA_NAT_MAX, nat);	592	nfattr_parse_nested(tb, CTA_NAT_MAX, nat);
593		593
594	if (nfattr_bad_size(tb, CTA_NAT_MAX, cta_min_nat))	594	if (nfattr_bad_size(tb, CTA_NAT_MAX, cta_min_nat))
595	return -EINVAL;	595	return -EINVAL;
596		596
597	if (tb[CTA_NAT_MINIP-1])	597	if (tb[CTA_NAT_MINIP-1])
598	range->min_ip = (__be32 )NFA_DATA(tb[CTA_NAT_MINIP-1]);	598	range->min_ip = (__be32 )NFA_DATA(tb[CTA_NAT_MINIP-1]);
599		599
600	if (!tb[CTA_NAT_MAXIP-1])	600	if (!tb[CTA_NAT_MAXIP-1])
601	range->max_ip = range->min_ip;	601	range->max_ip = range->min_ip;
602	else	602	else
603	range->max_ip = (__be32 )NFA_DATA(tb[CTA_NAT_MAXIP-1]);	603	range->max_ip = (__be32 )NFA_DATA(tb[CTA_NAT_MAXIP-1]);
604		604
605	if (range->min_ip)	605	if (range->min_ip)
606	range->flags \|= IP_NAT_RANGE_MAP_IPS;	606	range->flags \|= IP_NAT_RANGE_MAP_IPS;
607		607
608	if (!tb[CTA_NAT_PROTO-1])	608	if (!tb[CTA_NAT_PROTO-1])
609	return 0;	609	return 0;
610		610
611	err = ctnetlink_parse_nat_proto(tb[CTA_NAT_PROTO-1], ct, range);	611	err = ctnetlink_parse_nat_proto(tb[CTA_NAT_PROTO-1], ct, range);
612	if (err < 0)	612	if (err < 0)
613	return err;	613	return err;
614		614
615	return 0;	615	return 0;
616	}	616	}
617	#endif	617	#endif
618		618
619	static inline int	619	static inline int
620	ctnetlink_parse_help(struct nfattr attr, char *helper_name)	620	ctnetlink_parse_help(struct nfattr attr, char *helper_name)
621	{	621	{
622	struct nfattr *tb[CTA_HELP_MAX];	622	struct nfattr *tb[CTA_HELP_MAX];
623		623
624	nfattr_parse_nested(tb, CTA_HELP_MAX, attr);	624	nfattr_parse_nested(tb, CTA_HELP_MAX, attr);
625		625
626	if (!tb[CTA_HELP_NAME-1])	626	if (!tb[CTA_HELP_NAME-1])
627	return -EINVAL;	627	return -EINVAL;
628		628
629	*helper_name = NFA_DATA(tb[CTA_HELP_NAME-1]);	629	*helper_name = NFA_DATA(tb[CTA_HELP_NAME-1]);
630		630
631	return 0;	631	return 0;
632	}	632	}
633		633
634	static const size_t cta_min[CTA_MAX] = {	634	static const size_t cta_min[CTA_MAX] = {
635	[CTA_STATUS-1] = sizeof(__be32),	635	[CTA_STATUS-1] = sizeof(__be32),
636	[CTA_TIMEOUT-1] = sizeof(__be32),	636	[CTA_TIMEOUT-1] = sizeof(__be32),
637	[CTA_MARK-1] = sizeof(__be32),	637	[CTA_MARK-1] = sizeof(__be32),
638	[CTA_USE-1] = sizeof(__be32),	638	[CTA_USE-1] = sizeof(__be32),
639	[CTA_ID-1] = sizeof(__be32)	639	[CTA_ID-1] = sizeof(__be32)
640	};	640	};
641		641
642	static int	642	static int
643	ctnetlink_del_conntrack(struct sock ctnl, struct sk_buff skb,	643	ctnetlink_del_conntrack(struct sock ctnl, struct sk_buff skb,
644	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	644	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
645	{	645	{
646	struct ip_conntrack_tuple_hash *h;	646	struct ip_conntrack_tuple_hash *h;
647	struct ip_conntrack_tuple tuple;	647	struct ip_conntrack_tuple tuple;
648	struct ip_conntrack *ct;	648	struct ip_conntrack *ct;
649	int err = 0;	649	int err = 0;
650		650
651	if (nfattr_bad_size(cda, CTA_MAX, cta_min))	651	if (nfattr_bad_size(cda, CTA_MAX, cta_min))
652	return -EINVAL;	652	return -EINVAL;
653		653
654	if (cda[CTA_TUPLE_ORIG-1])	654	if (cda[CTA_TUPLE_ORIG-1])
655	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG);	655	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG);
656	else if (cda[CTA_TUPLE_REPLY-1])	656	else if (cda[CTA_TUPLE_REPLY-1])
657	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY);	657	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY);
658	else {	658	else {
659	/* Flush the whole table */	659	/* Flush the whole table */
660	ip_conntrack_flush();	660	ip_conntrack_flush();
661	return 0;	661	return 0;
662	}	662	}
663		663
664	if (err < 0)	664	if (err < 0)
665	return err;	665	return err;
666		666
667	h = ip_conntrack_find_get(&tuple, NULL);	667	h = ip_conntrack_find_get(&tuple, NULL);
668	if (!h)	668	if (!h)
669	return -ENOENT;	669	return -ENOENT;
670		670
671	ct = tuplehash_to_ctrack(h);	671	ct = tuplehash_to_ctrack(h);
672		672
673	if (cda[CTA_ID-1]) {	673	if (cda[CTA_ID-1]) {
674	u_int32_t id = ntohl((__be32 )NFA_DATA(cda[CTA_ID-1]));	674	u_int32_t id = ntohl((__be32 )NFA_DATA(cda[CTA_ID-1]));
675	if (ct->id != id) {	675	if (ct->id != id) {
676	ip_conntrack_put(ct);	676	ip_conntrack_put(ct);
677	return -ENOENT;	677	return -ENOENT;
678	}	678	}
679	}	679	}
680	if (del_timer(&ct->timeout))	680	if (del_timer(&ct->timeout))
681	ct->timeout.function((unsigned long)ct);	681	ct->timeout.function((unsigned long)ct);
682		682
683	ip_conntrack_put(ct);	683	ip_conntrack_put(ct);
684		684
685	return 0;	685	return 0;
686	}	686	}
687		687
688	static int	688	static int
689	ctnetlink_get_conntrack(struct sock ctnl, struct sk_buff skb,	689	ctnetlink_get_conntrack(struct sock ctnl, struct sk_buff skb,
690	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	690	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
691	{	691	{
692	struct ip_conntrack_tuple_hash *h;	692	struct ip_conntrack_tuple_hash *h;
693	struct ip_conntrack_tuple tuple;	693	struct ip_conntrack_tuple tuple;
694	struct ip_conntrack *ct;	694	struct ip_conntrack *ct;
695	struct sk_buff *skb2 = NULL;	695	struct sk_buff *skb2 = NULL;
696	int err = 0;	696	int err = 0;
697		697
698	if (nlh->nlmsg_flags & NLM_F_DUMP) {	698	if (nlh->nlmsg_flags & NLM_F_DUMP) {
699	struct nfgenmsg *msg = NLMSG_DATA(nlh);	699	struct nfgenmsg *msg = NLMSG_DATA(nlh);
700	u32 rlen;	700	u32 rlen;
701		701
702	if (msg->nfgen_family != AF_INET)	702	if (msg->nfgen_family != AF_INET)
703	return -EAFNOSUPPORT;	703	return -EAFNOSUPPORT;
704		704
705	#ifndef CONFIG_IP_NF_CT_ACCT	705	#ifndef CONFIG_IP_NF_CT_ACCT
706	if (NFNL_MSG_TYPE(nlh->nlmsg_type) == IPCTNL_MSG_CT_GET_CTRZERO)	706	if (NFNL_MSG_TYPE(nlh->nlmsg_type) == IPCTNL_MSG_CT_GET_CTRZERO)
707	return -ENOTSUPP;	707	return -ENOTSUPP;
708	#endif	708	#endif
709	if ((*errp = netlink_dump_start(ctnl, skb, nlh,	709	if ((*errp = netlink_dump_start(ctnl, skb, nlh,
710	ctnetlink_dump_table,	710	ctnetlink_dump_table,
711	ctnetlink_done)) != 0)	711	ctnetlink_done)) != 0)
712	return -EINVAL;	712	return -EINVAL;
713		713
714	rlen = NLMSG_ALIGN(nlh->nlmsg_len);	714	rlen = NLMSG_ALIGN(nlh->nlmsg_len);
715	if (rlen > skb->len)	715	if (rlen > skb->len)
716	rlen = skb->len;	716	rlen = skb->len;
717	skb_pull(skb, rlen);	717	skb_pull(skb, rlen);
718	return 0;	718	return 0;
719	}	719	}
720		720
721	if (nfattr_bad_size(cda, CTA_MAX, cta_min))	721	if (nfattr_bad_size(cda, CTA_MAX, cta_min))
722	return -EINVAL;	722	return -EINVAL;
723		723
724	if (cda[CTA_TUPLE_ORIG-1])	724	if (cda[CTA_TUPLE_ORIG-1])
725	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG);	725	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG);
726	else if (cda[CTA_TUPLE_REPLY-1])	726	else if (cda[CTA_TUPLE_REPLY-1])
727	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY);	727	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY);
728	else	728	else
729	return -EINVAL;	729	return -EINVAL;
730		730
731	if (err < 0)	731	if (err < 0)
732	return err;	732	return err;
733		733
734	h = ip_conntrack_find_get(&tuple, NULL);	734	h = ip_conntrack_find_get(&tuple, NULL);
735	if (!h)	735	if (!h)
736	return -ENOENT;	736	return -ENOENT;
737		737
738	ct = tuplehash_to_ctrack(h);	738	ct = tuplehash_to_ctrack(h);
739		739
740	err = -ENOMEM;	740	err = -ENOMEM;
741	skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);	741	skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
742	if (!skb2) {	742	if (!skb2) {
743	ip_conntrack_put(ct);	743	ip_conntrack_put(ct);
744	return -ENOMEM;	744	return -ENOMEM;
745	}	745	}
746	NETLINK_CB(skb2).dst_pid = NETLINK_CB(skb).pid;
747		746
748	err = ctnetlink_fill_info(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq,	747	err = ctnetlink_fill_info(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq,
749	IPCTNL_MSG_CT_NEW, 1, ct);	748	IPCTNL_MSG_CT_NEW, 1, ct);
750	ip_conntrack_put(ct);	749	ip_conntrack_put(ct);
751	if (err <= 0)	750	if (err <= 0)
752	goto free;	751	goto free;
753		752
754	err = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);	753	err = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
755	if (err < 0)	754	if (err < 0)
756	goto out;	755	goto out;
757		756
758	return 0;	757	return 0;
759		758
760	free:	759	free:
761	kfree_skb(skb2);	760	kfree_skb(skb2);
762	out:	761	out:
763	return err;	762	return err;
764	}	763	}
765		764
766	static inline int	765	static inline int
767	ctnetlink_change_status(struct ip_conntrack ct, struct nfattr cda[])	766	ctnetlink_change_status(struct ip_conntrack ct, struct nfattr cda[])
768	{	767	{
769	unsigned long d;	768	unsigned long d;
770	unsigned status = ntohl((__be32 )NFA_DATA(cda[CTA_STATUS-1]));	769	unsigned status = ntohl((__be32 )NFA_DATA(cda[CTA_STATUS-1]));
771	d = ct->status ^ status;	770	d = ct->status ^ status;
772		771
773	if (d & (IPS_EXPECTED\|IPS_CONFIRMED\|IPS_DYING))	772	if (d & (IPS_EXPECTED\|IPS_CONFIRMED\|IPS_DYING))
774	/* unchangeable */	773	/* unchangeable */
775	return -EINVAL;	774	return -EINVAL;
776		775
777	if (d & IPS_SEEN_REPLY && !(status & IPS_SEEN_REPLY))	776	if (d & IPS_SEEN_REPLY && !(status & IPS_SEEN_REPLY))
778	/* SEEN_REPLY bit can only be set */	777	/* SEEN_REPLY bit can only be set */
779	return -EINVAL;	778	return -EINVAL;
780		779
781		780
782	if (d & IPS_ASSURED && !(status & IPS_ASSURED))	781	if (d & IPS_ASSURED && !(status & IPS_ASSURED))
783	/* ASSURED bit can only be set */	782	/* ASSURED bit can only be set */
784	return -EINVAL;	783	return -EINVAL;
785		784
786	if (cda[CTA_NAT_SRC-1] \|\| cda[CTA_NAT_DST-1]) {	785	if (cda[CTA_NAT_SRC-1] \|\| cda[CTA_NAT_DST-1]) {
787	#ifndef CONFIG_IP_NF_NAT_NEEDED	786	#ifndef CONFIG_IP_NF_NAT_NEEDED
788	return -EINVAL;	787	return -EINVAL;
789	#else	788	#else
790	struct ip_nat_range range;	789	struct ip_nat_range range;
791		790
792	if (cda[CTA_NAT_DST-1]) {	791	if (cda[CTA_NAT_DST-1]) {
793	if (ctnetlink_parse_nat(cda[CTA_NAT_DST-1], ct,	792	if (ctnetlink_parse_nat(cda[CTA_NAT_DST-1], ct,
794	&range) < 0)	793	&range) < 0)
795	return -EINVAL;	794	return -EINVAL;
796	if (ip_nat_initialized(ct,	795	if (ip_nat_initialized(ct,
797	HOOK2MANIP(NF_IP_PRE_ROUTING)))	796	HOOK2MANIP(NF_IP_PRE_ROUTING)))
798	return -EEXIST;	797	return -EEXIST;
799	ip_nat_setup_info(ct, &range, NF_IP_PRE_ROUTING);	798	ip_nat_setup_info(ct, &range, NF_IP_PRE_ROUTING);
800	}	799	}
801	if (cda[CTA_NAT_SRC-1]) {	800	if (cda[CTA_NAT_SRC-1]) {
802	if (ctnetlink_parse_nat(cda[CTA_NAT_SRC-1], ct,	801	if (ctnetlink_parse_nat(cda[CTA_NAT_SRC-1], ct,
803	&range) < 0)	802	&range) < 0)
804	return -EINVAL;	803	return -EINVAL;
805	if (ip_nat_initialized(ct,	804	if (ip_nat_initialized(ct,
806	HOOK2MANIP(NF_IP_POST_ROUTING)))	805	HOOK2MANIP(NF_IP_POST_ROUTING)))
807	return -EEXIST;	806	return -EEXIST;
808	ip_nat_setup_info(ct, &range, NF_IP_POST_ROUTING);	807	ip_nat_setup_info(ct, &range, NF_IP_POST_ROUTING);
809	}	808	}
810	#endif	809	#endif
811	}	810	}
812		811
813	/* Be careful here, modifying NAT bits can screw up things,	812	/* Be careful here, modifying NAT bits can screw up things,
814	* so don't let users modify them directly if they don't pass	813	* so don't let users modify them directly if they don't pass
815	* ip_nat_range. */	814	* ip_nat_range. */
816	ct->status \|= status & ~(IPS_NAT_DONE_MASK \| IPS_NAT_MASK);	815	ct->status \|= status & ~(IPS_NAT_DONE_MASK \| IPS_NAT_MASK);
817	return 0;	816	return 0;
818	}	817	}
819		818
820		819
821	static inline int	820	static inline int
822	ctnetlink_change_helper(struct ip_conntrack ct, struct nfattr cda[])	821	ctnetlink_change_helper(struct ip_conntrack ct, struct nfattr cda[])
823	{	822	{
824	struct ip_conntrack_helper *helper;	823	struct ip_conntrack_helper *helper;
825	char *helpname;	824	char *helpname;
826	int err;	825	int err;
827		826
828	/* don't change helper of sibling connections */	827	/* don't change helper of sibling connections */
829	if (ct->master)	828	if (ct->master)
830	return -EINVAL;	829	return -EINVAL;
831		830
832	err = ctnetlink_parse_help(cda[CTA_HELP-1], &helpname);	831	err = ctnetlink_parse_help(cda[CTA_HELP-1], &helpname);
833	if (err < 0)	832	if (err < 0)
834	return err;	833	return err;
835		834
836	helper = __ip_conntrack_helper_find_byname(helpname);	835	helper = __ip_conntrack_helper_find_byname(helpname);
837	if (!helper) {	836	if (!helper) {
838	if (!strcmp(helpname, ""))	837	if (!strcmp(helpname, ""))
839	helper = NULL;	838	helper = NULL;
840	else	839	else
841	return -EINVAL;	840	return -EINVAL;
842	}	841	}
843		842
844	if (ct->helper) {	843	if (ct->helper) {
845	if (!helper) {	844	if (!helper) {
846	/* we had a helper before ... */	845	/* we had a helper before ... */
847	ip_ct_remove_expectations(ct);	846	ip_ct_remove_expectations(ct);
848	ct->helper = NULL;	847	ct->helper = NULL;
849	} else {	848	} else {
850	/* need to zero data of old helper */	849	/* need to zero data of old helper */
851	memset(&ct->help, 0, sizeof(ct->help));	850	memset(&ct->help, 0, sizeof(ct->help));
852	}	851	}
853	}	852	}
854		853
855	ct->helper = helper;	854	ct->helper = helper;
856		855
857	return 0;	856	return 0;
858	}	857	}
859		858
860	static inline int	859	static inline int
861	ctnetlink_change_timeout(struct ip_conntrack ct, struct nfattr cda[])	860	ctnetlink_change_timeout(struct ip_conntrack ct, struct nfattr cda[])
862	{	861	{
863	u_int32_t timeout = ntohl((__be32 )NFA_DATA(cda[CTA_TIMEOUT-1]));	862	u_int32_t timeout = ntohl((__be32 )NFA_DATA(cda[CTA_TIMEOUT-1]));
864		863
865	if (!del_timer(&ct->timeout))	864	if (!del_timer(&ct->timeout))
866	return -ETIME;	865	return -ETIME;
867		866
868	ct->timeout.expires = jiffies + timeout * HZ;	867	ct->timeout.expires = jiffies + timeout * HZ;
869	add_timer(&ct->timeout);	868	add_timer(&ct->timeout);
870		869
871	return 0;	870	return 0;
872	}	871	}
873		872
874	static inline int	873	static inline int
875	ctnetlink_change_protoinfo(struct ip_conntrack ct, struct nfattr cda[])	874	ctnetlink_change_protoinfo(struct ip_conntrack ct, struct nfattr cda[])
876	{	875	{
877	struct nfattr tb[CTA_PROTOINFO_MAX], attr = cda[CTA_PROTOINFO-1];	876	struct nfattr tb[CTA_PROTOINFO_MAX], attr = cda[CTA_PROTOINFO-1];
878	struct ip_conntrack_protocol *proto;	877	struct ip_conntrack_protocol *proto;
879	u_int16_t npt = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum;	878	u_int16_t npt = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum;
880	int err = 0;	879	int err = 0;
881		880
882	nfattr_parse_nested(tb, CTA_PROTOINFO_MAX, attr);	881	nfattr_parse_nested(tb, CTA_PROTOINFO_MAX, attr);
883		882
884	proto = ip_conntrack_proto_find_get(npt);	883	proto = ip_conntrack_proto_find_get(npt);
885		884
886	if (proto->from_nfattr)	885	if (proto->from_nfattr)
887	err = proto->from_nfattr(tb, ct);	886	err = proto->from_nfattr(tb, ct);
888	ip_conntrack_proto_put(proto);	887	ip_conntrack_proto_put(proto);
889		888
890	return err;	889	return err;
891	}	890	}
892		891
893	static int	892	static int
894	ctnetlink_change_conntrack(struct ip_conntrack ct, struct nfattr cda[])	893	ctnetlink_change_conntrack(struct ip_conntrack ct, struct nfattr cda[])
895	{	894	{
896	int err;	895	int err;
897		896
898	if (cda[CTA_HELP-1]) {	897	if (cda[CTA_HELP-1]) {
899	err = ctnetlink_change_helper(ct, cda);	898	err = ctnetlink_change_helper(ct, cda);
900	if (err < 0)	899	if (err < 0)
901	return err;	900	return err;
902	}	901	}
903		902
904	if (cda[CTA_TIMEOUT-1]) {	903	if (cda[CTA_TIMEOUT-1]) {
905	err = ctnetlink_change_timeout(ct, cda);	904	err = ctnetlink_change_timeout(ct, cda);
906	if (err < 0)	905	if (err < 0)
907	return err;	906	return err;
908	}	907	}
909		908
910	if (cda[CTA_STATUS-1]) {	909	if (cda[CTA_STATUS-1]) {
911	err = ctnetlink_change_status(ct, cda);	910	err = ctnetlink_change_status(ct, cda);
912	if (err < 0)	911	if (err < 0)
913	return err;	912	return err;
914	}	913	}
915		914
916	if (cda[CTA_PROTOINFO-1]) {	915	if (cda[CTA_PROTOINFO-1]) {
917	err = ctnetlink_change_protoinfo(ct, cda);	916	err = ctnetlink_change_protoinfo(ct, cda);
918	if (err < 0)	917	if (err < 0)
919	return err;	918	return err;
920	}	919	}
921		920
922	#if defined(CONFIG_IP_NF_CONNTRACK_MARK)	921	#if defined(CONFIG_IP_NF_CONNTRACK_MARK)
923	if (cda[CTA_MARK-1])	922	if (cda[CTA_MARK-1])
924	ct->mark = ntohl((__be32 )NFA_DATA(cda[CTA_MARK-1]));	923	ct->mark = ntohl((__be32 )NFA_DATA(cda[CTA_MARK-1]));
925	#endif	924	#endif
926		925
927	return 0;	926	return 0;
928	}	927	}
929		928
930	static int	929	static int
931	ctnetlink_create_conntrack(struct nfattr *cda[],	930	ctnetlink_create_conntrack(struct nfattr *cda[],
932	struct ip_conntrack_tuple *otuple,	931	struct ip_conntrack_tuple *otuple,
933	struct ip_conntrack_tuple *rtuple)	932	struct ip_conntrack_tuple *rtuple)
934	{	933	{
935	struct ip_conntrack *ct;	934	struct ip_conntrack *ct;
936	int err = -EINVAL;	935	int err = -EINVAL;
937		936
938	ct = ip_conntrack_alloc(otuple, rtuple);	937	ct = ip_conntrack_alloc(otuple, rtuple);
939	if (ct == NULL \|\| IS_ERR(ct))	938	if (ct == NULL \|\| IS_ERR(ct))
940	return -ENOMEM;	939	return -ENOMEM;
941		940
942	if (!cda[CTA_TIMEOUT-1])	941	if (!cda[CTA_TIMEOUT-1])
943	goto err;	942	goto err;
944	ct->timeout.expires = ntohl((__be32 )NFA_DATA(cda[CTA_TIMEOUT-1]));	943	ct->timeout.expires = ntohl((__be32 )NFA_DATA(cda[CTA_TIMEOUT-1]));
945		944
946	ct->timeout.expires = jiffies + ct->timeout.expires * HZ;	945	ct->timeout.expires = jiffies + ct->timeout.expires * HZ;
947	ct->status \|= IPS_CONFIRMED;	946	ct->status \|= IPS_CONFIRMED;
948		947
949	err = ctnetlink_change_status(ct, cda);	948	err = ctnetlink_change_status(ct, cda);
950	if (err < 0)	949	if (err < 0)
951	goto err;	950	goto err;
952		951
953	if (cda[CTA_PROTOINFO-1]) {	952	if (cda[CTA_PROTOINFO-1]) {
954	err = ctnetlink_change_protoinfo(ct, cda);	953	err = ctnetlink_change_protoinfo(ct, cda);
955	if (err < 0)	954	if (err < 0)
956	return err;	955	return err;
957	}	956	}
958		957
959	#if defined(CONFIG_IP_NF_CONNTRACK_MARK)	958	#if defined(CONFIG_IP_NF_CONNTRACK_MARK)
960	if (cda[CTA_MARK-1])	959	if (cda[CTA_MARK-1])
961	ct->mark = ntohl((__be32 )NFA_DATA(cda[CTA_MARK-1]));	960	ct->mark = ntohl((__be32 )NFA_DATA(cda[CTA_MARK-1]));
962	#endif	961	#endif
963		962
964	ct->helper = ip_conntrack_helper_find_get(rtuple);	963	ct->helper = ip_conntrack_helper_find_get(rtuple);
965		964
966	add_timer(&ct->timeout);	965	add_timer(&ct->timeout);
967	ip_conntrack_hash_insert(ct);	966	ip_conntrack_hash_insert(ct);
968		967
969	if (ct->helper)	968	if (ct->helper)
970	ip_conntrack_helper_put(ct->helper);	969	ip_conntrack_helper_put(ct->helper);
971		970
972	return 0;	971	return 0;
973		972
974	err:	973	err:
975	ip_conntrack_free(ct);	974	ip_conntrack_free(ct);
976	return err;	975	return err;
977	}	976	}
978		977
979	static int	978	static int
980	ctnetlink_new_conntrack(struct sock ctnl, struct sk_buff skb,	979	ctnetlink_new_conntrack(struct sock ctnl, struct sk_buff skb,
981	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	980	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
982	{	981	{
983	struct ip_conntrack_tuple otuple, rtuple;	982	struct ip_conntrack_tuple otuple, rtuple;
984	struct ip_conntrack_tuple_hash *h = NULL;	983	struct ip_conntrack_tuple_hash *h = NULL;
985	int err = 0;	984	int err = 0;
986		985
987	if (nfattr_bad_size(cda, CTA_MAX, cta_min))	986	if (nfattr_bad_size(cda, CTA_MAX, cta_min))
988	return -EINVAL;	987	return -EINVAL;
989		988
990	if (cda[CTA_TUPLE_ORIG-1]) {	989	if (cda[CTA_TUPLE_ORIG-1]) {
991	err = ctnetlink_parse_tuple(cda, &otuple, CTA_TUPLE_ORIG);	990	err = ctnetlink_parse_tuple(cda, &otuple, CTA_TUPLE_ORIG);
992	if (err < 0)	991	if (err < 0)
993	return err;	992	return err;
994	}	993	}
995		994
996	if (cda[CTA_TUPLE_REPLY-1]) {	995	if (cda[CTA_TUPLE_REPLY-1]) {
997	err = ctnetlink_parse_tuple(cda, &rtuple, CTA_TUPLE_REPLY);	996	err = ctnetlink_parse_tuple(cda, &rtuple, CTA_TUPLE_REPLY);
998	if (err < 0)	997	if (err < 0)
999	return err;	998	return err;
1000	}	999	}
1001		1000
1002	write_lock_bh(&ip_conntrack_lock);	1001	write_lock_bh(&ip_conntrack_lock);
1003	if (cda[CTA_TUPLE_ORIG-1])	1002	if (cda[CTA_TUPLE_ORIG-1])
1004	h = __ip_conntrack_find(&otuple, NULL);	1003	h = __ip_conntrack_find(&otuple, NULL);
1005	else if (cda[CTA_TUPLE_REPLY-1])	1004	else if (cda[CTA_TUPLE_REPLY-1])
1006	h = __ip_conntrack_find(&rtuple, NULL);	1005	h = __ip_conntrack_find(&rtuple, NULL);
1007		1006
1008	if (h == NULL) {	1007	if (h == NULL) {
1009	write_unlock_bh(&ip_conntrack_lock);	1008	write_unlock_bh(&ip_conntrack_lock);
1010	err = -ENOENT;	1009	err = -ENOENT;
1011	if (nlh->nlmsg_flags & NLM_F_CREATE)	1010	if (nlh->nlmsg_flags & NLM_F_CREATE)
1012	err = ctnetlink_create_conntrack(cda, &otuple, &rtuple);	1011	err = ctnetlink_create_conntrack(cda, &otuple, &rtuple);
1013	return err;	1012	return err;
1014	}	1013	}
1015	/* implicit 'else' */	1014	/* implicit 'else' */
1016		1015
1017	/* we only allow nat config for new conntracks */	1016	/* we only allow nat config for new conntracks */
1018	if (cda[CTA_NAT_SRC-1] \|\| cda[CTA_NAT_DST-1]) {	1017	if (cda[CTA_NAT_SRC-1] \|\| cda[CTA_NAT_DST-1]) {
1019	err = -EINVAL;	1018	err = -EINVAL;
1020	goto out_unlock;	1019	goto out_unlock;
1021	}	1020	}
1022		1021
1023	/* We manipulate the conntrack inside the global conntrack table lock,	1022	/* We manipulate the conntrack inside the global conntrack table lock,
1024	* so there's no need to increase the refcount */	1023	* so there's no need to increase the refcount */
1025	err = -EEXIST;	1024	err = -EEXIST;
1026	if (!(nlh->nlmsg_flags & NLM_F_EXCL))	1025	if (!(nlh->nlmsg_flags & NLM_F_EXCL))
1027	err = ctnetlink_change_conntrack(tuplehash_to_ctrack(h), cda);	1026	err = ctnetlink_change_conntrack(tuplehash_to_ctrack(h), cda);
1028		1027
1029	out_unlock:	1028	out_unlock:
1030	write_unlock_bh(&ip_conntrack_lock);	1029	write_unlock_bh(&ip_conntrack_lock);
1031	return err;	1030	return err;
1032	}	1031	}
1033		1032
1034	/***********************************************************************	1033	/***********************************************************************
1035	* EXPECT	1034	* EXPECT
1036	***********************************************************************/	1035	***********************************************************************/
1037		1036
1038	static inline int	1037	static inline int
1039	ctnetlink_exp_dump_tuple(struct sk_buff *skb,	1038	ctnetlink_exp_dump_tuple(struct sk_buff *skb,
1040	const struct ip_conntrack_tuple *tuple,	1039	const struct ip_conntrack_tuple *tuple,
1041	enum ctattr_expect type)	1040	enum ctattr_expect type)
1042	{	1041	{
1043	struct nfattr *nest_parms = NFA_NEST(skb, type);	1042	struct nfattr *nest_parms = NFA_NEST(skb, type);
1044		1043
1045	if (ctnetlink_dump_tuples(skb, tuple) < 0)	1044	if (ctnetlink_dump_tuples(skb, tuple) < 0)
1046	goto nfattr_failure;	1045	goto nfattr_failure;
1047		1046
1048	NFA_NEST_END(skb, nest_parms);	1047	NFA_NEST_END(skb, nest_parms);
1049		1048
1050	return 0;	1049	return 0;
1051		1050
1052	nfattr_failure:	1051	nfattr_failure:
1053	return -1;	1052	return -1;
1054	}	1053	}
1055		1054
1056	static inline int	1055	static inline int
1057	ctnetlink_exp_dump_mask(struct sk_buff *skb,	1056	ctnetlink_exp_dump_mask(struct sk_buff *skb,
1058	const struct ip_conntrack_tuple *tuple,	1057	const struct ip_conntrack_tuple *tuple,
1059	const struct ip_conntrack_tuple *mask)	1058	const struct ip_conntrack_tuple *mask)
1060	{	1059	{
1061	int ret;	1060	int ret;
1062	struct ip_conntrack_protocol *proto;	1061	struct ip_conntrack_protocol *proto;
1063	struct nfattr *nest_parms = NFA_NEST(skb, CTA_EXPECT_MASK);	1062	struct nfattr *nest_parms = NFA_NEST(skb, CTA_EXPECT_MASK);
1064		1063
1065	ret = ctnetlink_dump_tuples_ip(skb, mask);	1064	ret = ctnetlink_dump_tuples_ip(skb, mask);
1066	if (unlikely(ret < 0))	1065	if (unlikely(ret < 0))
1067	goto nfattr_failure;	1066	goto nfattr_failure;
1068		1067
1069	proto = ip_conntrack_proto_find_get(tuple->dst.protonum);	1068	proto = ip_conntrack_proto_find_get(tuple->dst.protonum);
1070	ret = ctnetlink_dump_tuples_proto(skb, mask, proto);	1069	ret = ctnetlink_dump_tuples_proto(skb, mask, proto);
1071	ip_conntrack_proto_put(proto);	1070	ip_conntrack_proto_put(proto);
1072	if (unlikely(ret < 0))	1071	if (unlikely(ret < 0))
1073	goto nfattr_failure;	1072	goto nfattr_failure;
1074		1073
1075	NFA_NEST_END(skb, nest_parms);	1074	NFA_NEST_END(skb, nest_parms);
1076		1075
1077	return 0;	1076	return 0;
1078		1077
1079	nfattr_failure:	1078	nfattr_failure:
1080	return -1;	1079	return -1;
1081	}	1080	}
1082		1081
1083	static inline int	1082	static inline int
1084	ctnetlink_exp_dump_expect(struct sk_buff *skb,	1083	ctnetlink_exp_dump_expect(struct sk_buff *skb,
1085	const struct ip_conntrack_expect *exp)	1084	const struct ip_conntrack_expect *exp)
1086	{	1085	{
1087	struct ip_conntrack *master = exp->master;	1086	struct ip_conntrack *master = exp->master;
1088	__be32 timeout = htonl((exp->timeout.expires - jiffies) / HZ);	1087	__be32 timeout = htonl((exp->timeout.expires - jiffies) / HZ);
1089	__be32 id = htonl(exp->id);	1088	__be32 id = htonl(exp->id);
1090		1089
1091	if (ctnetlink_exp_dump_tuple(skb, &exp->tuple, CTA_EXPECT_TUPLE) < 0)	1090	if (ctnetlink_exp_dump_tuple(skb, &exp->tuple, CTA_EXPECT_TUPLE) < 0)
1092	goto nfattr_failure;	1091	goto nfattr_failure;
1093	if (ctnetlink_exp_dump_mask(skb, &exp->tuple, &exp->mask) < 0)	1092	if (ctnetlink_exp_dump_mask(skb, &exp->tuple, &exp->mask) < 0)
1094	goto nfattr_failure;	1093	goto nfattr_failure;
1095	if (ctnetlink_exp_dump_tuple(skb,	1094	if (ctnetlink_exp_dump_tuple(skb,
1096	&master->tuplehash[IP_CT_DIR_ORIGINAL].tuple,	1095	&master->tuplehash[IP_CT_DIR_ORIGINAL].tuple,
1097	CTA_EXPECT_MASTER) < 0)	1096	CTA_EXPECT_MASTER) < 0)
1098	goto nfattr_failure;	1097	goto nfattr_failure;
1099		1098
1100	NFA_PUT(skb, CTA_EXPECT_TIMEOUT, sizeof(__be32), &timeout);	1099	NFA_PUT(skb, CTA_EXPECT_TIMEOUT, sizeof(__be32), &timeout);
1101	NFA_PUT(skb, CTA_EXPECT_ID, sizeof(__be32), &id);	1100	NFA_PUT(skb, CTA_EXPECT_ID, sizeof(__be32), &id);
1102		1101
1103	return 0;	1102	return 0;
1104		1103
1105	nfattr_failure:	1104	nfattr_failure:
1106	return -1;	1105	return -1;
1107	}	1106	}
1108		1107
1109	static int	1108	static int
1110	ctnetlink_exp_fill_info(struct sk_buff *skb, u32 pid, u32 seq,	1109	ctnetlink_exp_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
1111	int event,	1110	int event,
1112	int nowait,	1111	int nowait,
1113	const struct ip_conntrack_expect *exp)	1112	const struct ip_conntrack_expect *exp)
1114	{	1113	{
1115	struct nlmsghdr *nlh;	1114	struct nlmsghdr *nlh;
1116	struct nfgenmsg *nfmsg;	1115	struct nfgenmsg *nfmsg;
1117	unsigned char *b;	1116	unsigned char *b;
1118		1117
1119	b = skb->tail;	1118	b = skb->tail;
1120		1119
1121	event \|= NFNL_SUBSYS_CTNETLINK_EXP << 8;	1120	event \|= NFNL_SUBSYS_CTNETLINK_EXP << 8;
1122	nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));	1121	nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));
1123	nfmsg = NLMSG_DATA(nlh);	1122	nfmsg = NLMSG_DATA(nlh);
1124		1123
1125	nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0;	1124	nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0;
1126	nfmsg->nfgen_family = AF_INET;	1125	nfmsg->nfgen_family = AF_INET;
1127	nfmsg->version = NFNETLINK_V0;	1126	nfmsg->version = NFNETLINK_V0;
1128	nfmsg->res_id = 0;	1127	nfmsg->res_id = 0;
1129		1128
1130	if (ctnetlink_exp_dump_expect(skb, exp) < 0)	1129	if (ctnetlink_exp_dump_expect(skb, exp) < 0)
1131	goto nfattr_failure;	1130	goto nfattr_failure;
1132		1131
1133	nlh->nlmsg_len = skb->tail - b;	1132	nlh->nlmsg_len = skb->tail - b;
1134	return skb->len;	1133	return skb->len;
1135		1134
1136	nlmsg_failure:	1135	nlmsg_failure:
1137	nfattr_failure:	1136	nfattr_failure:
1138	skb_trim(skb, b - skb->data);	1137	skb_trim(skb, b - skb->data);
1139	return -1;	1138	return -1;
1140	}	1139	}
1141		1140
1142	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS	1141	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS
1143	static int ctnetlink_expect_event(struct notifier_block *this,	1142	static int ctnetlink_expect_event(struct notifier_block *this,
1144	unsigned long events, void *ptr)	1143	unsigned long events, void *ptr)
1145	{	1144	{
1146	struct nlmsghdr *nlh;	1145	struct nlmsghdr *nlh;
1147	struct nfgenmsg *nfmsg;	1146	struct nfgenmsg *nfmsg;
1148	struct ip_conntrack_expect exp = (struct ip_conntrack_expect )ptr;	1147	struct ip_conntrack_expect exp = (struct ip_conntrack_expect )ptr;
1149	struct sk_buff *skb;	1148	struct sk_buff *skb;
1150	unsigned int type;	1149	unsigned int type;
1151	unsigned char *b;	1150	unsigned char *b;
1152	int flags = 0;	1151	int flags = 0;
1153		1152
1154	if (events & IPEXP_NEW) {	1153	if (events & IPEXP_NEW) {
1155	type = IPCTNL_MSG_EXP_NEW;	1154	type = IPCTNL_MSG_EXP_NEW;
1156	flags = NLM_F_CREATE\|NLM_F_EXCL;	1155	flags = NLM_F_CREATE\|NLM_F_EXCL;
1157	} else	1156	} else
1158	return NOTIFY_DONE;	1157	return NOTIFY_DONE;
1159		1158
1160	if (!nfnetlink_has_listeners(NFNLGRP_CONNTRACK_EXP_NEW))	1159	if (!nfnetlink_has_listeners(NFNLGRP_CONNTRACK_EXP_NEW))
1161	return NOTIFY_DONE;	1160	return NOTIFY_DONE;
1162		1161
1163	skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);	1162	skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
1164	if (!skb)	1163	if (!skb)
1165	return NOTIFY_DONE;	1164	return NOTIFY_DONE;
1166		1165
1167	b = skb->tail;	1166	b = skb->tail;
1168		1167
1169	type \|= NFNL_SUBSYS_CTNETLINK_EXP << 8;	1168	type \|= NFNL_SUBSYS_CTNETLINK_EXP << 8;
1170	nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg));	1169	nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg));
1171	nfmsg = NLMSG_DATA(nlh);	1170	nfmsg = NLMSG_DATA(nlh);
1172		1171
1173	nlh->nlmsg_flags = flags;	1172	nlh->nlmsg_flags = flags;
1174	nfmsg->nfgen_family = AF_INET;	1173	nfmsg->nfgen_family = AF_INET;
1175	nfmsg->version = NFNETLINK_V0;	1174	nfmsg->version = NFNETLINK_V0;
1176	nfmsg->res_id = 0;	1175	nfmsg->res_id = 0;
1177		1176
1178	if (ctnetlink_exp_dump_expect(skb, exp) < 0)	1177	if (ctnetlink_exp_dump_expect(skb, exp) < 0)
1179	goto nfattr_failure;	1178	goto nfattr_failure;
1180		1179
1181	nlh->nlmsg_len = skb->tail - b;	1180	nlh->nlmsg_len = skb->tail - b;
1182	nfnetlink_send(skb, 0, NFNLGRP_CONNTRACK_EXP_NEW, 0);	1181	nfnetlink_send(skb, 0, NFNLGRP_CONNTRACK_EXP_NEW, 0);
1183	return NOTIFY_DONE;	1182	return NOTIFY_DONE;
1184		1183
1185	nlmsg_failure:	1184	nlmsg_failure:
1186	nfattr_failure:	1185	nfattr_failure:
1187	kfree_skb(skb);	1186	kfree_skb(skb);
1188	return NOTIFY_DONE;	1187	return NOTIFY_DONE;
1189	}	1188	}
1190	#endif	1189	#endif
1191		1190
1192	static int	1191	static int
1193	ctnetlink_exp_dump_table(struct sk_buff skb, struct netlink_callback cb)	1192	ctnetlink_exp_dump_table(struct sk_buff skb, struct netlink_callback cb)
1194	{	1193	{
1195	struct ip_conntrack_expect *exp = NULL;	1194	struct ip_conntrack_expect *exp = NULL;
1196	struct list_head *i;	1195	struct list_head *i;
1197	u_int32_t id = (u_int32_t ) &cb->args[0];	1196	u_int32_t id = (u_int32_t ) &cb->args[0];
1198		1197
1199	read_lock_bh(&ip_conntrack_lock);	1198	read_lock_bh(&ip_conntrack_lock);
1200	list_for_each_prev(i, &ip_conntrack_expect_list) {	1199	list_for_each_prev(i, &ip_conntrack_expect_list) {
1201	exp = (struct ip_conntrack_expect *) i;	1200	exp = (struct ip_conntrack_expect *) i;
1202	if (exp->id <= *id)	1201	if (exp->id <= *id)
1203	continue;	1202	continue;
1204	if (ctnetlink_exp_fill_info(skb, NETLINK_CB(cb->skb).pid,	1203	if (ctnetlink_exp_fill_info(skb, NETLINK_CB(cb->skb).pid,
1205	cb->nlh->nlmsg_seq,	1204	cb->nlh->nlmsg_seq,
1206	IPCTNL_MSG_EXP_NEW,	1205	IPCTNL_MSG_EXP_NEW,
1207	1, exp) < 0)	1206	1, exp) < 0)
1208	goto out;	1207	goto out;
1209	*id = exp->id;	1208	*id = exp->id;
1210	}	1209	}
1211	out:	1210	out:
1212	read_unlock_bh(&ip_conntrack_lock);	1211	read_unlock_bh(&ip_conntrack_lock);
1213		1212
1214	return skb->len;	1213	return skb->len;
1215	}	1214	}
1216		1215
1217	static const size_t cta_min_exp[CTA_EXPECT_MAX] = {	1216	static const size_t cta_min_exp[CTA_EXPECT_MAX] = {
1218	[CTA_EXPECT_TIMEOUT-1] = sizeof(__be32),	1217	[CTA_EXPECT_TIMEOUT-1] = sizeof(__be32),
1219	[CTA_EXPECT_ID-1] = sizeof(__be32)	1218	[CTA_EXPECT_ID-1] = sizeof(__be32)
1220	};	1219	};
1221		1220
1222	static int	1221	static int
1223	ctnetlink_get_expect(struct sock ctnl, struct sk_buff skb,	1222	ctnetlink_get_expect(struct sock ctnl, struct sk_buff skb,
1224	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	1223	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
1225	{	1224	{
1226	struct ip_conntrack_tuple tuple;	1225	struct ip_conntrack_tuple tuple;
1227	struct ip_conntrack_expect *exp;	1226	struct ip_conntrack_expect *exp;
1228	struct sk_buff *skb2;	1227	struct sk_buff *skb2;
1229	int err = 0;	1228	int err = 0;
1230		1229
1231	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))	1230	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))
1232	return -EINVAL;	1231	return -EINVAL;
1233		1232
1234	if (nlh->nlmsg_flags & NLM_F_DUMP) {	1233	if (nlh->nlmsg_flags & NLM_F_DUMP) {
1235	struct nfgenmsg *msg = NLMSG_DATA(nlh);	1234	struct nfgenmsg *msg = NLMSG_DATA(nlh);
1236	u32 rlen;	1235	u32 rlen;
1237		1236
1238	if (msg->nfgen_family != AF_INET)	1237	if (msg->nfgen_family != AF_INET)
1239	return -EAFNOSUPPORT;	1238	return -EAFNOSUPPORT;
1240		1239
1241	if ((*errp = netlink_dump_start(ctnl, skb, nlh,	1240	if ((*errp = netlink_dump_start(ctnl, skb, nlh,
1242	ctnetlink_exp_dump_table,	1241	ctnetlink_exp_dump_table,
1243	ctnetlink_done)) != 0)	1242	ctnetlink_done)) != 0)
1244	return -EINVAL;	1243	return -EINVAL;
1245	rlen = NLMSG_ALIGN(nlh->nlmsg_len);	1244	rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1246	if (rlen > skb->len)	1245	if (rlen > skb->len)
1247	rlen = skb->len;	1246	rlen = skb->len;
1248	skb_pull(skb, rlen);	1247	skb_pull(skb, rlen);
1249	return 0;	1248	return 0;
1250	}	1249	}
1251		1250
1252	if (cda[CTA_EXPECT_MASTER-1])	1251	if (cda[CTA_EXPECT_MASTER-1])
1253	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_MASTER);	1252	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_MASTER);
1254	else	1253	else
1255	return -EINVAL;	1254	return -EINVAL;
1256		1255
1257	if (err < 0)	1256	if (err < 0)
1258	return err;	1257	return err;
1259		1258
1260	exp = ip_conntrack_expect_find(&tuple);	1259	exp = ip_conntrack_expect_find(&tuple);
1261	if (!exp)	1260	if (!exp)
1262	return -ENOENT;	1261	return -ENOENT;
1263		1262
1264	if (cda[CTA_EXPECT_ID-1]) {	1263	if (cda[CTA_EXPECT_ID-1]) {
1265	__be32 id = (__be32 )NFA_DATA(cda[CTA_EXPECT_ID-1]);	1264	__be32 id = (__be32 )NFA_DATA(cda[CTA_EXPECT_ID-1]);
1266	if (exp->id != ntohl(id)) {	1265	if (exp->id != ntohl(id)) {
1267	ip_conntrack_expect_put(exp);	1266	ip_conntrack_expect_put(exp);
1268	return -ENOENT;	1267	return -ENOENT;
1269	}	1268	}
1270	}	1269	}
1271		1270
1272	err = -ENOMEM;	1271	err = -ENOMEM;
1273	skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);	1272	skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1274	if (!skb2)	1273	if (!skb2)
1275	goto out;	1274	goto out;
1276	NETLINK_CB(skb2).dst_pid = NETLINK_CB(skb).pid;	1275
1277
1278	err = ctnetlink_exp_fill_info(skb2, NETLINK_CB(skb).pid,	1276	err = ctnetlink_exp_fill_info(skb2, NETLINK_CB(skb).pid,
1279	nlh->nlmsg_seq, IPCTNL_MSG_EXP_NEW,	1277	nlh->nlmsg_seq, IPCTNL_MSG_EXP_NEW,
1280	1, exp);	1278	1, exp);
1281	if (err <= 0)	1279	if (err <= 0)
1282	goto free;	1280	goto free;
1283		1281
1284	ip_conntrack_expect_put(exp);	1282	ip_conntrack_expect_put(exp);
1285		1283
1286	return netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);	1284	return netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1287		1285
1288	free:	1286	free:
1289	kfree_skb(skb2);	1287	kfree_skb(skb2);
1290	out:	1288	out:
1291	ip_conntrack_expect_put(exp);	1289	ip_conntrack_expect_put(exp);
1292	return err;	1290	return err;
1293	}	1291	}
1294		1292
1295	static int	1293	static int
1296	ctnetlink_del_expect(struct sock ctnl, struct sk_buff skb,	1294	ctnetlink_del_expect(struct sock ctnl, struct sk_buff skb,
1297	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	1295	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
1298	{	1296	{
1299	struct ip_conntrack_expect exp, tmp;	1297	struct ip_conntrack_expect exp, tmp;
1300	struct ip_conntrack_tuple tuple;	1298	struct ip_conntrack_tuple tuple;
1301	struct ip_conntrack_helper *h;	1299	struct ip_conntrack_helper *h;
1302	int err;	1300	int err;
1303		1301
1304	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))	1302	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))
1305	return -EINVAL;	1303	return -EINVAL;
1306		1304
1307	if (cda[CTA_EXPECT_TUPLE-1]) {	1305	if (cda[CTA_EXPECT_TUPLE-1]) {
1308	/* delete a single expect by tuple */	1306	/* delete a single expect by tuple */
1309	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE);	1307	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE);
1310	if (err < 0)	1308	if (err < 0)
1311	return err;	1309	return err;
1312		1310
1313	/* bump usage count to 2 */	1311	/* bump usage count to 2 */
1314	exp = ip_conntrack_expect_find(&tuple);	1312	exp = ip_conntrack_expect_find(&tuple);
1315	if (!exp)	1313	if (!exp)
1316	return -ENOENT;	1314	return -ENOENT;
1317		1315
1318	if (cda[CTA_EXPECT_ID-1]) {	1316	if (cda[CTA_EXPECT_ID-1]) {
1319	__be32 id =	1317	__be32 id =
1320	(__be32 )NFA_DATA(cda[CTA_EXPECT_ID-1]);	1318	(__be32 )NFA_DATA(cda[CTA_EXPECT_ID-1]);
1321	if (exp->id != ntohl(id)) {	1319	if (exp->id != ntohl(id)) {
1322	ip_conntrack_expect_put(exp);	1320	ip_conntrack_expect_put(exp);
1323	return -ENOENT;	1321	return -ENOENT;
1324	}	1322	}
1325	}	1323	}
1326		1324
1327	/* after list removal, usage count == 1 */	1325	/* after list removal, usage count == 1 */
1328	ip_conntrack_unexpect_related(exp);	1326	ip_conntrack_unexpect_related(exp);
1329	/* have to put what we 'get' above.	1327	/* have to put what we 'get' above.
1330	* after this line usage count == 0 */	1328	* after this line usage count == 0 */
1331	ip_conntrack_expect_put(exp);	1329	ip_conntrack_expect_put(exp);
1332	} else if (cda[CTA_EXPECT_HELP_NAME-1]) {	1330	} else if (cda[CTA_EXPECT_HELP_NAME-1]) {
1333	char *name = NFA_DATA(cda[CTA_EXPECT_HELP_NAME-1]);	1331	char *name = NFA_DATA(cda[CTA_EXPECT_HELP_NAME-1]);
1334		1332
1335	/* delete all expectations for this helper */	1333	/* delete all expectations for this helper */
1336	write_lock_bh(&ip_conntrack_lock);	1334	write_lock_bh(&ip_conntrack_lock);
1337	h = __ip_conntrack_helper_find_byname(name);	1335	h = __ip_conntrack_helper_find_byname(name);
1338	if (!h) {	1336	if (!h) {
1339	write_unlock_bh(&ip_conntrack_lock);	1337	write_unlock_bh(&ip_conntrack_lock);
1340	return -EINVAL;	1338	return -EINVAL;
1341	}	1339	}
1342	list_for_each_entry_safe(exp, tmp, &ip_conntrack_expect_list,	1340	list_for_each_entry_safe(exp, tmp, &ip_conntrack_expect_list,
1343	list) {	1341	list) {
1344	if (exp->master->helper == h	1342	if (exp->master->helper == h
1345	&& del_timer(&exp->timeout)) {	1343	&& del_timer(&exp->timeout)) {
1346	ip_ct_unlink_expect(exp);	1344	ip_ct_unlink_expect(exp);
1347	ip_conntrack_expect_put(exp);	1345	ip_conntrack_expect_put(exp);
1348	}	1346	}
1349	}	1347	}
1350	write_unlock_bh(&ip_conntrack_lock);	1348	write_unlock_bh(&ip_conntrack_lock);
1351	} else {	1349	} else {
1352	/* This basically means we have to flush everything*/	1350	/* This basically means we have to flush everything*/
1353	write_lock_bh(&ip_conntrack_lock);	1351	write_lock_bh(&ip_conntrack_lock);
1354	list_for_each_entry_safe(exp, tmp, &ip_conntrack_expect_list,	1352	list_for_each_entry_safe(exp, tmp, &ip_conntrack_expect_list,
1355	list) {	1353	list) {
1356	if (del_timer(&exp->timeout)) {	1354	if (del_timer(&exp->timeout)) {
1357	ip_ct_unlink_expect(exp);	1355	ip_ct_unlink_expect(exp);
1358	ip_conntrack_expect_put(exp);	1356	ip_conntrack_expect_put(exp);
1359	}	1357	}
1360	}	1358	}
1361	write_unlock_bh(&ip_conntrack_lock);	1359	write_unlock_bh(&ip_conntrack_lock);
1362	}	1360	}
1363		1361
1364	return 0;	1362	return 0;
1365	}	1363	}
1366	static int	1364	static int
1367	ctnetlink_change_expect(struct ip_conntrack_expect x, struct nfattr cda[])	1365	ctnetlink_change_expect(struct ip_conntrack_expect x, struct nfattr cda[])
1368	{	1366	{
1369	return -EOPNOTSUPP;	1367	return -EOPNOTSUPP;
1370	}	1368	}
1371		1369
1372	static int	1370	static int
1373	ctnetlink_create_expect(struct nfattr *cda[])	1371	ctnetlink_create_expect(struct nfattr *cda[])
1374	{	1372	{
1375	struct ip_conntrack_tuple tuple, mask, master_tuple;	1373	struct ip_conntrack_tuple tuple, mask, master_tuple;
1376	struct ip_conntrack_tuple_hash *h = NULL;	1374	struct ip_conntrack_tuple_hash *h = NULL;
1377	struct ip_conntrack_expect *exp;	1375	struct ip_conntrack_expect *exp;
1378	struct ip_conntrack *ct;	1376	struct ip_conntrack *ct;
1379	int err = 0;	1377	int err = 0;
1380		1378
1381	/* caller guarantees that those three CTA_EXPECT_* exist */	1379	/* caller guarantees that those three CTA_EXPECT_* exist */
1382	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE);	1380	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE);
1383	if (err < 0)	1381	if (err < 0)
1384	return err;	1382	return err;
1385	err = ctnetlink_parse_tuple(cda, &mask, CTA_EXPECT_MASK);	1383	err = ctnetlink_parse_tuple(cda, &mask, CTA_EXPECT_MASK);
1386	if (err < 0)	1384	if (err < 0)
1387	return err;	1385	return err;
1388	err = ctnetlink_parse_tuple(cda, &master_tuple, CTA_EXPECT_MASTER);	1386	err = ctnetlink_parse_tuple(cda, &master_tuple, CTA_EXPECT_MASTER);
1389	if (err < 0)	1387	if (err < 0)
1390	return err;	1388	return err;
1391		1389
1392	/* Look for master conntrack of this expectation */	1390	/* Look for master conntrack of this expectation */
1393	h = ip_conntrack_find_get(&master_tuple, NULL);	1391	h = ip_conntrack_find_get(&master_tuple, NULL);
1394	if (!h)	1392	if (!h)
1395	return -ENOENT;	1393	return -ENOENT;
1396	ct = tuplehash_to_ctrack(h);	1394	ct = tuplehash_to_ctrack(h);
1397		1395
1398	if (!ct->helper) {	1396	if (!ct->helper) {
1399	/* such conntrack hasn't got any helper, abort */	1397	/* such conntrack hasn't got any helper, abort */
1400	err = -EINVAL;	1398	err = -EINVAL;
1401	goto out;	1399	goto out;
1402	}	1400	}
1403		1401
1404	exp = ip_conntrack_expect_alloc(ct);	1402	exp = ip_conntrack_expect_alloc(ct);
1405	if (!exp) {	1403	if (!exp) {
1406	err = -ENOMEM;	1404	err = -ENOMEM;
1407	goto out;	1405	goto out;
1408	}	1406	}
1409		1407
1410	exp->expectfn = NULL;	1408	exp->expectfn = NULL;
1411	exp->flags = 0;	1409	exp->flags = 0;
1412	exp->master = ct;	1410	exp->master = ct;
1413	memcpy(&exp->tuple, &tuple, sizeof(struct ip_conntrack_tuple));	1411	memcpy(&exp->tuple, &tuple, sizeof(struct ip_conntrack_tuple));
1414	memcpy(&exp->mask, &mask, sizeof(struct ip_conntrack_tuple));	1412	memcpy(&exp->mask, &mask, sizeof(struct ip_conntrack_tuple));
1415		1413
1416	err = ip_conntrack_expect_related(exp);	1414	err = ip_conntrack_expect_related(exp);
1417	ip_conntrack_expect_put(exp);	1415	ip_conntrack_expect_put(exp);
1418		1416
1419	out:	1417	out:
1420	ip_conntrack_put(tuplehash_to_ctrack(h));	1418	ip_conntrack_put(tuplehash_to_ctrack(h));
1421	return err;	1419	return err;
1422	}	1420	}
1423		1421
1424	static int	1422	static int
1425	ctnetlink_new_expect(struct sock ctnl, struct sk_buff skb,	1423	ctnetlink_new_expect(struct sock ctnl, struct sk_buff skb,
1426	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	1424	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
1427	{	1425	{
1428	struct ip_conntrack_tuple tuple;	1426	struct ip_conntrack_tuple tuple;
1429	struct ip_conntrack_expect *exp;	1427	struct ip_conntrack_expect *exp;
1430	int err = 0;	1428	int err = 0;
1431		1429
1432	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))	1430	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))
1433	return -EINVAL;	1431	return -EINVAL;
1434		1432
1435	if (!cda[CTA_EXPECT_TUPLE-1]	1433	if (!cda[CTA_EXPECT_TUPLE-1]
1436	\|\| !cda[CTA_EXPECT_MASK-1]	1434	\|\| !cda[CTA_EXPECT_MASK-1]
1437	\|\| !cda[CTA_EXPECT_MASTER-1])	1435	\|\| !cda[CTA_EXPECT_MASTER-1])
1438	return -EINVAL;	1436	return -EINVAL;
1439		1437
1440	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE);	1438	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE);
1441	if (err < 0)	1439	if (err < 0)
1442	return err;	1440	return err;
1443		1441
1444	write_lock_bh(&ip_conntrack_lock);	1442	write_lock_bh(&ip_conntrack_lock);
1445	exp = __ip_conntrack_expect_find(&tuple);	1443	exp = __ip_conntrack_expect_find(&tuple);
1446		1444
1447	if (!exp) {	1445	if (!exp) {
1448	write_unlock_bh(&ip_conntrack_lock);	1446	write_unlock_bh(&ip_conntrack_lock);
1449	err = -ENOENT;	1447	err = -ENOENT;
1450	if (nlh->nlmsg_flags & NLM_F_CREATE)	1448	if (nlh->nlmsg_flags & NLM_F_CREATE)
1451	err = ctnetlink_create_expect(cda);	1449	err = ctnetlink_create_expect(cda);
1452	return err;	1450	return err;
1453	}	1451	}
1454		1452
1455	err = -EEXIST;	1453	err = -EEXIST;
1456	if (!(nlh->nlmsg_flags & NLM_F_EXCL))	1454	if (!(nlh->nlmsg_flags & NLM_F_EXCL))
1457	err = ctnetlink_change_expect(exp, cda);	1455	err = ctnetlink_change_expect(exp, cda);
1458	write_unlock_bh(&ip_conntrack_lock);	1456	write_unlock_bh(&ip_conntrack_lock);
1459		1457
1460	return err;	1458	return err;
1461	}	1459	}
1462		1460
1463	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS	1461	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS
1464	static struct notifier_block ctnl_notifier = {	1462	static struct notifier_block ctnl_notifier = {
1465	.notifier_call = ctnetlink_conntrack_event,	1463	.notifier_call = ctnetlink_conntrack_event,
1466	};	1464	};
1467		1465
1468	static struct notifier_block ctnl_notifier_exp = {	1466	static struct notifier_block ctnl_notifier_exp = {
1469	.notifier_call = ctnetlink_expect_event,	1467	.notifier_call = ctnetlink_expect_event,
1470	};	1468	};
1471	#endif	1469	#endif
1472		1470
1473	static struct nfnl_callback ctnl_cb[IPCTNL_MSG_MAX] = {	1471	static struct nfnl_callback ctnl_cb[IPCTNL_MSG_MAX] = {
1474	[IPCTNL_MSG_CT_NEW] = { .call = ctnetlink_new_conntrack,	1472	[IPCTNL_MSG_CT_NEW] = { .call = ctnetlink_new_conntrack,
1475	.attr_count = CTA_MAX, },	1473	.attr_count = CTA_MAX, },
1476	[IPCTNL_MSG_CT_GET] = { .call = ctnetlink_get_conntrack,	1474	[IPCTNL_MSG_CT_GET] = { .call = ctnetlink_get_conntrack,
1477	.attr_count = CTA_MAX, },	1475	.attr_count = CTA_MAX, },
1478	[IPCTNL_MSG_CT_DELETE] = { .call = ctnetlink_del_conntrack,	1476	[IPCTNL_MSG_CT_DELETE] = { .call = ctnetlink_del_conntrack,
1479	.attr_count = CTA_MAX, },	1477	.attr_count = CTA_MAX, },
1480	[IPCTNL_MSG_CT_GET_CTRZERO] = { .call = ctnetlink_get_conntrack,	1478	[IPCTNL_MSG_CT_GET_CTRZERO] = { .call = ctnetlink_get_conntrack,
1481	.attr_count = CTA_MAX, },	1479	.attr_count = CTA_MAX, },
1482	};	1480	};
1483		1481
1484	static struct nfnl_callback ctnl_exp_cb[IPCTNL_MSG_EXP_MAX] = {	1482	static struct nfnl_callback ctnl_exp_cb[IPCTNL_MSG_EXP_MAX] = {
1485	[IPCTNL_MSG_EXP_GET] = { .call = ctnetlink_get_expect,	1483	[IPCTNL_MSG_EXP_GET] = { .call = ctnetlink_get_expect,
1486	.attr_count = CTA_EXPECT_MAX, },	1484	.attr_count = CTA_EXPECT_MAX, },
1487	[IPCTNL_MSG_EXP_NEW] = { .call = ctnetlink_new_expect,	1485	[IPCTNL_MSG_EXP_NEW] = { .call = ctnetlink_new_expect,
1488	.attr_count = CTA_EXPECT_MAX, },	1486	.attr_count = CTA_EXPECT_MAX, },
1489	[IPCTNL_MSG_EXP_DELETE] = { .call = ctnetlink_del_expect,	1487	[IPCTNL_MSG_EXP_DELETE] = { .call = ctnetlink_del_expect,
1490	.attr_count = CTA_EXPECT_MAX, },	1488	.attr_count = CTA_EXPECT_MAX, },
1491	};	1489	};
1492		1490
1493	static struct nfnetlink_subsystem ctnl_subsys = {	1491	static struct nfnetlink_subsystem ctnl_subsys = {
1494	.name = "conntrack",	1492	.name = "conntrack",
1495	.subsys_id = NFNL_SUBSYS_CTNETLINK,	1493	.subsys_id = NFNL_SUBSYS_CTNETLINK,
1496	.cb_count = IPCTNL_MSG_MAX,	1494	.cb_count = IPCTNL_MSG_MAX,
1497	.cb = ctnl_cb,	1495	.cb = ctnl_cb,
1498	};	1496	};
1499		1497
1500	static struct nfnetlink_subsystem ctnl_exp_subsys = {	1498	static struct nfnetlink_subsystem ctnl_exp_subsys = {
1501	.name = "conntrack_expect",	1499	.name = "conntrack_expect",
1502	.subsys_id = NFNL_SUBSYS_CTNETLINK_EXP,	1500	.subsys_id = NFNL_SUBSYS_CTNETLINK_EXP,
1503	.cb_count = IPCTNL_MSG_EXP_MAX,	1501	.cb_count = IPCTNL_MSG_EXP_MAX,
1504	.cb = ctnl_exp_cb,	1502	.cb = ctnl_exp_cb,
1505	};	1503	};
1506		1504
1507	MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK);	1505	MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK);
1508	MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK_EXP);	1506	MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK_EXP);
1509		1507
1510	static int __init ctnetlink_init(void)	1508	static int __init ctnetlink_init(void)
1511	{	1509	{
1512	int ret;	1510	int ret;
1513		1511
1514	printk("ctnetlink v%s: registering with nfnetlink.\n", version);	1512	printk("ctnetlink v%s: registering with nfnetlink.\n", version);
1515	ret = nfnetlink_subsys_register(&ctnl_subsys);	1513	ret = nfnetlink_subsys_register(&ctnl_subsys);
1516	if (ret < 0) {	1514	if (ret < 0) {
1517	printk("ctnetlink_init: cannot register with nfnetlink.\n");	1515	printk("ctnetlink_init: cannot register with nfnetlink.\n");
1518	goto err_out;	1516	goto err_out;
1519	}	1517	}
1520		1518
1521	ret = nfnetlink_subsys_register(&ctnl_exp_subsys);	1519	ret = nfnetlink_subsys_register(&ctnl_exp_subsys);
1522	if (ret < 0) {	1520	if (ret < 0) {
1523	printk("ctnetlink_init: cannot register exp with nfnetlink.\n");	1521	printk("ctnetlink_init: cannot register exp with nfnetlink.\n");
1524	goto err_unreg_subsys;	1522	goto err_unreg_subsys;
1525	}	1523	}
1526		1524
1527	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS	1525	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS
1528	ret = ip_conntrack_register_notifier(&ctnl_notifier);	1526	ret = ip_conntrack_register_notifier(&ctnl_notifier);
1529	if (ret < 0) {	1527	if (ret < 0) {
1530	printk("ctnetlink_init: cannot register notifier.\n");	1528	printk("ctnetlink_init: cannot register notifier.\n");
1531	goto err_unreg_exp_subsys;	1529	goto err_unreg_exp_subsys;
1532	}	1530	}
1533		1531
1534	ret = ip_conntrack_expect_register_notifier(&ctnl_notifier_exp);	1532	ret = ip_conntrack_expect_register_notifier(&ctnl_notifier_exp);
1535	if (ret < 0) {	1533	if (ret < 0) {
1536	printk("ctnetlink_init: cannot expect register notifier.\n");	1534	printk("ctnetlink_init: cannot expect register notifier.\n");
1537	goto err_unreg_notifier;	1535	goto err_unreg_notifier;
1538	}	1536	}
1539	#endif	1537	#endif
1540		1538
1541	return 0;	1539	return 0;
1542		1540
1543	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS	1541	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS
1544	err_unreg_notifier:	1542	err_unreg_notifier:
1545	ip_conntrack_unregister_notifier(&ctnl_notifier);	1543	ip_conntrack_unregister_notifier(&ctnl_notifier);
1546	err_unreg_exp_subsys:	1544	err_unreg_exp_subsys:
1547	nfnetlink_subsys_unregister(&ctnl_exp_subsys);	1545	nfnetlink_subsys_unregister(&ctnl_exp_subsys);
1548	#endif	1546	#endif
1549	err_unreg_subsys:	1547	err_unreg_subsys:
1550	nfnetlink_subsys_unregister(&ctnl_subsys);	1548	nfnetlink_subsys_unregister(&ctnl_subsys);
1551	err_out:	1549	err_out:
1552	return ret;	1550	return ret;
1553	}	1551	}
1554		1552
1555	static void __exit ctnetlink_exit(void)	1553	static void __exit ctnetlink_exit(void)
1556	{	1554	{
1557	printk("ctnetlink: unregistering from nfnetlink.\n");	1555	printk("ctnetlink: unregistering from nfnetlink.\n");
1558		1556
1559	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS	1557	#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS
1560	ip_conntrack_expect_unregister_notifier(&ctnl_notifier_exp);	1558	ip_conntrack_expect_unregister_notifier(&ctnl_notifier_exp);
1561	ip_conntrack_unregister_notifier(&ctnl_notifier);	1559	ip_conntrack_unregister_notifier(&ctnl_notifier);
1562	#endif	1560	#endif
1563		1561
1564	nfnetlink_subsys_unregister(&ctnl_exp_subsys);	1562	nfnetlink_subsys_unregister(&ctnl_exp_subsys);
1565	nfnetlink_subsys_unregister(&ctnl_subsys);	1563	nfnetlink_subsys_unregister(&ctnl_subsys);
1566	return;	1564	return;
1567	}	1565	}
1568		1566
1569	module_init(ctnetlink_init);	1567	module_init(ctnetlink_init);
1570	module_exit(ctnetlink_exit);	1568	module_exit(ctnetlink_exit);
1571		1569

net/netfilter/nf_conntrack_netlink.c

Diff comments View file @ 4e9b826

1	/* Connection tracking via netlink socket. Allows for user space	1	/* Connection tracking via netlink socket. Allows for user space
2	* protocol helpers and general trouble making from userspace.	2	* protocol helpers and general trouble making from userspace.
3	*	3	*
4	* (C) 2001 by Jay Schulist <jschlst@samba.org>	4	* (C) 2001 by Jay Schulist <jschlst@samba.org>
5	* (C) 2002-2006 by Harald Welte <laforge@gnumonks.org>	5	* (C) 2002-2006 by Harald Welte <laforge@gnumonks.org>
6	* (C) 2003 by Patrick Mchardy <kaber@trash.net>	6	* (C) 2003 by Patrick Mchardy <kaber@trash.net>
7	* (C) 2005-2006 by Pablo Neira Ayuso <pablo@eurodev.net>	7	* (C) 2005-2006 by Pablo Neira Ayuso <pablo@eurodev.net>
8	*	8	*
9	* I've reworked this stuff to use attributes instead of conntrack	9	* I've reworked this stuff to use attributes instead of conntrack
10	* structures. 5.44 am. I need more tea. --pablo 05/07/11.	10	* structures. 5.44 am. I need more tea. --pablo 05/07/11.
11	*	11	*
12	* Initial connection tracking via netlink development funded and	12	* Initial connection tracking via netlink development funded and
13	* generally made possible by Network Robots, Inc. (www.networkrobots.com)	13	* generally made possible by Network Robots, Inc. (www.networkrobots.com)
14	*	14	*
15	* Further development of this code funded by Astaro AG (http://www.astaro.com)	15	* Further development of this code funded by Astaro AG (http://www.astaro.com)
16	*	16	*
17	* This software may be used and distributed according to the terms	17	* This software may be used and distributed according to the terms
18	* of the GNU General Public License, incorporated herein by reference.	18	* of the GNU General Public License, incorporated herein by reference.
19	*	19	*
20	* Derived from ip_conntrack_netlink.c: Port by Pablo Neira Ayuso (05/11/14)	20	* Derived from ip_conntrack_netlink.c: Port by Pablo Neira Ayuso (05/11/14)
21	*/	21	*/
22		22
23	#include <linux/init.h>	23	#include <linux/init.h>
24	#include <linux/module.h>	24	#include <linux/module.h>
25	#include <linux/kernel.h>	25	#include <linux/kernel.h>
26	#include <linux/types.h>	26	#include <linux/types.h>
27	#include <linux/timer.h>	27	#include <linux/timer.h>
28	#include <linux/skbuff.h>	28	#include <linux/skbuff.h>
29	#include <linux/errno.h>	29	#include <linux/errno.h>
30	#include <linux/netlink.h>	30	#include <linux/netlink.h>
31	#include <linux/spinlock.h>	31	#include <linux/spinlock.h>
32	#include <linux/interrupt.h>	32	#include <linux/interrupt.h>
33	#include <linux/notifier.h>	33	#include <linux/notifier.h>
34		34
35	#include <linux/netfilter.h>	35	#include <linux/netfilter.h>
36	#include <net/netfilter/nf_conntrack.h>	36	#include <net/netfilter/nf_conntrack.h>
37	#include <net/netfilter/nf_conntrack_core.h>	37	#include <net/netfilter/nf_conntrack_core.h>
38	#include <net/netfilter/nf_conntrack_helper.h>	38	#include <net/netfilter/nf_conntrack_helper.h>
39	#include <net/netfilter/nf_conntrack_l3proto.h>	39	#include <net/netfilter/nf_conntrack_l3proto.h>
40	#include <net/netfilter/nf_conntrack_protocol.h>	40	#include <net/netfilter/nf_conntrack_protocol.h>
41	#include <linux/netfilter_ipv4/ip_nat_protocol.h>	41	#include <linux/netfilter_ipv4/ip_nat_protocol.h>
42		42
43	#include <linux/netfilter/nfnetlink.h>	43	#include <linux/netfilter/nfnetlink.h>
44	#include <linux/netfilter/nfnetlink_conntrack.h>	44	#include <linux/netfilter/nfnetlink_conntrack.h>
45		45
46	MODULE_LICENSE("GPL");	46	MODULE_LICENSE("GPL");
47		47
48	static char __initdata version[] = "0.93";	48	static char __initdata version[] = "0.93";
49		49
50	static inline int	50	static inline int
51	ctnetlink_dump_tuples_proto(struct sk_buff *skb,	51	ctnetlink_dump_tuples_proto(struct sk_buff *skb,
52	const struct nf_conntrack_tuple *tuple,	52	const struct nf_conntrack_tuple *tuple,
53	struct nf_conntrack_protocol *proto)	53	struct nf_conntrack_protocol *proto)
54	{	54	{
55	int ret = 0;	55	int ret = 0;
56	struct nfattr *nest_parms = NFA_NEST(skb, CTA_TUPLE_PROTO);	56	struct nfattr *nest_parms = NFA_NEST(skb, CTA_TUPLE_PROTO);
57		57
58	NFA_PUT(skb, CTA_PROTO_NUM, sizeof(u_int8_t), &tuple->dst.protonum);	58	NFA_PUT(skb, CTA_PROTO_NUM, sizeof(u_int8_t), &tuple->dst.protonum);
59		59
60	if (likely(proto->tuple_to_nfattr))	60	if (likely(proto->tuple_to_nfattr))
61	ret = proto->tuple_to_nfattr(skb, tuple);	61	ret = proto->tuple_to_nfattr(skb, tuple);
62		62
63	NFA_NEST_END(skb, nest_parms);	63	NFA_NEST_END(skb, nest_parms);
64		64
65	return ret;	65	return ret;
66		66
67	nfattr_failure:	67	nfattr_failure:
68	return -1;	68	return -1;
69	}	69	}
70		70
71	static inline int	71	static inline int
72	ctnetlink_dump_tuples_ip(struct sk_buff *skb,	72	ctnetlink_dump_tuples_ip(struct sk_buff *skb,
73	const struct nf_conntrack_tuple *tuple,	73	const struct nf_conntrack_tuple *tuple,
74	struct nf_conntrack_l3proto *l3proto)	74	struct nf_conntrack_l3proto *l3proto)
75	{	75	{
76	int ret = 0;	76	int ret = 0;
77	struct nfattr *nest_parms = NFA_NEST(skb, CTA_TUPLE_IP);	77	struct nfattr *nest_parms = NFA_NEST(skb, CTA_TUPLE_IP);
78		78
79	if (likely(l3proto->tuple_to_nfattr))	79	if (likely(l3proto->tuple_to_nfattr))
80	ret = l3proto->tuple_to_nfattr(skb, tuple);	80	ret = l3proto->tuple_to_nfattr(skb, tuple);
81		81
82	NFA_NEST_END(skb, nest_parms);	82	NFA_NEST_END(skb, nest_parms);
83		83
84	return ret;	84	return ret;
85		85
86	nfattr_failure:	86	nfattr_failure:
87	return -1;	87	return -1;
88	}	88	}
89		89
90	static inline int	90	static inline int
91	ctnetlink_dump_tuples(struct sk_buff *skb,	91	ctnetlink_dump_tuples(struct sk_buff *skb,
92	const struct nf_conntrack_tuple *tuple)	92	const struct nf_conntrack_tuple *tuple)
93	{	93	{
94	int ret;	94	int ret;
95	struct nf_conntrack_l3proto *l3proto;	95	struct nf_conntrack_l3proto *l3proto;
96	struct nf_conntrack_protocol *proto;	96	struct nf_conntrack_protocol *proto;
97		97
98	l3proto = nf_ct_l3proto_find_get(tuple->src.l3num);	98	l3proto = nf_ct_l3proto_find_get(tuple->src.l3num);
99	ret = ctnetlink_dump_tuples_ip(skb, tuple, l3proto);	99	ret = ctnetlink_dump_tuples_ip(skb, tuple, l3proto);
100	nf_ct_l3proto_put(l3proto);	100	nf_ct_l3proto_put(l3proto);
101		101
102	if (unlikely(ret < 0))	102	if (unlikely(ret < 0))
103	return ret;	103	return ret;
104		104
105	proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum);	105	proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum);
106	ret = ctnetlink_dump_tuples_proto(skb, tuple, proto);	106	ret = ctnetlink_dump_tuples_proto(skb, tuple, proto);
107	nf_ct_proto_put(proto);	107	nf_ct_proto_put(proto);
108		108
109	return ret;	109	return ret;
110	}	110	}
111		111
112	static inline int	112	static inline int
113	ctnetlink_dump_status(struct sk_buff skb, const struct nf_conn ct)	113	ctnetlink_dump_status(struct sk_buff skb, const struct nf_conn ct)
114	{	114	{
115	u_int32_t status = htonl((u_int32_t) ct->status);	115	u_int32_t status = htonl((u_int32_t) ct->status);
116	NFA_PUT(skb, CTA_STATUS, sizeof(status), &status);	116	NFA_PUT(skb, CTA_STATUS, sizeof(status), &status);
117	return 0;	117	return 0;
118		118
119	nfattr_failure:	119	nfattr_failure:
120	return -1;	120	return -1;
121	}	121	}
122		122
123	static inline int	123	static inline int
124	ctnetlink_dump_timeout(struct sk_buff skb, const struct nf_conn ct)	124	ctnetlink_dump_timeout(struct sk_buff skb, const struct nf_conn ct)
125	{	125	{
126	long timeout_l = ct->timeout.expires - jiffies;	126	long timeout_l = ct->timeout.expires - jiffies;
127	u_int32_t timeout;	127	u_int32_t timeout;
128		128
129	if (timeout_l < 0)	129	if (timeout_l < 0)
130	timeout = 0;	130	timeout = 0;
131	else	131	else
132	timeout = htonl(timeout_l / HZ);	132	timeout = htonl(timeout_l / HZ);
133		133
134	NFA_PUT(skb, CTA_TIMEOUT, sizeof(timeout), &timeout);	134	NFA_PUT(skb, CTA_TIMEOUT, sizeof(timeout), &timeout);
135	return 0;	135	return 0;
136		136
137	nfattr_failure:	137	nfattr_failure:
138	return -1;	138	return -1;
139	}	139	}
140		140
141	static inline int	141	static inline int
142	ctnetlink_dump_protoinfo(struct sk_buff skb, const struct nf_conn ct)	142	ctnetlink_dump_protoinfo(struct sk_buff skb, const struct nf_conn ct)
143	{	143	{
144	struct nf_conntrack_protocol *proto = nf_ct_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num, ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum);	144	struct nf_conntrack_protocol *proto = nf_ct_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num, ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum);
145	struct nfattr *nest_proto;	145	struct nfattr *nest_proto;
146	int ret;	146	int ret;
147		147
148	if (!proto->to_nfattr) {	148	if (!proto->to_nfattr) {
149	nf_ct_proto_put(proto);	149	nf_ct_proto_put(proto);
150	return 0;	150	return 0;
151	}	151	}
152		152
153	nest_proto = NFA_NEST(skb, CTA_PROTOINFO);	153	nest_proto = NFA_NEST(skb, CTA_PROTOINFO);
154		154
155	ret = proto->to_nfattr(skb, nest_proto, ct);	155	ret = proto->to_nfattr(skb, nest_proto, ct);
156		156
157	nf_ct_proto_put(proto);	157	nf_ct_proto_put(proto);
158		158
159	NFA_NEST_END(skb, nest_proto);	159	NFA_NEST_END(skb, nest_proto);
160		160
161	return ret;	161	return ret;
162		162
163	nfattr_failure:	163	nfattr_failure:
164	nf_ct_proto_put(proto);	164	nf_ct_proto_put(proto);
165	return -1;	165	return -1;
166	}	166	}
167		167
168	static inline int	168	static inline int
169	ctnetlink_dump_helpinfo(struct sk_buff skb, const struct nf_conn ct)	169	ctnetlink_dump_helpinfo(struct sk_buff skb, const struct nf_conn ct)
170	{	170	{
171	struct nfattr *nest_helper;	171	struct nfattr *nest_helper;
172	const struct nf_conn_help *help = nfct_help(ct);	172	const struct nf_conn_help *help = nfct_help(ct);
173		173
174	if (!help \|\| !help->helper)	174	if (!help \|\| !help->helper)
175	return 0;	175	return 0;
176		176
177	nest_helper = NFA_NEST(skb, CTA_HELP);	177	nest_helper = NFA_NEST(skb, CTA_HELP);
178	NFA_PUT(skb, CTA_HELP_NAME, strlen(help->helper->name), help->helper->name);	178	NFA_PUT(skb, CTA_HELP_NAME, strlen(help->helper->name), help->helper->name);
179		179
180	if (help->helper->to_nfattr)	180	if (help->helper->to_nfattr)
181	help->helper->to_nfattr(skb, ct);	181	help->helper->to_nfattr(skb, ct);
182		182
183	NFA_NEST_END(skb, nest_helper);	183	NFA_NEST_END(skb, nest_helper);
184		184
185	return 0;	185	return 0;
186		186
187	nfattr_failure:	187	nfattr_failure:
188	return -1;	188	return -1;
189	}	189	}
190		190
191	#ifdef CONFIG_NF_CT_ACCT	191	#ifdef CONFIG_NF_CT_ACCT
192	static inline int	192	static inline int
193	ctnetlink_dump_counters(struct sk_buff skb, const struct nf_conn ct,	193	ctnetlink_dump_counters(struct sk_buff skb, const struct nf_conn ct,
194	enum ip_conntrack_dir dir)	194	enum ip_conntrack_dir dir)
195	{	195	{
196	enum ctattr_type type = dir ? CTA_COUNTERS_REPLY: CTA_COUNTERS_ORIG;	196	enum ctattr_type type = dir ? CTA_COUNTERS_REPLY: CTA_COUNTERS_ORIG;
197	struct nfattr *nest_count = NFA_NEST(skb, type);	197	struct nfattr *nest_count = NFA_NEST(skb, type);
198	u_int32_t tmp;	198	u_int32_t tmp;
199		199
200	tmp = htonl(ct->counters[dir].packets);	200	tmp = htonl(ct->counters[dir].packets);
201	NFA_PUT(skb, CTA_COUNTERS32_PACKETS, sizeof(u_int32_t), &tmp);	201	NFA_PUT(skb, CTA_COUNTERS32_PACKETS, sizeof(u_int32_t), &tmp);
202		202
203	tmp = htonl(ct->counters[dir].bytes);	203	tmp = htonl(ct->counters[dir].bytes);
204	NFA_PUT(skb, CTA_COUNTERS32_BYTES, sizeof(u_int32_t), &tmp);	204	NFA_PUT(skb, CTA_COUNTERS32_BYTES, sizeof(u_int32_t), &tmp);
205		205
206	NFA_NEST_END(skb, nest_count);	206	NFA_NEST_END(skb, nest_count);
207		207
208	return 0;	208	return 0;
209		209
210	nfattr_failure:	210	nfattr_failure:
211	return -1;	211	return -1;
212	}	212	}
213	#else	213	#else
214	#define ctnetlink_dump_counters(a, b, c) (0)	214	#define ctnetlink_dump_counters(a, b, c) (0)
215	#endif	215	#endif
216		216
217	#ifdef CONFIG_NF_CONNTRACK_MARK	217	#ifdef CONFIG_NF_CONNTRACK_MARK
218	static inline int	218	static inline int
219	ctnetlink_dump_mark(struct sk_buff skb, const struct nf_conn ct)	219	ctnetlink_dump_mark(struct sk_buff skb, const struct nf_conn ct)
220	{	220	{
221	u_int32_t mark = htonl(ct->mark);	221	u_int32_t mark = htonl(ct->mark);
222		222
223	NFA_PUT(skb, CTA_MARK, sizeof(u_int32_t), &mark);	223	NFA_PUT(skb, CTA_MARK, sizeof(u_int32_t), &mark);
224	return 0;	224	return 0;
225		225
226	nfattr_failure:	226	nfattr_failure:
227	return -1;	227	return -1;
228	}	228	}
229	#else	229	#else
230	#define ctnetlink_dump_mark(a, b) (0)	230	#define ctnetlink_dump_mark(a, b) (0)
231	#endif	231	#endif
232		232
233	static inline int	233	static inline int
234	ctnetlink_dump_id(struct sk_buff skb, const struct nf_conn ct)	234	ctnetlink_dump_id(struct sk_buff skb, const struct nf_conn ct)
235	{	235	{
236	u_int32_t id = htonl(ct->id);	236	u_int32_t id = htonl(ct->id);
237	NFA_PUT(skb, CTA_ID, sizeof(u_int32_t), &id);	237	NFA_PUT(skb, CTA_ID, sizeof(u_int32_t), &id);
238	return 0;	238	return 0;
239		239
240	nfattr_failure:	240	nfattr_failure:
241	return -1;	241	return -1;
242	}	242	}
243		243
244	static inline int	244	static inline int
245	ctnetlink_dump_use(struct sk_buff skb, const struct nf_conn ct)	245	ctnetlink_dump_use(struct sk_buff skb, const struct nf_conn ct)
246	{	246	{
247	u_int32_t use = htonl(atomic_read(&ct->ct_general.use));	247	u_int32_t use = htonl(atomic_read(&ct->ct_general.use));
248		248
249	NFA_PUT(skb, CTA_USE, sizeof(u_int32_t), &use);	249	NFA_PUT(skb, CTA_USE, sizeof(u_int32_t), &use);
250	return 0;	250	return 0;
251		251
252	nfattr_failure:	252	nfattr_failure:
253	return -1;	253	return -1;
254	}	254	}
255		255
256	#define tuple(ct, dir) (&(ct)->tuplehash[dir].tuple)	256	#define tuple(ct, dir) (&(ct)->tuplehash[dir].tuple)
257		257
258	static int	258	static int
259	ctnetlink_fill_info(struct sk_buff *skb, u32 pid, u32 seq,	259	ctnetlink_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
260	int event, int nowait,	260	int event, int nowait,
261	const struct nf_conn *ct)	261	const struct nf_conn *ct)
262	{	262	{
263	struct nlmsghdr *nlh;	263	struct nlmsghdr *nlh;
264	struct nfgenmsg *nfmsg;	264	struct nfgenmsg *nfmsg;
265	struct nfattr *nest_parms;	265	struct nfattr *nest_parms;
266	unsigned char *b;	266	unsigned char *b;
267		267
268	b = skb->tail;	268	b = skb->tail;
269		269
270	event \|= NFNL_SUBSYS_CTNETLINK << 8;	270	event \|= NFNL_SUBSYS_CTNETLINK << 8;
271	nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));	271	nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));
272	nfmsg = NLMSG_DATA(nlh);	272	nfmsg = NLMSG_DATA(nlh);
273		273
274	nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0;	274	nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0;
275	nfmsg->nfgen_family =	275	nfmsg->nfgen_family =
276	ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num;	276	ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num;
277	nfmsg->version = NFNETLINK_V0;	277	nfmsg->version = NFNETLINK_V0;
278	nfmsg->res_id = 0;	278	nfmsg->res_id = 0;
279		279
280	nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG);	280	nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG);
281	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)	281	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)
282	goto nfattr_failure;	282	goto nfattr_failure;
283	NFA_NEST_END(skb, nest_parms);	283	NFA_NEST_END(skb, nest_parms);
284		284
285	nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY);	285	nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY);
286	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)	286	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)
287	goto nfattr_failure;	287	goto nfattr_failure;
288	NFA_NEST_END(skb, nest_parms);	288	NFA_NEST_END(skb, nest_parms);
289		289
290	if (ctnetlink_dump_status(skb, ct) < 0 \|\|	290	if (ctnetlink_dump_status(skb, ct) < 0 \|\|
291	ctnetlink_dump_timeout(skb, ct) < 0 \|\|	291	ctnetlink_dump_timeout(skb, ct) < 0 \|\|
292	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 \|\|	292	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 \|\|
293	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0 \|\|	293	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0 \|\|
294	ctnetlink_dump_protoinfo(skb, ct) < 0 \|\|	294	ctnetlink_dump_protoinfo(skb, ct) < 0 \|\|
295	ctnetlink_dump_helpinfo(skb, ct) < 0 \|\|	295	ctnetlink_dump_helpinfo(skb, ct) < 0 \|\|
296	ctnetlink_dump_mark(skb, ct) < 0 \|\|	296	ctnetlink_dump_mark(skb, ct) < 0 \|\|
297	ctnetlink_dump_id(skb, ct) < 0 \|\|	297	ctnetlink_dump_id(skb, ct) < 0 \|\|
298	ctnetlink_dump_use(skb, ct) < 0)	298	ctnetlink_dump_use(skb, ct) < 0)
299	goto nfattr_failure;	299	goto nfattr_failure;
300		300
301	nlh->nlmsg_len = skb->tail - b;	301	nlh->nlmsg_len = skb->tail - b;
302	return skb->len;	302	return skb->len;
303		303
304	nlmsg_failure:	304	nlmsg_failure:
305	nfattr_failure:	305	nfattr_failure:
306	skb_trim(skb, b - skb->data);	306	skb_trim(skb, b - skb->data);
307	return -1;	307	return -1;
308	}	308	}
309		309
310	#ifdef CONFIG_NF_CONNTRACK_EVENTS	310	#ifdef CONFIG_NF_CONNTRACK_EVENTS
311	static int ctnetlink_conntrack_event(struct notifier_block *this,	311	static int ctnetlink_conntrack_event(struct notifier_block *this,
312	unsigned long events, void *ptr)	312	unsigned long events, void *ptr)
313	{	313	{
314	struct nlmsghdr *nlh;	314	struct nlmsghdr *nlh;
315	struct nfgenmsg *nfmsg;	315	struct nfgenmsg *nfmsg;
316	struct nfattr *nest_parms;	316	struct nfattr *nest_parms;
317	struct nf_conn ct = (struct nf_conn )ptr;	317	struct nf_conn ct = (struct nf_conn )ptr;
318	struct sk_buff *skb;	318	struct sk_buff *skb;
319	unsigned int type;	319	unsigned int type;
320	unsigned char *b;	320	unsigned char *b;
321	unsigned int flags = 0, group;	321	unsigned int flags = 0, group;
322		322
323	/* ignore our fake conntrack entry */	323	/* ignore our fake conntrack entry */
324	if (ct == &nf_conntrack_untracked)	324	if (ct == &nf_conntrack_untracked)
325	return NOTIFY_DONE;	325	return NOTIFY_DONE;
326		326
327	if (events & IPCT_DESTROY) {	327	if (events & IPCT_DESTROY) {
328	type = IPCTNL_MSG_CT_DELETE;	328	type = IPCTNL_MSG_CT_DELETE;
329	group = NFNLGRP_CONNTRACK_DESTROY;	329	group = NFNLGRP_CONNTRACK_DESTROY;
330	} else if (events & (IPCT_NEW \| IPCT_RELATED)) {	330	} else if (events & (IPCT_NEW \| IPCT_RELATED)) {
331	type = IPCTNL_MSG_CT_NEW;	331	type = IPCTNL_MSG_CT_NEW;
332	flags = NLM_F_CREATE\|NLM_F_EXCL;	332	flags = NLM_F_CREATE\|NLM_F_EXCL;
333	/* dump everything */	333	/* dump everything */
334	events = ~0UL;	334	events = ~0UL;
335	group = NFNLGRP_CONNTRACK_NEW;	335	group = NFNLGRP_CONNTRACK_NEW;
336	} else if (events & (IPCT_STATUS \| IPCT_PROTOINFO)) {	336	} else if (events & (IPCT_STATUS \| IPCT_PROTOINFO)) {
337	type = IPCTNL_MSG_CT_NEW;	337	type = IPCTNL_MSG_CT_NEW;
338	group = NFNLGRP_CONNTRACK_UPDATE;	338	group = NFNLGRP_CONNTRACK_UPDATE;
339	} else	339	} else
340	return NOTIFY_DONE;	340	return NOTIFY_DONE;
341		341
342	if (!nfnetlink_has_listeners(group))	342	if (!nfnetlink_has_listeners(group))
343	return NOTIFY_DONE;	343	return NOTIFY_DONE;
344		344
345	skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);	345	skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
346	if (!skb)	346	if (!skb)
347	return NOTIFY_DONE;	347	return NOTIFY_DONE;
348		348
349	b = skb->tail;	349	b = skb->tail;
350		350
351	type \|= NFNL_SUBSYS_CTNETLINK << 8;	351	type \|= NFNL_SUBSYS_CTNETLINK << 8;
352	nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg));	352	nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg));
353	nfmsg = NLMSG_DATA(nlh);	353	nfmsg = NLMSG_DATA(nlh);
354		354
355	nlh->nlmsg_flags = flags;	355	nlh->nlmsg_flags = flags;
356	nfmsg->nfgen_family = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num;	356	nfmsg->nfgen_family = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num;
357	nfmsg->version = NFNETLINK_V0;	357	nfmsg->version = NFNETLINK_V0;
358	nfmsg->res_id = 0;	358	nfmsg->res_id = 0;
359		359
360	nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG);	360	nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG);
361	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)	361	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0)
362	goto nfattr_failure;	362	goto nfattr_failure;
363	NFA_NEST_END(skb, nest_parms);	363	NFA_NEST_END(skb, nest_parms);
364		364
365	nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY);	365	nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY);
366	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)	366	if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0)
367	goto nfattr_failure;	367	goto nfattr_failure;
368	NFA_NEST_END(skb, nest_parms);	368	NFA_NEST_END(skb, nest_parms);
369		369
370	/* NAT stuff is now a status flag */	370	/* NAT stuff is now a status flag */
371	if ((events & IPCT_STATUS \|\| events & IPCT_NATINFO)	371	if ((events & IPCT_STATUS \|\| events & IPCT_NATINFO)
372	&& ctnetlink_dump_status(skb, ct) < 0)	372	&& ctnetlink_dump_status(skb, ct) < 0)
373	goto nfattr_failure;	373	goto nfattr_failure;
374	if (events & IPCT_REFRESH	374	if (events & IPCT_REFRESH
375	&& ctnetlink_dump_timeout(skb, ct) < 0)	375	&& ctnetlink_dump_timeout(skb, ct) < 0)
376	goto nfattr_failure;	376	goto nfattr_failure;
377	if (events & IPCT_PROTOINFO	377	if (events & IPCT_PROTOINFO
378	&& ctnetlink_dump_protoinfo(skb, ct) < 0)	378	&& ctnetlink_dump_protoinfo(skb, ct) < 0)
379	goto nfattr_failure;	379	goto nfattr_failure;
380	if (events & IPCT_HELPINFO	380	if (events & IPCT_HELPINFO
381	&& ctnetlink_dump_helpinfo(skb, ct) < 0)	381	&& ctnetlink_dump_helpinfo(skb, ct) < 0)
382	goto nfattr_failure;	382	goto nfattr_failure;
383		383
384	if (ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 \|\|	384	if (ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 \|\|
385	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0)	385	ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0)
386	goto nfattr_failure;	386	goto nfattr_failure;
387		387
388	if (events & IPCT_MARK	388	if (events & IPCT_MARK
389	&& ctnetlink_dump_mark(skb, ct) < 0)	389	&& ctnetlink_dump_mark(skb, ct) < 0)
390	goto nfattr_failure;	390	goto nfattr_failure;
391		391
392	nlh->nlmsg_len = skb->tail - b;	392	nlh->nlmsg_len = skb->tail - b;
393	nfnetlink_send(skb, 0, group, 0);	393	nfnetlink_send(skb, 0, group, 0);
394	return NOTIFY_DONE;	394	return NOTIFY_DONE;
395		395
396	nlmsg_failure:	396	nlmsg_failure:
397	nfattr_failure:	397	nfattr_failure:
398	kfree_skb(skb);	398	kfree_skb(skb);
399	return NOTIFY_DONE;	399	return NOTIFY_DONE;
400	}	400	}
401	#endif /* CONFIG_NF_CONNTRACK_EVENTS */	401	#endif /* CONFIG_NF_CONNTRACK_EVENTS */
402		402
403	static int ctnetlink_done(struct netlink_callback *cb)	403	static int ctnetlink_done(struct netlink_callback *cb)
404	{	404	{
405	if (cb->args[1])	405	if (cb->args[1])
406	nf_ct_put((struct nf_conn *)cb->args[1]);	406	nf_ct_put((struct nf_conn *)cb->args[1]);
407	return 0;	407	return 0;
408	}	408	}
409		409
410	#define L3PROTO(ct) ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num	410	#define L3PROTO(ct) ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num
411		411
412	static int	412	static int
413	ctnetlink_dump_table(struct sk_buff skb, struct netlink_callback cb)	413	ctnetlink_dump_table(struct sk_buff skb, struct netlink_callback cb)
414	{	414	{
415	struct nf_conn ct, last;	415	struct nf_conn ct, last;
416	struct nf_conntrack_tuple_hash *h;	416	struct nf_conntrack_tuple_hash *h;
417	struct list_head *i;	417	struct list_head *i;
418	struct nfgenmsg *nfmsg = NLMSG_DATA(cb->nlh);	418	struct nfgenmsg *nfmsg = NLMSG_DATA(cb->nlh);
419	u_int8_t l3proto = nfmsg->nfgen_family;	419	u_int8_t l3proto = nfmsg->nfgen_family;
420		420
421	read_lock_bh(&nf_conntrack_lock);	421	read_lock_bh(&nf_conntrack_lock);
422	last = (struct nf_conn *)cb->args[1];	422	last = (struct nf_conn *)cb->args[1];
423	for (; cb->args[0] < nf_conntrack_htable_size; cb->args[0]++) {	423	for (; cb->args[0] < nf_conntrack_htable_size; cb->args[0]++) {
424	restart:	424	restart:
425	list_for_each_prev(i, &nf_conntrack_hash[cb->args[0]]) {	425	list_for_each_prev(i, &nf_conntrack_hash[cb->args[0]]) {
426	h = (struct nf_conntrack_tuple_hash *) i;	426	h = (struct nf_conntrack_tuple_hash *) i;
427	if (DIRECTION(h) != IP_CT_DIR_ORIGINAL)	427	if (DIRECTION(h) != IP_CT_DIR_ORIGINAL)
428	continue;	428	continue;
429	ct = nf_ct_tuplehash_to_ctrack(h);	429	ct = nf_ct_tuplehash_to_ctrack(h);
430	/* Dump entries of a given L3 protocol number.	430	/* Dump entries of a given L3 protocol number.
431	* If it is not specified, ie. l3proto == 0,	431	* If it is not specified, ie. l3proto == 0,
432	* then dump everything. */	432	* then dump everything. */
433	if (l3proto && L3PROTO(ct) != l3proto)	433	if (l3proto && L3PROTO(ct) != l3proto)
434	continue;	434	continue;
435	if (cb->args[1]) {	435	if (cb->args[1]) {
436	if (ct != last)	436	if (ct != last)
437	continue;	437	continue;
438	cb->args[1] = 0;	438	cb->args[1] = 0;
439	}	439	}
440	if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid,	440	if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid,
441	cb->nlh->nlmsg_seq,	441	cb->nlh->nlmsg_seq,
442	IPCTNL_MSG_CT_NEW,	442	IPCTNL_MSG_CT_NEW,
443	1, ct) < 0) {	443	1, ct) < 0) {
444	nf_conntrack_get(&ct->ct_general);	444	nf_conntrack_get(&ct->ct_general);
445	cb->args[1] = (unsigned long)ct;	445	cb->args[1] = (unsigned long)ct;
446	goto out;	446	goto out;
447	}	447	}
448	#ifdef CONFIG_NF_CT_ACCT	448	#ifdef CONFIG_NF_CT_ACCT
449	if (NFNL_MSG_TYPE(cb->nlh->nlmsg_type) ==	449	if (NFNL_MSG_TYPE(cb->nlh->nlmsg_type) ==
450	IPCTNL_MSG_CT_GET_CTRZERO)	450	IPCTNL_MSG_CT_GET_CTRZERO)
451	memset(&ct->counters, 0, sizeof(ct->counters));	451	memset(&ct->counters, 0, sizeof(ct->counters));
452	#endif	452	#endif
453	}	453	}
454	if (cb->args[1]) {	454	if (cb->args[1]) {
455	cb->args[1] = 0;	455	cb->args[1] = 0;
456	goto restart;	456	goto restart;
457	}	457	}
458	}	458	}
459	out:	459	out:
460	read_unlock_bh(&nf_conntrack_lock);	460	read_unlock_bh(&nf_conntrack_lock);
461	if (last)	461	if (last)
462	nf_ct_put(last);	462	nf_ct_put(last);
463		463
464	return skb->len;	464	return skb->len;
465	}	465	}
466		466
467	static inline int	467	static inline int
468	ctnetlink_parse_tuple_ip(struct nfattr attr, struct nf_conntrack_tuple tuple)	468	ctnetlink_parse_tuple_ip(struct nfattr attr, struct nf_conntrack_tuple tuple)
469	{	469	{
470	struct nfattr *tb[CTA_IP_MAX];	470	struct nfattr *tb[CTA_IP_MAX];
471	struct nf_conntrack_l3proto *l3proto;	471	struct nf_conntrack_l3proto *l3proto;
472	int ret = 0;	472	int ret = 0;
473		473
474	nfattr_parse_nested(tb, CTA_IP_MAX, attr);	474	nfattr_parse_nested(tb, CTA_IP_MAX, attr);
475		475
476	l3proto = nf_ct_l3proto_find_get(tuple->src.l3num);	476	l3proto = nf_ct_l3proto_find_get(tuple->src.l3num);
477		477
478	if (likely(l3proto->nfattr_to_tuple))	478	if (likely(l3proto->nfattr_to_tuple))
479	ret = l3proto->nfattr_to_tuple(tb, tuple);	479	ret = l3proto->nfattr_to_tuple(tb, tuple);
480		480
481	nf_ct_l3proto_put(l3proto);	481	nf_ct_l3proto_put(l3proto);
482		482
483	return ret;	483	return ret;
484	}	484	}
485		485
486	static const size_t cta_min_proto[CTA_PROTO_MAX] = {	486	static const size_t cta_min_proto[CTA_PROTO_MAX] = {
487	[CTA_PROTO_NUM-1] = sizeof(u_int8_t),	487	[CTA_PROTO_NUM-1] = sizeof(u_int8_t),
488	};	488	};
489		489
490	static inline int	490	static inline int
491	ctnetlink_parse_tuple_proto(struct nfattr *attr,	491	ctnetlink_parse_tuple_proto(struct nfattr *attr,
492	struct nf_conntrack_tuple *tuple)	492	struct nf_conntrack_tuple *tuple)
493	{	493	{
494	struct nfattr *tb[CTA_PROTO_MAX];	494	struct nfattr *tb[CTA_PROTO_MAX];
495	struct nf_conntrack_protocol *proto;	495	struct nf_conntrack_protocol *proto;
496	int ret = 0;	496	int ret = 0;
497		497
498	nfattr_parse_nested(tb, CTA_PROTO_MAX, attr);	498	nfattr_parse_nested(tb, CTA_PROTO_MAX, attr);
499		499
500	if (nfattr_bad_size(tb, CTA_PROTO_MAX, cta_min_proto))	500	if (nfattr_bad_size(tb, CTA_PROTO_MAX, cta_min_proto))
501	return -EINVAL;	501	return -EINVAL;
502		502
503	if (!tb[CTA_PROTO_NUM-1])	503	if (!tb[CTA_PROTO_NUM-1])
504	return -EINVAL;	504	return -EINVAL;
505	tuple->dst.protonum = (u_int8_t )NFA_DATA(tb[CTA_PROTO_NUM-1]);	505	tuple->dst.protonum = (u_int8_t )NFA_DATA(tb[CTA_PROTO_NUM-1]);
506		506
507	proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum);	507	proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum);
508		508
509	if (likely(proto->nfattr_to_tuple))	509	if (likely(proto->nfattr_to_tuple))
510	ret = proto->nfattr_to_tuple(tb, tuple);	510	ret = proto->nfattr_to_tuple(tb, tuple);
511		511
512	nf_ct_proto_put(proto);	512	nf_ct_proto_put(proto);
513		513
514	return ret;	514	return ret;
515	}	515	}
516		516
517	static inline int	517	static inline int
518	ctnetlink_parse_tuple(struct nfattr cda[], struct nf_conntrack_tuple tuple,	518	ctnetlink_parse_tuple(struct nfattr cda[], struct nf_conntrack_tuple tuple,
519	enum ctattr_tuple type, u_int8_t l3num)	519	enum ctattr_tuple type, u_int8_t l3num)
520	{	520	{
521	struct nfattr *tb[CTA_TUPLE_MAX];	521	struct nfattr *tb[CTA_TUPLE_MAX];
522	int err;	522	int err;
523		523
524	memset(tuple, 0, sizeof(*tuple));	524	memset(tuple, 0, sizeof(*tuple));
525		525
526	nfattr_parse_nested(tb, CTA_TUPLE_MAX, cda[type-1]);	526	nfattr_parse_nested(tb, CTA_TUPLE_MAX, cda[type-1]);
527		527
528	if (!tb[CTA_TUPLE_IP-1])	528	if (!tb[CTA_TUPLE_IP-1])
529	return -EINVAL;	529	return -EINVAL;
530		530
531	tuple->src.l3num = l3num;	531	tuple->src.l3num = l3num;
532		532
533	err = ctnetlink_parse_tuple_ip(tb[CTA_TUPLE_IP-1], tuple);	533	err = ctnetlink_parse_tuple_ip(tb[CTA_TUPLE_IP-1], tuple);
534	if (err < 0)	534	if (err < 0)
535	return err;	535	return err;
536		536
537	if (!tb[CTA_TUPLE_PROTO-1])	537	if (!tb[CTA_TUPLE_PROTO-1])
538	return -EINVAL;	538	return -EINVAL;
539		539
540	err = ctnetlink_parse_tuple_proto(tb[CTA_TUPLE_PROTO-1], tuple);	540	err = ctnetlink_parse_tuple_proto(tb[CTA_TUPLE_PROTO-1], tuple);
541	if (err < 0)	541	if (err < 0)
542	return err;	542	return err;
543		543
544	/* orig and expect tuples get DIR_ORIGINAL */	544	/* orig and expect tuples get DIR_ORIGINAL */
545	if (type == CTA_TUPLE_REPLY)	545	if (type == CTA_TUPLE_REPLY)
546	tuple->dst.dir = IP_CT_DIR_REPLY;	546	tuple->dst.dir = IP_CT_DIR_REPLY;
547	else	547	else
548	tuple->dst.dir = IP_CT_DIR_ORIGINAL;	548	tuple->dst.dir = IP_CT_DIR_ORIGINAL;
549		549
550	return 0;	550	return 0;
551	}	551	}
552		552
553	#ifdef CONFIG_IP_NF_NAT_NEEDED	553	#ifdef CONFIG_IP_NF_NAT_NEEDED
554	static const size_t cta_min_protonat[CTA_PROTONAT_MAX] = {	554	static const size_t cta_min_protonat[CTA_PROTONAT_MAX] = {
555	[CTA_PROTONAT_PORT_MIN-1] = sizeof(u_int16_t),	555	[CTA_PROTONAT_PORT_MIN-1] = sizeof(u_int16_t),
556	[CTA_PROTONAT_PORT_MAX-1] = sizeof(u_int16_t),	556	[CTA_PROTONAT_PORT_MAX-1] = sizeof(u_int16_t),
557	};	557	};
558		558
559	static int ctnetlink_parse_nat_proto(struct nfattr *attr,	559	static int ctnetlink_parse_nat_proto(struct nfattr *attr,
560	const struct nf_conn *ct,	560	const struct nf_conn *ct,
561	struct ip_nat_range *range)	561	struct ip_nat_range *range)
562	{	562	{
563	struct nfattr *tb[CTA_PROTONAT_MAX];	563	struct nfattr *tb[CTA_PROTONAT_MAX];
564	struct ip_nat_protocol *npt;	564	struct ip_nat_protocol *npt;
565		565
566	nfattr_parse_nested(tb, CTA_PROTONAT_MAX, attr);	566	nfattr_parse_nested(tb, CTA_PROTONAT_MAX, attr);
567		567
568	if (nfattr_bad_size(tb, CTA_PROTONAT_MAX, cta_min_protonat))	568	if (nfattr_bad_size(tb, CTA_PROTONAT_MAX, cta_min_protonat))
569	return -EINVAL;	569	return -EINVAL;
570		570
571	npt = ip_nat_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum);	571	npt = ip_nat_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum);
572		572
573	if (!npt->nfattr_to_range) {	573	if (!npt->nfattr_to_range) {
574	ip_nat_proto_put(npt);	574	ip_nat_proto_put(npt);
575	return 0;	575	return 0;
576	}	576	}
577		577
578	/* nfattr_to_range returns 1 if it parsed, 0 if not, neg. on error */	578	/* nfattr_to_range returns 1 if it parsed, 0 if not, neg. on error */
579	if (npt->nfattr_to_range(tb, range) > 0)	579	if (npt->nfattr_to_range(tb, range) > 0)
580	range->flags \|= IP_NAT_RANGE_PROTO_SPECIFIED;	580	range->flags \|= IP_NAT_RANGE_PROTO_SPECIFIED;
581		581
582	ip_nat_proto_put(npt);	582	ip_nat_proto_put(npt);
583		583
584	return 0;	584	return 0;
585	}	585	}
586		586
587	static const size_t cta_min_nat[CTA_NAT_MAX] = {	587	static const size_t cta_min_nat[CTA_NAT_MAX] = {
588	[CTA_NAT_MINIP-1] = sizeof(u_int32_t),	588	[CTA_NAT_MINIP-1] = sizeof(u_int32_t),
589	[CTA_NAT_MAXIP-1] = sizeof(u_int32_t),	589	[CTA_NAT_MAXIP-1] = sizeof(u_int32_t),
590	};	590	};
591		591
592	static inline int	592	static inline int
593	ctnetlink_parse_nat(struct nfattr *nat,	593	ctnetlink_parse_nat(struct nfattr *nat,
594	const struct nf_conn ct, struct ip_nat_range range)	594	const struct nf_conn ct, struct ip_nat_range range)
595	{	595	{
596	struct nfattr *tb[CTA_NAT_MAX];	596	struct nfattr *tb[CTA_NAT_MAX];
597	int err;	597	int err;
598		598
599	memset(range, 0, sizeof(*range));	599	memset(range, 0, sizeof(*range));
600		600
601	nfattr_parse_nested(tb, CTA_NAT_MAX, nat);	601	nfattr_parse_nested(tb, CTA_NAT_MAX, nat);
602		602
603	if (nfattr_bad_size(tb, CTA_NAT_MAX, cta_min_nat))	603	if (nfattr_bad_size(tb, CTA_NAT_MAX, cta_min_nat))
604	return -EINVAL;	604	return -EINVAL;
605		605
606	if (tb[CTA_NAT_MINIP-1])	606	if (tb[CTA_NAT_MINIP-1])
607	range->min_ip = (u_int32_t )NFA_DATA(tb[CTA_NAT_MINIP-1]);	607	range->min_ip = (u_int32_t )NFA_DATA(tb[CTA_NAT_MINIP-1]);
608		608
609	if (!tb[CTA_NAT_MAXIP-1])	609	if (!tb[CTA_NAT_MAXIP-1])
610	range->max_ip = range->min_ip;	610	range->max_ip = range->min_ip;
611	else	611	else
612	range->max_ip = (u_int32_t )NFA_DATA(tb[CTA_NAT_MAXIP-1]);	612	range->max_ip = (u_int32_t )NFA_DATA(tb[CTA_NAT_MAXIP-1]);
613		613
614	if (range->min_ip)	614	if (range->min_ip)
615	range->flags \|= IP_NAT_RANGE_MAP_IPS;	615	range->flags \|= IP_NAT_RANGE_MAP_IPS;
616		616
617	if (!tb[CTA_NAT_PROTO-1])	617	if (!tb[CTA_NAT_PROTO-1])
618	return 0;	618	return 0;
619		619
620	err = ctnetlink_parse_nat_proto(tb[CTA_NAT_PROTO-1], ct, range);	620	err = ctnetlink_parse_nat_proto(tb[CTA_NAT_PROTO-1], ct, range);
621	if (err < 0)	621	if (err < 0)
622	return err;	622	return err;
623		623
624	return 0;	624	return 0;
625	}	625	}
626	#endif	626	#endif
627		627
628	static inline int	628	static inline int
629	ctnetlink_parse_help(struct nfattr attr, char *helper_name)	629	ctnetlink_parse_help(struct nfattr attr, char *helper_name)
630	{	630	{
631	struct nfattr *tb[CTA_HELP_MAX];	631	struct nfattr *tb[CTA_HELP_MAX];
632		632
633	nfattr_parse_nested(tb, CTA_HELP_MAX, attr);	633	nfattr_parse_nested(tb, CTA_HELP_MAX, attr);
634		634
635	if (!tb[CTA_HELP_NAME-1])	635	if (!tb[CTA_HELP_NAME-1])
636	return -EINVAL;	636	return -EINVAL;
637		637
638	*helper_name = NFA_DATA(tb[CTA_HELP_NAME-1]);	638	*helper_name = NFA_DATA(tb[CTA_HELP_NAME-1]);
639		639
640	return 0;	640	return 0;
641	}	641	}
642		642
643	static const size_t cta_min[CTA_MAX] = {	643	static const size_t cta_min[CTA_MAX] = {
644	[CTA_STATUS-1] = sizeof(u_int32_t),	644	[CTA_STATUS-1] = sizeof(u_int32_t),
645	[CTA_TIMEOUT-1] = sizeof(u_int32_t),	645	[CTA_TIMEOUT-1] = sizeof(u_int32_t),
646	[CTA_MARK-1] = sizeof(u_int32_t),	646	[CTA_MARK-1] = sizeof(u_int32_t),
647	[CTA_USE-1] = sizeof(u_int32_t),	647	[CTA_USE-1] = sizeof(u_int32_t),
648	[CTA_ID-1] = sizeof(u_int32_t)	648	[CTA_ID-1] = sizeof(u_int32_t)
649	};	649	};
650		650
651	static int	651	static int
652	ctnetlink_del_conntrack(struct sock ctnl, struct sk_buff skb,	652	ctnetlink_del_conntrack(struct sock ctnl, struct sk_buff skb,
653	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	653	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
654	{	654	{
655	struct nf_conntrack_tuple_hash *h;	655	struct nf_conntrack_tuple_hash *h;
656	struct nf_conntrack_tuple tuple;	656	struct nf_conntrack_tuple tuple;
657	struct nf_conn *ct;	657	struct nf_conn *ct;
658	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);	658	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
659	u_int8_t u3 = nfmsg->nfgen_family;	659	u_int8_t u3 = nfmsg->nfgen_family;
660	int err = 0;	660	int err = 0;
661		661
662	if (nfattr_bad_size(cda, CTA_MAX, cta_min))	662	if (nfattr_bad_size(cda, CTA_MAX, cta_min))
663	return -EINVAL;	663	return -EINVAL;
664		664
665	if (cda[CTA_TUPLE_ORIG-1])	665	if (cda[CTA_TUPLE_ORIG-1])
666	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG, u3);	666	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG, u3);
667	else if (cda[CTA_TUPLE_REPLY-1])	667	else if (cda[CTA_TUPLE_REPLY-1])
668	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY, u3);	668	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY, u3);
669	else {	669	else {
670	/* Flush the whole table */	670	/* Flush the whole table */
671	nf_conntrack_flush();	671	nf_conntrack_flush();
672	return 0;	672	return 0;
673	}	673	}
674		674
675	if (err < 0)	675	if (err < 0)
676	return err;	676	return err;
677		677
678	h = nf_conntrack_find_get(&tuple, NULL);	678	h = nf_conntrack_find_get(&tuple, NULL);
679	if (!h)	679	if (!h)
680	return -ENOENT;	680	return -ENOENT;
681		681
682	ct = nf_ct_tuplehash_to_ctrack(h);	682	ct = nf_ct_tuplehash_to_ctrack(h);
683		683
684	if (cda[CTA_ID-1]) {	684	if (cda[CTA_ID-1]) {
685	u_int32_t id = ntohl((u_int32_t )NFA_DATA(cda[CTA_ID-1]));	685	u_int32_t id = ntohl((u_int32_t )NFA_DATA(cda[CTA_ID-1]));
686	if (ct->id != id) {	686	if (ct->id != id) {
687	nf_ct_put(ct);	687	nf_ct_put(ct);
688	return -ENOENT;	688	return -ENOENT;
689	}	689	}
690	}	690	}
691	if (del_timer(&ct->timeout))	691	if (del_timer(&ct->timeout))
692	ct->timeout.function((unsigned long)ct);	692	ct->timeout.function((unsigned long)ct);
693		693
694	nf_ct_put(ct);	694	nf_ct_put(ct);
695		695
696	return 0;	696	return 0;
697	}	697	}
698		698
699	static int	699	static int
700	ctnetlink_get_conntrack(struct sock ctnl, struct sk_buff skb,	700	ctnetlink_get_conntrack(struct sock ctnl, struct sk_buff skb,
701	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	701	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
702	{	702	{
703	struct nf_conntrack_tuple_hash *h;	703	struct nf_conntrack_tuple_hash *h;
704	struct nf_conntrack_tuple tuple;	704	struct nf_conntrack_tuple tuple;
705	struct nf_conn *ct;	705	struct nf_conn *ct;
706	struct sk_buff *skb2 = NULL;	706	struct sk_buff *skb2 = NULL;
707	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);	707	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
708	u_int8_t u3 = nfmsg->nfgen_family;	708	u_int8_t u3 = nfmsg->nfgen_family;
709	int err = 0;	709	int err = 0;
710		710
711	if (nlh->nlmsg_flags & NLM_F_DUMP) {	711	if (nlh->nlmsg_flags & NLM_F_DUMP) {
712	u32 rlen;	712	u32 rlen;
713		713
714	#ifndef CONFIG_NF_CT_ACCT	714	#ifndef CONFIG_NF_CT_ACCT
715	if (NFNL_MSG_TYPE(nlh->nlmsg_type) == IPCTNL_MSG_CT_GET_CTRZERO)	715	if (NFNL_MSG_TYPE(nlh->nlmsg_type) == IPCTNL_MSG_CT_GET_CTRZERO)
716	return -ENOTSUPP;	716	return -ENOTSUPP;
717	#endif	717	#endif
718	if ((*errp = netlink_dump_start(ctnl, skb, nlh,	718	if ((*errp = netlink_dump_start(ctnl, skb, nlh,
719	ctnetlink_dump_table,	719	ctnetlink_dump_table,
720	ctnetlink_done)) != 0)	720	ctnetlink_done)) != 0)
721	return -EINVAL;	721	return -EINVAL;
722		722
723	rlen = NLMSG_ALIGN(nlh->nlmsg_len);	723	rlen = NLMSG_ALIGN(nlh->nlmsg_len);
724	if (rlen > skb->len)	724	if (rlen > skb->len)
725	rlen = skb->len;	725	rlen = skb->len;
726	skb_pull(skb, rlen);	726	skb_pull(skb, rlen);
727	return 0;	727	return 0;
728	}	728	}
729		729
730	if (nfattr_bad_size(cda, CTA_MAX, cta_min))	730	if (nfattr_bad_size(cda, CTA_MAX, cta_min))
731	return -EINVAL;	731	return -EINVAL;
732		732
733	if (cda[CTA_TUPLE_ORIG-1])	733	if (cda[CTA_TUPLE_ORIG-1])
734	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG, u3);	734	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG, u3);
735	else if (cda[CTA_TUPLE_REPLY-1])	735	else if (cda[CTA_TUPLE_REPLY-1])
736	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY, u3);	736	err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY, u3);
737	else	737	else
738	return -EINVAL;	738	return -EINVAL;
739		739
740	if (err < 0)	740	if (err < 0)
741	return err;	741	return err;
742		742
743	h = nf_conntrack_find_get(&tuple, NULL);	743	h = nf_conntrack_find_get(&tuple, NULL);
744	if (!h)	744	if (!h)
745	return -ENOENT;	745	return -ENOENT;
746		746
747	ct = nf_ct_tuplehash_to_ctrack(h);	747	ct = nf_ct_tuplehash_to_ctrack(h);
748		748
749	err = -ENOMEM;	749	err = -ENOMEM;
750	skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);	750	skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
751	if (!skb2) {	751	if (!skb2) {
752	nf_ct_put(ct);	752	nf_ct_put(ct);
753	return -ENOMEM;	753	return -ENOMEM;
754	}	754	}
755	NETLINK_CB(skb2).dst_pid = NETLINK_CB(skb).pid;
756		755
757	err = ctnetlink_fill_info(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq,	756	err = ctnetlink_fill_info(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq,
758	IPCTNL_MSG_CT_NEW, 1, ct);	757	IPCTNL_MSG_CT_NEW, 1, ct);
759	nf_ct_put(ct);	758	nf_ct_put(ct);
760	if (err <= 0)	759	if (err <= 0)
761	goto free;	760	goto free;
762		761
763	err = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);	762	err = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
764	if (err < 0)	763	if (err < 0)
765	goto out;	764	goto out;
766		765
767	return 0;	766	return 0;
768		767
769	free:	768	free:
770	kfree_skb(skb2);	769	kfree_skb(skb2);
771	out:	770	out:
772	return err;	771	return err;
773	}	772	}
774		773
775	static inline int	774	static inline int
776	ctnetlink_change_status(struct nf_conn ct, struct nfattr cda[])	775	ctnetlink_change_status(struct nf_conn ct, struct nfattr cda[])
777	{	776	{
778	unsigned long d;	777	unsigned long d;
779	unsigned status = ntohl((u_int32_t )NFA_DATA(cda[CTA_STATUS-1]));	778	unsigned status = ntohl((u_int32_t )NFA_DATA(cda[CTA_STATUS-1]));
780	d = ct->status ^ status;	779	d = ct->status ^ status;
781		780
782	if (d & (IPS_EXPECTED\|IPS_CONFIRMED\|IPS_DYING))	781	if (d & (IPS_EXPECTED\|IPS_CONFIRMED\|IPS_DYING))
783	/* unchangeable */	782	/* unchangeable */
784	return -EINVAL;	783	return -EINVAL;
785		784
786	if (d & IPS_SEEN_REPLY && !(status & IPS_SEEN_REPLY))	785	if (d & IPS_SEEN_REPLY && !(status & IPS_SEEN_REPLY))
787	/* SEEN_REPLY bit can only be set */	786	/* SEEN_REPLY bit can only be set */
788	return -EINVAL;	787	return -EINVAL;
789		788
790		789
791	if (d & IPS_ASSURED && !(status & IPS_ASSURED))	790	if (d & IPS_ASSURED && !(status & IPS_ASSURED))
792	/* ASSURED bit can only be set */	791	/* ASSURED bit can only be set */
793	return -EINVAL;	792	return -EINVAL;
794		793
795	if (cda[CTA_NAT_SRC-1] \|\| cda[CTA_NAT_DST-1]) {	794	if (cda[CTA_NAT_SRC-1] \|\| cda[CTA_NAT_DST-1]) {
796	#ifndef CONFIG_IP_NF_NAT_NEEDED	795	#ifndef CONFIG_IP_NF_NAT_NEEDED
797	return -EINVAL;	796	return -EINVAL;
798	#else	797	#else
799	struct ip_nat_range range;	798	struct ip_nat_range range;
800		799
801	if (cda[CTA_NAT_DST-1]) {	800	if (cda[CTA_NAT_DST-1]) {
802	if (ctnetlink_parse_nat(cda[CTA_NAT_DST-1], ct,	801	if (ctnetlink_parse_nat(cda[CTA_NAT_DST-1], ct,
803	&range) < 0)	802	&range) < 0)
804	return -EINVAL;	803	return -EINVAL;
805	if (ip_nat_initialized(ct,	804	if (ip_nat_initialized(ct,
806	HOOK2MANIP(NF_IP_PRE_ROUTING)))	805	HOOK2MANIP(NF_IP_PRE_ROUTING)))
807	return -EEXIST;	806	return -EEXIST;
808	ip_nat_setup_info(ct, &range, hooknum);	807	ip_nat_setup_info(ct, &range, hooknum);
809	}	808	}
810	if (cda[CTA_NAT_SRC-1]) {	809	if (cda[CTA_NAT_SRC-1]) {
811	if (ctnetlink_parse_nat(cda[CTA_NAT_SRC-1], ct,	810	if (ctnetlink_parse_nat(cda[CTA_NAT_SRC-1], ct,
812	&range) < 0)	811	&range) < 0)
813	return -EINVAL;	812	return -EINVAL;
814	if (ip_nat_initialized(ct,	813	if (ip_nat_initialized(ct,
815	HOOK2MANIP(NF_IP_POST_ROUTING)))	814	HOOK2MANIP(NF_IP_POST_ROUTING)))
816	return -EEXIST;	815	return -EEXIST;
817	ip_nat_setup_info(ct, &range, hooknum);	816	ip_nat_setup_info(ct, &range, hooknum);
818	}	817	}
819	#endif	818	#endif
820	}	819	}
821		820
822	/* Be careful here, modifying NAT bits can screw up things,	821	/* Be careful here, modifying NAT bits can screw up things,
823	* so don't let users modify them directly if they don't pass	822	* so don't let users modify them directly if they don't pass
824	* ip_nat_range. */	823	* ip_nat_range. */
825	ct->status \|= status & ~(IPS_NAT_DONE_MASK \| IPS_NAT_MASK);	824	ct->status \|= status & ~(IPS_NAT_DONE_MASK \| IPS_NAT_MASK);
826	return 0;	825	return 0;
827	}	826	}
828		827
829		828
830	static inline int	829	static inline int
831	ctnetlink_change_helper(struct nf_conn ct, struct nfattr cda[])	830	ctnetlink_change_helper(struct nf_conn ct, struct nfattr cda[])
832	{	831	{
833	struct nf_conntrack_helper *helper;	832	struct nf_conntrack_helper *helper;
834	struct nf_conn_help *help = nfct_help(ct);	833	struct nf_conn_help *help = nfct_help(ct);
835	char *helpname;	834	char *helpname;
836	int err;	835	int err;
837		836
838	if (!help) {	837	if (!help) {
839	/* FIXME: we need to reallocate and rehash */	838	/* FIXME: we need to reallocate and rehash */
840	return -EBUSY;	839	return -EBUSY;
841	}	840	}
842		841
843	/* don't change helper of sibling connections */	842	/* don't change helper of sibling connections */
844	if (ct->master)	843	if (ct->master)
845	return -EINVAL;	844	return -EINVAL;
846		845
847	err = ctnetlink_parse_help(cda[CTA_HELP-1], &helpname);	846	err = ctnetlink_parse_help(cda[CTA_HELP-1], &helpname);
848	if (err < 0)	847	if (err < 0)
849	return err;	848	return err;
850		849
851	helper = __nf_conntrack_helper_find_byname(helpname);	850	helper = __nf_conntrack_helper_find_byname(helpname);
852	if (!helper) {	851	if (!helper) {
853	if (!strcmp(helpname, ""))	852	if (!strcmp(helpname, ""))
854	helper = NULL;	853	helper = NULL;
855	else	854	else
856	return -EINVAL;	855	return -EINVAL;
857	}	856	}
858		857
859	if (help->helper) {	858	if (help->helper) {
860	if (!helper) {	859	if (!helper) {
861	/* we had a helper before ... */	860	/* we had a helper before ... */
862	nf_ct_remove_expectations(ct);	861	nf_ct_remove_expectations(ct);
863	help->helper = NULL;	862	help->helper = NULL;
864	} else {	863	} else {
865	/* need to zero data of old helper */	864	/* need to zero data of old helper */
866	memset(&help->help, 0, sizeof(help->help));	865	memset(&help->help, 0, sizeof(help->help));
867	}	866	}
868	}	867	}
869		868
870	help->helper = helper;	869	help->helper = helper;
871		870
872	return 0;	871	return 0;
873	}	872	}
874		873
875	static inline int	874	static inline int
876	ctnetlink_change_timeout(struct nf_conn ct, struct nfattr cda[])	875	ctnetlink_change_timeout(struct nf_conn ct, struct nfattr cda[])
877	{	876	{
878	u_int32_t timeout = ntohl((u_int32_t )NFA_DATA(cda[CTA_TIMEOUT-1]));	877	u_int32_t timeout = ntohl((u_int32_t )NFA_DATA(cda[CTA_TIMEOUT-1]));
879		878
880	if (!del_timer(&ct->timeout))	879	if (!del_timer(&ct->timeout))
881	return -ETIME;	880	return -ETIME;
882		881
883	ct->timeout.expires = jiffies + timeout * HZ;	882	ct->timeout.expires = jiffies + timeout * HZ;
884	add_timer(&ct->timeout);	883	add_timer(&ct->timeout);
885		884
886	return 0;	885	return 0;
887	}	886	}
888		887
889	static inline int	888	static inline int
890	ctnetlink_change_protoinfo(struct nf_conn ct, struct nfattr cda[])	889	ctnetlink_change_protoinfo(struct nf_conn ct, struct nfattr cda[])
891	{	890	{
892	struct nfattr tb[CTA_PROTOINFO_MAX], attr = cda[CTA_PROTOINFO-1];	891	struct nfattr tb[CTA_PROTOINFO_MAX], attr = cda[CTA_PROTOINFO-1];
893	struct nf_conntrack_protocol *proto;	892	struct nf_conntrack_protocol *proto;
894	u_int16_t npt = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum;	893	u_int16_t npt = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum;
895	u_int16_t l3num = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num;	894	u_int16_t l3num = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num;
896	int err = 0;	895	int err = 0;
897		896
898	nfattr_parse_nested(tb, CTA_PROTOINFO_MAX, attr);	897	nfattr_parse_nested(tb, CTA_PROTOINFO_MAX, attr);
899		898
900	proto = nf_ct_proto_find_get(l3num, npt);	899	proto = nf_ct_proto_find_get(l3num, npt);
901		900
902	if (proto->from_nfattr)	901	if (proto->from_nfattr)
903	err = proto->from_nfattr(tb, ct);	902	err = proto->from_nfattr(tb, ct);
904	nf_ct_proto_put(proto);	903	nf_ct_proto_put(proto);
905		904
906	return err;	905	return err;
907	}	906	}
908		907
909	static int	908	static int
910	ctnetlink_change_conntrack(struct nf_conn ct, struct nfattr cda[])	909	ctnetlink_change_conntrack(struct nf_conn ct, struct nfattr cda[])
911	{	910	{
912	int err;	911	int err;
913		912
914	if (cda[CTA_HELP-1]) {	913	if (cda[CTA_HELP-1]) {
915	err = ctnetlink_change_helper(ct, cda);	914	err = ctnetlink_change_helper(ct, cda);
916	if (err < 0)	915	if (err < 0)
917	return err;	916	return err;
918	}	917	}
919		918
920	if (cda[CTA_TIMEOUT-1]) {	919	if (cda[CTA_TIMEOUT-1]) {
921	err = ctnetlink_change_timeout(ct, cda);	920	err = ctnetlink_change_timeout(ct, cda);
922	if (err < 0)	921	if (err < 0)
923	return err;	922	return err;
924	}	923	}
925		924
926	if (cda[CTA_STATUS-1]) {	925	if (cda[CTA_STATUS-1]) {
927	err = ctnetlink_change_status(ct, cda);	926	err = ctnetlink_change_status(ct, cda);
928	if (err < 0)	927	if (err < 0)
929	return err;	928	return err;
930	}	929	}
931		930
932	if (cda[CTA_PROTOINFO-1]) {	931	if (cda[CTA_PROTOINFO-1]) {
933	err = ctnetlink_change_protoinfo(ct, cda);	932	err = ctnetlink_change_protoinfo(ct, cda);
934	if (err < 0)	933	if (err < 0)
935	return err;	934	return err;
936	}	935	}
937		936
938	#if defined(CONFIG_NF_CONNTRACK_MARK)	937	#if defined(CONFIG_NF_CONNTRACK_MARK)
939	if (cda[CTA_MARK-1])	938	if (cda[CTA_MARK-1])
940	ct->mark = ntohl((u_int32_t )NFA_DATA(cda[CTA_MARK-1]));	939	ct->mark = ntohl((u_int32_t )NFA_DATA(cda[CTA_MARK-1]));
941	#endif	940	#endif
942		941
943	return 0;	942	return 0;
944	}	943	}
945		944
946	static int	945	static int
947	ctnetlink_create_conntrack(struct nfattr *cda[],	946	ctnetlink_create_conntrack(struct nfattr *cda[],
948	struct nf_conntrack_tuple *otuple,	947	struct nf_conntrack_tuple *otuple,
949	struct nf_conntrack_tuple *rtuple)	948	struct nf_conntrack_tuple *rtuple)
950	{	949	{
951	struct nf_conn *ct;	950	struct nf_conn *ct;
952	int err = -EINVAL;	951	int err = -EINVAL;
953	struct nf_conn_help *help;	952	struct nf_conn_help *help;
954		953
955	ct = nf_conntrack_alloc(otuple, rtuple);	954	ct = nf_conntrack_alloc(otuple, rtuple);
956	if (ct == NULL \|\| IS_ERR(ct))	955	if (ct == NULL \|\| IS_ERR(ct))
957	return -ENOMEM;	956	return -ENOMEM;
958		957
959	if (!cda[CTA_TIMEOUT-1])	958	if (!cda[CTA_TIMEOUT-1])
960	goto err;	959	goto err;
961	ct->timeout.expires = ntohl((u_int32_t )NFA_DATA(cda[CTA_TIMEOUT-1]));	960	ct->timeout.expires = ntohl((u_int32_t )NFA_DATA(cda[CTA_TIMEOUT-1]));
962		961
963	ct->timeout.expires = jiffies + ct->timeout.expires * HZ;	962	ct->timeout.expires = jiffies + ct->timeout.expires * HZ;
964	ct->status \|= IPS_CONFIRMED;	963	ct->status \|= IPS_CONFIRMED;
965		964
966	err = ctnetlink_change_status(ct, cda);	965	err = ctnetlink_change_status(ct, cda);
967	if (err < 0)	966	if (err < 0)
968	goto err;	967	goto err;
969		968
970	if (cda[CTA_PROTOINFO-1]) {	969	if (cda[CTA_PROTOINFO-1]) {
971	err = ctnetlink_change_protoinfo(ct, cda);	970	err = ctnetlink_change_protoinfo(ct, cda);
972	if (err < 0)	971	if (err < 0)
973	return err;	972	return err;
974	}	973	}
975		974
976	#if defined(CONFIG_NF_CONNTRACK_MARK)	975	#if defined(CONFIG_NF_CONNTRACK_MARK)
977	if (cda[CTA_MARK-1])	976	if (cda[CTA_MARK-1])
978	ct->mark = ntohl((u_int32_t )NFA_DATA(cda[CTA_MARK-1]));	977	ct->mark = ntohl((u_int32_t )NFA_DATA(cda[CTA_MARK-1]));
979	#endif	978	#endif
980		979
981	help = nfct_help(ct);	980	help = nfct_help(ct);
982	if (help)	981	if (help)
983	help->helper = nf_ct_helper_find_get(rtuple);	982	help->helper = nf_ct_helper_find_get(rtuple);
984		983
985	add_timer(&ct->timeout);	984	add_timer(&ct->timeout);
986	nf_conntrack_hash_insert(ct);	985	nf_conntrack_hash_insert(ct);
987		986
988	if (help && help->helper)	987	if (help && help->helper)
989	nf_ct_helper_put(help->helper);	988	nf_ct_helper_put(help->helper);
990		989
991	return 0;	990	return 0;
992		991
993	err:	992	err:
994	nf_conntrack_free(ct);	993	nf_conntrack_free(ct);
995	return err;	994	return err;
996	}	995	}
997		996
998	static int	997	static int
999	ctnetlink_new_conntrack(struct sock ctnl, struct sk_buff skb,	998	ctnetlink_new_conntrack(struct sock ctnl, struct sk_buff skb,
1000	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	999	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
1001	{	1000	{
1002	struct nf_conntrack_tuple otuple, rtuple;	1001	struct nf_conntrack_tuple otuple, rtuple;
1003	struct nf_conntrack_tuple_hash *h = NULL;	1002	struct nf_conntrack_tuple_hash *h = NULL;
1004	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);	1003	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
1005	u_int8_t u3 = nfmsg->nfgen_family;	1004	u_int8_t u3 = nfmsg->nfgen_family;
1006	int err = 0;	1005	int err = 0;
1007		1006
1008	if (nfattr_bad_size(cda, CTA_MAX, cta_min))	1007	if (nfattr_bad_size(cda, CTA_MAX, cta_min))
1009	return -EINVAL;	1008	return -EINVAL;
1010		1009
1011	if (cda[CTA_TUPLE_ORIG-1]) {	1010	if (cda[CTA_TUPLE_ORIG-1]) {
1012	err = ctnetlink_parse_tuple(cda, &otuple, CTA_TUPLE_ORIG, u3);	1011	err = ctnetlink_parse_tuple(cda, &otuple, CTA_TUPLE_ORIG, u3);
1013	if (err < 0)	1012	if (err < 0)
1014	return err;	1013	return err;
1015	}	1014	}
1016		1015
1017	if (cda[CTA_TUPLE_REPLY-1]) {	1016	if (cda[CTA_TUPLE_REPLY-1]) {
1018	err = ctnetlink_parse_tuple(cda, &rtuple, CTA_TUPLE_REPLY, u3);	1017	err = ctnetlink_parse_tuple(cda, &rtuple, CTA_TUPLE_REPLY, u3);
1019	if (err < 0)	1018	if (err < 0)
1020	return err;	1019	return err;
1021	}	1020	}
1022		1021
1023	write_lock_bh(&nf_conntrack_lock);	1022	write_lock_bh(&nf_conntrack_lock);
1024	if (cda[CTA_TUPLE_ORIG-1])	1023	if (cda[CTA_TUPLE_ORIG-1])
1025	h = __nf_conntrack_find(&otuple, NULL);	1024	h = __nf_conntrack_find(&otuple, NULL);
1026	else if (cda[CTA_TUPLE_REPLY-1])	1025	else if (cda[CTA_TUPLE_REPLY-1])
1027	h = __nf_conntrack_find(&rtuple, NULL);	1026	h = __nf_conntrack_find(&rtuple, NULL);
1028		1027
1029	if (h == NULL) {	1028	if (h == NULL) {
1030	write_unlock_bh(&nf_conntrack_lock);	1029	write_unlock_bh(&nf_conntrack_lock);
1031	err = -ENOENT;	1030	err = -ENOENT;
1032	if (nlh->nlmsg_flags & NLM_F_CREATE)	1031	if (nlh->nlmsg_flags & NLM_F_CREATE)
1033	err = ctnetlink_create_conntrack(cda, &otuple, &rtuple);	1032	err = ctnetlink_create_conntrack(cda, &otuple, &rtuple);
1034	return err;	1033	return err;
1035	}	1034	}
1036	/* implicit 'else' */	1035	/* implicit 'else' */
1037		1036
1038	/* we only allow nat config for new conntracks */	1037	/* we only allow nat config for new conntracks */
1039	if (cda[CTA_NAT_SRC-1] \|\| cda[CTA_NAT_DST-1]) {	1038	if (cda[CTA_NAT_SRC-1] \|\| cda[CTA_NAT_DST-1]) {
1040	err = -EINVAL;	1039	err = -EINVAL;
1041	goto out_unlock;	1040	goto out_unlock;
1042	}	1041	}
1043		1042
1044	/* We manipulate the conntrack inside the global conntrack table lock,	1043	/* We manipulate the conntrack inside the global conntrack table lock,
1045	* so there's no need to increase the refcount */	1044	* so there's no need to increase the refcount */
1046	err = -EEXIST;	1045	err = -EEXIST;
1047	if (!(nlh->nlmsg_flags & NLM_F_EXCL))	1046	if (!(nlh->nlmsg_flags & NLM_F_EXCL))
1048	err = ctnetlink_change_conntrack(nf_ct_tuplehash_to_ctrack(h), cda);	1047	err = ctnetlink_change_conntrack(nf_ct_tuplehash_to_ctrack(h), cda);
1049		1048
1050	out_unlock:	1049	out_unlock:
1051	write_unlock_bh(&nf_conntrack_lock);	1050	write_unlock_bh(&nf_conntrack_lock);
1052	return err;	1051	return err;
1053	}	1052	}
1054		1053
1055	/***********************************************************************	1054	/***********************************************************************
1056	* EXPECT	1055	* EXPECT
1057	***********************************************************************/	1056	***********************************************************************/
1058		1057
1059	static inline int	1058	static inline int
1060	ctnetlink_exp_dump_tuple(struct sk_buff *skb,	1059	ctnetlink_exp_dump_tuple(struct sk_buff *skb,
1061	const struct nf_conntrack_tuple *tuple,	1060	const struct nf_conntrack_tuple *tuple,
1062	enum ctattr_expect type)	1061	enum ctattr_expect type)
1063	{	1062	{
1064	struct nfattr *nest_parms = NFA_NEST(skb, type);	1063	struct nfattr *nest_parms = NFA_NEST(skb, type);
1065		1064
1066	if (ctnetlink_dump_tuples(skb, tuple) < 0)	1065	if (ctnetlink_dump_tuples(skb, tuple) < 0)
1067	goto nfattr_failure;	1066	goto nfattr_failure;
1068		1067
1069	NFA_NEST_END(skb, nest_parms);	1068	NFA_NEST_END(skb, nest_parms);
1070		1069
1071	return 0;	1070	return 0;
1072		1071
1073	nfattr_failure:	1072	nfattr_failure:
1074	return -1;	1073	return -1;
1075	}	1074	}
1076		1075
1077	static inline int	1076	static inline int
1078	ctnetlink_exp_dump_mask(struct sk_buff *skb,	1077	ctnetlink_exp_dump_mask(struct sk_buff *skb,
1079	const struct nf_conntrack_tuple *tuple,	1078	const struct nf_conntrack_tuple *tuple,
1080	const struct nf_conntrack_tuple *mask)	1079	const struct nf_conntrack_tuple *mask)
1081	{	1080	{
1082	int ret;	1081	int ret;
1083	struct nf_conntrack_l3proto *l3proto;	1082	struct nf_conntrack_l3proto *l3proto;
1084	struct nf_conntrack_protocol *proto;	1083	struct nf_conntrack_protocol *proto;
1085	struct nfattr *nest_parms = NFA_NEST(skb, CTA_EXPECT_MASK);	1084	struct nfattr *nest_parms = NFA_NEST(skb, CTA_EXPECT_MASK);
1086		1085
1087	l3proto = nf_ct_l3proto_find_get(tuple->src.l3num);	1086	l3proto = nf_ct_l3proto_find_get(tuple->src.l3num);
1088	ret = ctnetlink_dump_tuples_ip(skb, mask, l3proto);	1087	ret = ctnetlink_dump_tuples_ip(skb, mask, l3proto);
1089	nf_ct_l3proto_put(l3proto);	1088	nf_ct_l3proto_put(l3proto);
1090		1089
1091	if (unlikely(ret < 0))	1090	if (unlikely(ret < 0))
1092	goto nfattr_failure;	1091	goto nfattr_failure;
1093		1092
1094	proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum);	1093	proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum);
1095	ret = ctnetlink_dump_tuples_proto(skb, mask, proto);	1094	ret = ctnetlink_dump_tuples_proto(skb, mask, proto);
1096	nf_ct_proto_put(proto);	1095	nf_ct_proto_put(proto);
1097	if (unlikely(ret < 0))	1096	if (unlikely(ret < 0))
1098	goto nfattr_failure;	1097	goto nfattr_failure;
1099		1098
1100	NFA_NEST_END(skb, nest_parms);	1099	NFA_NEST_END(skb, nest_parms);
1101		1100
1102	return 0;	1101	return 0;
1103		1102
1104	nfattr_failure:	1103	nfattr_failure:
1105	return -1;	1104	return -1;
1106	}	1105	}
1107		1106
1108	static inline int	1107	static inline int
1109	ctnetlink_exp_dump_expect(struct sk_buff *skb,	1108	ctnetlink_exp_dump_expect(struct sk_buff *skb,
1110	const struct nf_conntrack_expect *exp)	1109	const struct nf_conntrack_expect *exp)
1111	{	1110	{
1112	struct nf_conn *master = exp->master;	1111	struct nf_conn *master = exp->master;
1113	u_int32_t timeout = htonl((exp->timeout.expires - jiffies) / HZ);	1112	u_int32_t timeout = htonl((exp->timeout.expires - jiffies) / HZ);
1114	u_int32_t id = htonl(exp->id);	1113	u_int32_t id = htonl(exp->id);
1115		1114
1116	if (ctnetlink_exp_dump_tuple(skb, &exp->tuple, CTA_EXPECT_TUPLE) < 0)	1115	if (ctnetlink_exp_dump_tuple(skb, &exp->tuple, CTA_EXPECT_TUPLE) < 0)
1117	goto nfattr_failure;	1116	goto nfattr_failure;
1118	if (ctnetlink_exp_dump_mask(skb, &exp->tuple, &exp->mask) < 0)	1117	if (ctnetlink_exp_dump_mask(skb, &exp->tuple, &exp->mask) < 0)
1119	goto nfattr_failure;	1118	goto nfattr_failure;
1120	if (ctnetlink_exp_dump_tuple(skb,	1119	if (ctnetlink_exp_dump_tuple(skb,
1121	&master->tuplehash[IP_CT_DIR_ORIGINAL].tuple,	1120	&master->tuplehash[IP_CT_DIR_ORIGINAL].tuple,
1122	CTA_EXPECT_MASTER) < 0)	1121	CTA_EXPECT_MASTER) < 0)
1123	goto nfattr_failure;	1122	goto nfattr_failure;
1124		1123
1125	NFA_PUT(skb, CTA_EXPECT_TIMEOUT, sizeof(timeout), &timeout);	1124	NFA_PUT(skb, CTA_EXPECT_TIMEOUT, sizeof(timeout), &timeout);
1126	NFA_PUT(skb, CTA_EXPECT_ID, sizeof(u_int32_t), &id);	1125	NFA_PUT(skb, CTA_EXPECT_ID, sizeof(u_int32_t), &id);
1127		1126
1128	return 0;	1127	return 0;
1129		1128
1130	nfattr_failure:	1129	nfattr_failure:
1131	return -1;	1130	return -1;
1132	}	1131	}
1133		1132
1134	static int	1133	static int
1135	ctnetlink_exp_fill_info(struct sk_buff *skb, u32 pid, u32 seq,	1134	ctnetlink_exp_fill_info(struct sk_buff *skb, u32 pid, u32 seq,
1136	int event,	1135	int event,
1137	int nowait,	1136	int nowait,
1138	const struct nf_conntrack_expect *exp)	1137	const struct nf_conntrack_expect *exp)
1139	{	1138	{
1140	struct nlmsghdr *nlh;	1139	struct nlmsghdr *nlh;
1141	struct nfgenmsg *nfmsg;	1140	struct nfgenmsg *nfmsg;
1142	unsigned char *b;	1141	unsigned char *b;
1143		1142
1144	b = skb->tail;	1143	b = skb->tail;
1145		1144
1146	event \|= NFNL_SUBSYS_CTNETLINK_EXP << 8;	1145	event \|= NFNL_SUBSYS_CTNETLINK_EXP << 8;
1147	nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));	1146	nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg));
1148	nfmsg = NLMSG_DATA(nlh);	1147	nfmsg = NLMSG_DATA(nlh);
1149		1148
1150	nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0;	1149	nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0;
1151	nfmsg->nfgen_family = exp->tuple.src.l3num;	1150	nfmsg->nfgen_family = exp->tuple.src.l3num;
1152	nfmsg->version = NFNETLINK_V0;	1151	nfmsg->version = NFNETLINK_V0;
1153	nfmsg->res_id = 0;	1152	nfmsg->res_id = 0;
1154		1153
1155	if (ctnetlink_exp_dump_expect(skb, exp) < 0)	1154	if (ctnetlink_exp_dump_expect(skb, exp) < 0)
1156	goto nfattr_failure;	1155	goto nfattr_failure;
1157		1156
1158	nlh->nlmsg_len = skb->tail - b;	1157	nlh->nlmsg_len = skb->tail - b;
1159	return skb->len;	1158	return skb->len;
1160		1159
1161	nlmsg_failure:	1160	nlmsg_failure:
1162	nfattr_failure:	1161	nfattr_failure:
1163	skb_trim(skb, b - skb->data);	1162	skb_trim(skb, b - skb->data);
1164	return -1;	1163	return -1;
1165	}	1164	}
1166		1165
1167	#ifdef CONFIG_NF_CONNTRACK_EVENTS	1166	#ifdef CONFIG_NF_CONNTRACK_EVENTS
1168	static int ctnetlink_expect_event(struct notifier_block *this,	1167	static int ctnetlink_expect_event(struct notifier_block *this,
1169	unsigned long events, void *ptr)	1168	unsigned long events, void *ptr)
1170	{	1169	{
1171	struct nlmsghdr *nlh;	1170	struct nlmsghdr *nlh;
1172	struct nfgenmsg *nfmsg;	1171	struct nfgenmsg *nfmsg;
1173	struct nf_conntrack_expect exp = (struct nf_conntrack_expect )ptr;	1172	struct nf_conntrack_expect exp = (struct nf_conntrack_expect )ptr;
1174	struct sk_buff *skb;	1173	struct sk_buff *skb;
1175	unsigned int type;	1174	unsigned int type;
1176	unsigned char *b;	1175	unsigned char *b;
1177	int flags = 0;	1176	int flags = 0;
1178		1177
1179	if (events & IPEXP_NEW) {	1178	if (events & IPEXP_NEW) {
1180	type = IPCTNL_MSG_EXP_NEW;	1179	type = IPCTNL_MSG_EXP_NEW;
1181	flags = NLM_F_CREATE\|NLM_F_EXCL;	1180	flags = NLM_F_CREATE\|NLM_F_EXCL;
1182	} else	1181	} else
1183	return NOTIFY_DONE;	1182	return NOTIFY_DONE;
1184		1183
1185	if (!nfnetlink_has_listeners(NFNLGRP_CONNTRACK_EXP_NEW))	1184	if (!nfnetlink_has_listeners(NFNLGRP_CONNTRACK_EXP_NEW))
1186	return NOTIFY_DONE;	1185	return NOTIFY_DONE;
1187		1186
1188	skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);	1187	skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
1189	if (!skb)	1188	if (!skb)
1190	return NOTIFY_DONE;	1189	return NOTIFY_DONE;
1191		1190
1192	b = skb->tail;	1191	b = skb->tail;
1193		1192
1194	type \|= NFNL_SUBSYS_CTNETLINK_EXP << 8;	1193	type \|= NFNL_SUBSYS_CTNETLINK_EXP << 8;
1195	nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg));	1194	nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg));
1196	nfmsg = NLMSG_DATA(nlh);	1195	nfmsg = NLMSG_DATA(nlh);
1197		1196
1198	nlh->nlmsg_flags = flags;	1197	nlh->nlmsg_flags = flags;
1199	nfmsg->nfgen_family = exp->tuple.src.l3num;	1198	nfmsg->nfgen_family = exp->tuple.src.l3num;
1200	nfmsg->version = NFNETLINK_V0;	1199	nfmsg->version = NFNETLINK_V0;
1201	nfmsg->res_id = 0;	1200	nfmsg->res_id = 0;
1202		1201
1203	if (ctnetlink_exp_dump_expect(skb, exp) < 0)	1202	if (ctnetlink_exp_dump_expect(skb, exp) < 0)
1204	goto nfattr_failure;	1203	goto nfattr_failure;
1205		1204
1206	nlh->nlmsg_len = skb->tail - b;	1205	nlh->nlmsg_len = skb->tail - b;
1207	nfnetlink_send(skb, 0, NFNLGRP_CONNTRACK_EXP_NEW, 0);	1206	nfnetlink_send(skb, 0, NFNLGRP_CONNTRACK_EXP_NEW, 0);
1208	return NOTIFY_DONE;	1207	return NOTIFY_DONE;
1209		1208
1210	nlmsg_failure:	1209	nlmsg_failure:
1211	nfattr_failure:	1210	nfattr_failure:
1212	kfree_skb(skb);	1211	kfree_skb(skb);
1213	return NOTIFY_DONE;	1212	return NOTIFY_DONE;
1214	}	1213	}
1215	#endif	1214	#endif
1216		1215
1217	static int	1216	static int
1218	ctnetlink_exp_dump_table(struct sk_buff skb, struct netlink_callback cb)	1217	ctnetlink_exp_dump_table(struct sk_buff skb, struct netlink_callback cb)
1219	{	1218	{
1220	struct nf_conntrack_expect *exp = NULL;	1219	struct nf_conntrack_expect *exp = NULL;
1221	struct list_head *i;	1220	struct list_head *i;
1222	u_int32_t id = (u_int32_t ) &cb->args[0];	1221	u_int32_t id = (u_int32_t ) &cb->args[0];
1223	struct nfgenmsg *nfmsg = NLMSG_DATA(cb->nlh);	1222	struct nfgenmsg *nfmsg = NLMSG_DATA(cb->nlh);
1224	u_int8_t l3proto = nfmsg->nfgen_family;	1223	u_int8_t l3proto = nfmsg->nfgen_family;
1225		1224
1226	read_lock_bh(&nf_conntrack_lock);	1225	read_lock_bh(&nf_conntrack_lock);
1227	list_for_each_prev(i, &nf_conntrack_expect_list) {	1226	list_for_each_prev(i, &nf_conntrack_expect_list) {
1228	exp = (struct nf_conntrack_expect *) i;	1227	exp = (struct nf_conntrack_expect *) i;
1229	if (l3proto && exp->tuple.src.l3num != l3proto)	1228	if (l3proto && exp->tuple.src.l3num != l3proto)
1230	continue;	1229	continue;
1231	if (exp->id <= *id)	1230	if (exp->id <= *id)
1232	continue;	1231	continue;
1233	if (ctnetlink_exp_fill_info(skb, NETLINK_CB(cb->skb).pid,	1232	if (ctnetlink_exp_fill_info(skb, NETLINK_CB(cb->skb).pid,
1234	cb->nlh->nlmsg_seq,	1233	cb->nlh->nlmsg_seq,
1235	IPCTNL_MSG_EXP_NEW,	1234	IPCTNL_MSG_EXP_NEW,
1236	1, exp) < 0)	1235	1, exp) < 0)
1237	goto out;	1236	goto out;
1238	*id = exp->id;	1237	*id = exp->id;
1239	}	1238	}
1240	out:	1239	out:
1241	read_unlock_bh(&nf_conntrack_lock);	1240	read_unlock_bh(&nf_conntrack_lock);
1242		1241
1243	return skb->len;	1242	return skb->len;
1244	}	1243	}
1245		1244
1246	static const size_t cta_min_exp[CTA_EXPECT_MAX] = {	1245	static const size_t cta_min_exp[CTA_EXPECT_MAX] = {
1247	[CTA_EXPECT_TIMEOUT-1] = sizeof(u_int32_t),	1246	[CTA_EXPECT_TIMEOUT-1] = sizeof(u_int32_t),
1248	[CTA_EXPECT_ID-1] = sizeof(u_int32_t)	1247	[CTA_EXPECT_ID-1] = sizeof(u_int32_t)
1249	};	1248	};
1250		1249
1251	static int	1250	static int
1252	ctnetlink_get_expect(struct sock ctnl, struct sk_buff skb,	1251	ctnetlink_get_expect(struct sock ctnl, struct sk_buff skb,
1253	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	1252	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
1254	{	1253	{
1255	struct nf_conntrack_tuple tuple;	1254	struct nf_conntrack_tuple tuple;
1256	struct nf_conntrack_expect *exp;	1255	struct nf_conntrack_expect *exp;
1257	struct sk_buff *skb2;	1256	struct sk_buff *skb2;
1258	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);	1257	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
1259	u_int8_t u3 = nfmsg->nfgen_family;	1258	u_int8_t u3 = nfmsg->nfgen_family;
1260	int err = 0;	1259	int err = 0;
1261		1260
1262	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))	1261	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))
1263	return -EINVAL;	1262	return -EINVAL;
1264		1263
1265	if (nlh->nlmsg_flags & NLM_F_DUMP) {	1264	if (nlh->nlmsg_flags & NLM_F_DUMP) {
1266	u32 rlen;	1265	u32 rlen;
1267		1266
1268	if ((*errp = netlink_dump_start(ctnl, skb, nlh,	1267	if ((*errp = netlink_dump_start(ctnl, skb, nlh,
1269	ctnetlink_exp_dump_table,	1268	ctnetlink_exp_dump_table,
1270	ctnetlink_done)) != 0)	1269	ctnetlink_done)) != 0)
1271	return -EINVAL;	1270	return -EINVAL;
1272	rlen = NLMSG_ALIGN(nlh->nlmsg_len);	1271	rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1273	if (rlen > skb->len)	1272	if (rlen > skb->len)
1274	rlen = skb->len;	1273	rlen = skb->len;
1275	skb_pull(skb, rlen);	1274	skb_pull(skb, rlen);
1276	return 0;	1275	return 0;
1277	}	1276	}
1278		1277
1279	if (cda[CTA_EXPECT_MASTER-1])	1278	if (cda[CTA_EXPECT_MASTER-1])
1280	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_MASTER, u3);	1279	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_MASTER, u3);
1281	else	1280	else
1282	return -EINVAL;	1281	return -EINVAL;
1283		1282
1284	if (err < 0)	1283	if (err < 0)
1285	return err;	1284	return err;
1286		1285
1287	exp = nf_conntrack_expect_find(&tuple);	1286	exp = nf_conntrack_expect_find(&tuple);
1288	if (!exp)	1287	if (!exp)
1289	return -ENOENT;	1288	return -ENOENT;
1290		1289
1291	if (cda[CTA_EXPECT_ID-1]) {	1290	if (cda[CTA_EXPECT_ID-1]) {
1292	u_int32_t id = (u_int32_t )NFA_DATA(cda[CTA_EXPECT_ID-1]);	1291	u_int32_t id = (u_int32_t )NFA_DATA(cda[CTA_EXPECT_ID-1]);
1293	if (exp->id != ntohl(id)) {	1292	if (exp->id != ntohl(id)) {
1294	nf_conntrack_expect_put(exp);	1293	nf_conntrack_expect_put(exp);
1295	return -ENOENT;	1294	return -ENOENT;
1296	}	1295	}
1297	}	1296	}
1298		1297
1299	err = -ENOMEM;	1298	err = -ENOMEM;
1300	skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);	1299	skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1301	if (!skb2)	1300	if (!skb2)
1302	goto out;	1301	goto out;
1303	NETLINK_CB(skb2).dst_pid = NETLINK_CB(skb).pid;	1302
1304
1305	err = ctnetlink_exp_fill_info(skb2, NETLINK_CB(skb).pid,	1303	err = ctnetlink_exp_fill_info(skb2, NETLINK_CB(skb).pid,
1306	nlh->nlmsg_seq, IPCTNL_MSG_EXP_NEW,	1304	nlh->nlmsg_seq, IPCTNL_MSG_EXP_NEW,
1307	1, exp);	1305	1, exp);
1308	if (err <= 0)	1306	if (err <= 0)
1309	goto free;	1307	goto free;
1310		1308
1311	nf_conntrack_expect_put(exp);	1309	nf_conntrack_expect_put(exp);
1312		1310
1313	return netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);	1311	return netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1314		1312
1315	free:	1313	free:
1316	kfree_skb(skb2);	1314	kfree_skb(skb2);
1317	out:	1315	out:
1318	nf_conntrack_expect_put(exp);	1316	nf_conntrack_expect_put(exp);
1319	return err;	1317	return err;
1320	}	1318	}
1321		1319
1322	static int	1320	static int
1323	ctnetlink_del_expect(struct sock ctnl, struct sk_buff skb,	1321	ctnetlink_del_expect(struct sock ctnl, struct sk_buff skb,
1324	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	1322	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
1325	{	1323	{
1326	struct nf_conntrack_expect exp, tmp;	1324	struct nf_conntrack_expect exp, tmp;
1327	struct nf_conntrack_tuple tuple;	1325	struct nf_conntrack_tuple tuple;
1328	struct nf_conntrack_helper *h;	1326	struct nf_conntrack_helper *h;
1329	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);	1327	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
1330	u_int8_t u3 = nfmsg->nfgen_family;	1328	u_int8_t u3 = nfmsg->nfgen_family;
1331	int err;	1329	int err;
1332		1330
1333	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))	1331	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))
1334	return -EINVAL;	1332	return -EINVAL;
1335		1333
1336	if (cda[CTA_EXPECT_TUPLE-1]) {	1334	if (cda[CTA_EXPECT_TUPLE-1]) {
1337	/* delete a single expect by tuple */	1335	/* delete a single expect by tuple */
1338	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3);	1336	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3);
1339	if (err < 0)	1337	if (err < 0)
1340	return err;	1338	return err;
1341		1339
1342	/* bump usage count to 2 */	1340	/* bump usage count to 2 */
1343	exp = nf_conntrack_expect_find(&tuple);	1341	exp = nf_conntrack_expect_find(&tuple);
1344	if (!exp)	1342	if (!exp)
1345	return -ENOENT;	1343	return -ENOENT;
1346		1344
1347	if (cda[CTA_EXPECT_ID-1]) {	1345	if (cda[CTA_EXPECT_ID-1]) {
1348	u_int32_t id =	1346	u_int32_t id =
1349	(u_int32_t )NFA_DATA(cda[CTA_EXPECT_ID-1]);	1347	(u_int32_t )NFA_DATA(cda[CTA_EXPECT_ID-1]);
1350	if (exp->id != ntohl(id)) {	1348	if (exp->id != ntohl(id)) {
1351	nf_conntrack_expect_put(exp);	1349	nf_conntrack_expect_put(exp);
1352	return -ENOENT;	1350	return -ENOENT;
1353	}	1351	}
1354	}	1352	}
1355		1353
1356	/* after list removal, usage count == 1 */	1354	/* after list removal, usage count == 1 */
1357	nf_conntrack_unexpect_related(exp);	1355	nf_conntrack_unexpect_related(exp);
1358	/* have to put what we 'get' above.	1356	/* have to put what we 'get' above.
1359	* after this line usage count == 0 */	1357	* after this line usage count == 0 */
1360	nf_conntrack_expect_put(exp);	1358	nf_conntrack_expect_put(exp);
1361	} else if (cda[CTA_EXPECT_HELP_NAME-1]) {	1359	} else if (cda[CTA_EXPECT_HELP_NAME-1]) {
1362	char *name = NFA_DATA(cda[CTA_EXPECT_HELP_NAME-1]);	1360	char *name = NFA_DATA(cda[CTA_EXPECT_HELP_NAME-1]);
1363		1361
1364	/* delete all expectations for this helper */	1362	/* delete all expectations for this helper */
1365	write_lock_bh(&nf_conntrack_lock);	1363	write_lock_bh(&nf_conntrack_lock);
1366	h = __nf_conntrack_helper_find_byname(name);	1364	h = __nf_conntrack_helper_find_byname(name);
1367	if (!h) {	1365	if (!h) {
1368	write_unlock_bh(&nf_conntrack_lock);	1366	write_unlock_bh(&nf_conntrack_lock);
1369	return -EINVAL;	1367	return -EINVAL;
1370	}	1368	}
1371	list_for_each_entry_safe(exp, tmp, &nf_conntrack_expect_list,	1369	list_for_each_entry_safe(exp, tmp, &nf_conntrack_expect_list,
1372	list) {	1370	list) {
1373	struct nf_conn_help *m_help = nfct_help(exp->master);	1371	struct nf_conn_help *m_help = nfct_help(exp->master);
1374	if (m_help->helper == h	1372	if (m_help->helper == h
1375	&& del_timer(&exp->timeout)) {	1373	&& del_timer(&exp->timeout)) {
1376	nf_ct_unlink_expect(exp);	1374	nf_ct_unlink_expect(exp);
1377	nf_conntrack_expect_put(exp);	1375	nf_conntrack_expect_put(exp);
1378	}	1376	}
1379	}	1377	}
1380	write_unlock_bh(&nf_conntrack_lock);	1378	write_unlock_bh(&nf_conntrack_lock);
1381	} else {	1379	} else {
1382	/* This basically means we have to flush everything*/	1380	/* This basically means we have to flush everything*/
1383	write_lock_bh(&nf_conntrack_lock);	1381	write_lock_bh(&nf_conntrack_lock);
1384	list_for_each_entry_safe(exp, tmp, &nf_conntrack_expect_list,	1382	list_for_each_entry_safe(exp, tmp, &nf_conntrack_expect_list,
1385	list) {	1383	list) {
1386	if (del_timer(&exp->timeout)) {	1384	if (del_timer(&exp->timeout)) {
1387	nf_ct_unlink_expect(exp);	1385	nf_ct_unlink_expect(exp);
1388	nf_conntrack_expect_put(exp);	1386	nf_conntrack_expect_put(exp);
1389	}	1387	}
1390	}	1388	}
1391	write_unlock_bh(&nf_conntrack_lock);	1389	write_unlock_bh(&nf_conntrack_lock);
1392	}	1390	}
1393		1391
1394	return 0;	1392	return 0;
1395	}	1393	}
1396	static int	1394	static int
1397	ctnetlink_change_expect(struct nf_conntrack_expect x, struct nfattr cda[])	1395	ctnetlink_change_expect(struct nf_conntrack_expect x, struct nfattr cda[])
1398	{	1396	{
1399	return -EOPNOTSUPP;	1397	return -EOPNOTSUPP;
1400	}	1398	}
1401		1399
1402	static int	1400	static int
1403	ctnetlink_create_expect(struct nfattr *cda[], u_int8_t u3)	1401	ctnetlink_create_expect(struct nfattr *cda[], u_int8_t u3)
1404	{	1402	{
1405	struct nf_conntrack_tuple tuple, mask, master_tuple;	1403	struct nf_conntrack_tuple tuple, mask, master_tuple;
1406	struct nf_conntrack_tuple_hash *h = NULL;	1404	struct nf_conntrack_tuple_hash *h = NULL;
1407	struct nf_conntrack_expect *exp;	1405	struct nf_conntrack_expect *exp;
1408	struct nf_conn *ct;	1406	struct nf_conn *ct;
1409	struct nf_conn_help *help;	1407	struct nf_conn_help *help;
1410	int err = 0;	1408	int err = 0;
1411		1409
1412	/* caller guarantees that those three CTA_EXPECT_* exist */	1410	/* caller guarantees that those three CTA_EXPECT_* exist */
1413	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3);	1411	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3);
1414	if (err < 0)	1412	if (err < 0)
1415	return err;	1413	return err;
1416	err = ctnetlink_parse_tuple(cda, &mask, CTA_EXPECT_MASK, u3);	1414	err = ctnetlink_parse_tuple(cda, &mask, CTA_EXPECT_MASK, u3);
1417	if (err < 0)	1415	if (err < 0)
1418	return err;	1416	return err;
1419	err = ctnetlink_parse_tuple(cda, &master_tuple, CTA_EXPECT_MASTER, u3);	1417	err = ctnetlink_parse_tuple(cda, &master_tuple, CTA_EXPECT_MASTER, u3);
1420	if (err < 0)	1418	if (err < 0)
1421	return err;	1419	return err;
1422		1420
1423	/* Look for master conntrack of this expectation */	1421	/* Look for master conntrack of this expectation */
1424	h = nf_conntrack_find_get(&master_tuple, NULL);	1422	h = nf_conntrack_find_get(&master_tuple, NULL);
1425	if (!h)	1423	if (!h)
1426	return -ENOENT;	1424	return -ENOENT;
1427	ct = nf_ct_tuplehash_to_ctrack(h);	1425	ct = nf_ct_tuplehash_to_ctrack(h);
1428	help = nfct_help(ct);	1426	help = nfct_help(ct);
1429		1427
1430	if (!help \|\| !help->helper) {	1428	if (!help \|\| !help->helper) {
1431	/* such conntrack hasn't got any helper, abort */	1429	/* such conntrack hasn't got any helper, abort */
1432	err = -EINVAL;	1430	err = -EINVAL;
1433	goto out;	1431	goto out;
1434	}	1432	}
1435		1433
1436	exp = nf_conntrack_expect_alloc(ct);	1434	exp = nf_conntrack_expect_alloc(ct);
1437	if (!exp) {	1435	if (!exp) {
1438	err = -ENOMEM;	1436	err = -ENOMEM;
1439	goto out;	1437	goto out;
1440	}	1438	}
1441		1439
1442	exp->expectfn = NULL;	1440	exp->expectfn = NULL;
1443	exp->flags = 0;	1441	exp->flags = 0;
1444	exp->master = ct;	1442	exp->master = ct;
1445	memcpy(&exp->tuple, &tuple, sizeof(struct nf_conntrack_tuple));	1443	memcpy(&exp->tuple, &tuple, sizeof(struct nf_conntrack_tuple));
1446	memcpy(&exp->mask, &mask, sizeof(struct nf_conntrack_tuple));	1444	memcpy(&exp->mask, &mask, sizeof(struct nf_conntrack_tuple));
1447		1445
1448	err = nf_conntrack_expect_related(exp);	1446	err = nf_conntrack_expect_related(exp);
1449	nf_conntrack_expect_put(exp);	1447	nf_conntrack_expect_put(exp);
1450		1448
1451	out:	1449	out:
1452	nf_ct_put(nf_ct_tuplehash_to_ctrack(h));	1450	nf_ct_put(nf_ct_tuplehash_to_ctrack(h));
1453	return err;	1451	return err;
1454	}	1452	}
1455		1453
1456	static int	1454	static int
1457	ctnetlink_new_expect(struct sock ctnl, struct sk_buff skb,	1455	ctnetlink_new_expect(struct sock ctnl, struct sk_buff skb,
1458	struct nlmsghdr nlh, struct nfattr cda[], int *errp)	1456	struct nlmsghdr nlh, struct nfattr cda[], int *errp)
1459	{	1457	{
1460	struct nf_conntrack_tuple tuple;	1458	struct nf_conntrack_tuple tuple;
1461	struct nf_conntrack_expect *exp;	1459	struct nf_conntrack_expect *exp;
1462	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);	1460	struct nfgenmsg *nfmsg = NLMSG_DATA(nlh);
1463	u_int8_t u3 = nfmsg->nfgen_family;	1461	u_int8_t u3 = nfmsg->nfgen_family;
1464	int err = 0;	1462	int err = 0;
1465		1463
1466	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))	1464	if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp))
1467	return -EINVAL;	1465	return -EINVAL;
1468		1466
1469	if (!cda[CTA_EXPECT_TUPLE-1]	1467	if (!cda[CTA_EXPECT_TUPLE-1]
1470	\|\| !cda[CTA_EXPECT_MASK-1]	1468	\|\| !cda[CTA_EXPECT_MASK-1]
1471	\|\| !cda[CTA_EXPECT_MASTER-1])	1469	\|\| !cda[CTA_EXPECT_MASTER-1])
1472	return -EINVAL;	1470	return -EINVAL;
1473		1471
1474	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3);	1472	err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3);
1475	if (err < 0)	1473	if (err < 0)
1476	return err;	1474	return err;
1477		1475
1478	write_lock_bh(&nf_conntrack_lock);	1476	write_lock_bh(&nf_conntrack_lock);
1479	exp = __nf_conntrack_expect_find(&tuple);	1477	exp = __nf_conntrack_expect_find(&tuple);
1480		1478
1481	if (!exp) {	1479	if (!exp) {
1482	write_unlock_bh(&nf_conntrack_lock);	1480	write_unlock_bh(&nf_conntrack_lock);
1483	err = -ENOENT;	1481	err = -ENOENT;
1484	if (nlh->nlmsg_flags & NLM_F_CREATE)	1482	if (nlh->nlmsg_flags & NLM_F_CREATE)
1485	err = ctnetlink_create_expect(cda, u3);	1483	err = ctnetlink_create_expect(cda, u3);
1486	return err;	1484	return err;
1487	}	1485	}
1488		1486
1489	err = -EEXIST;	1487	err = -EEXIST;
1490	if (!(nlh->nlmsg_flags & NLM_F_EXCL))	1488	if (!(nlh->nlmsg_flags & NLM_F_EXCL))
1491	err = ctnetlink_change_expect(exp, cda);	1489	err = ctnetlink_change_expect(exp, cda);
1492	write_unlock_bh(&nf_conntrack_lock);	1490	write_unlock_bh(&nf_conntrack_lock);
1493		1491
1494	return err;	1492	return err;
1495	}	1493	}
1496		1494
1497	#ifdef CONFIG_NF_CONNTRACK_EVENTS	1495	#ifdef CONFIG_NF_CONNTRACK_EVENTS
1498	static struct notifier_block ctnl_notifier = {	1496	static struct notifier_block ctnl_notifier = {
1499	.notifier_call = ctnetlink_conntrack_event,	1497	.notifier_call = ctnetlink_conntrack_event,
1500	};	1498	};
1501		1499
1502	static struct notifier_block ctnl_notifier_exp = {	1500	static struct notifier_block ctnl_notifier_exp = {
1503	.notifier_call = ctnetlink_expect_event,	1501	.notifier_call = ctnetlink_expect_event,
1504	};	1502	};
1505	#endif	1503	#endif
1506		1504
1507	static struct nfnl_callback ctnl_cb[IPCTNL_MSG_MAX] = {	1505	static struct nfnl_callback ctnl_cb[IPCTNL_MSG_MAX] = {
1508	[IPCTNL_MSG_CT_NEW] = { .call = ctnetlink_new_conntrack,	1506	[IPCTNL_MSG_CT_NEW] = { .call = ctnetlink_new_conntrack,
1509	.attr_count = CTA_MAX, },	1507	.attr_count = CTA_MAX, },
1510	[IPCTNL_MSG_CT_GET] = { .call = ctnetlink_get_conntrack,	1508	[IPCTNL_MSG_CT_GET] = { .call = ctnetlink_get_conntrack,
1511	.attr_count = CTA_MAX, },	1509	.attr_count = CTA_MAX, },
1512	[IPCTNL_MSG_CT_DELETE] = { .call = ctnetlink_del_conntrack,	1510	[IPCTNL_MSG_CT_DELETE] = { .call = ctnetlink_del_conntrack,
1513	.attr_count = CTA_MAX, },	1511	.attr_count = CTA_MAX, },
1514	[IPCTNL_MSG_CT_GET_CTRZERO] = { .call = ctnetlink_get_conntrack,	1512	[IPCTNL_MSG_CT_GET_CTRZERO] = { .call = ctnetlink_get_conntrack,
1515	.attr_count = CTA_MAX, },	1513	.attr_count = CTA_MAX, },
1516	};	1514	};
1517		1515
1518	static struct nfnl_callback ctnl_exp_cb[IPCTNL_MSG_EXP_MAX] = {	1516	static struct nfnl_callback ctnl_exp_cb[IPCTNL_MSG_EXP_MAX] = {
1519	[IPCTNL_MSG_EXP_GET] = { .call = ctnetlink_get_expect,	1517	[IPCTNL_MSG_EXP_GET] = { .call = ctnetlink_get_expect,
1520	.attr_count = CTA_EXPECT_MAX, },	1518	.attr_count = CTA_EXPECT_MAX, },
1521	[IPCTNL_MSG_EXP_NEW] = { .call = ctnetlink_new_expect,	1519	[IPCTNL_MSG_EXP_NEW] = { .call = ctnetlink_new_expect,
1522	.attr_count = CTA_EXPECT_MAX, },	1520	.attr_count = CTA_EXPECT_MAX, },
1523	[IPCTNL_MSG_EXP_DELETE] = { .call = ctnetlink_del_expect,	1521	[IPCTNL_MSG_EXP_DELETE] = { .call = ctnetlink_del_expect,
1524	.attr_count = CTA_EXPECT_MAX, },	1522	.attr_count = CTA_EXPECT_MAX, },
1525	};	1523	};
1526		1524
1527	static struct nfnetlink_subsystem ctnl_subsys = {	1525	static struct nfnetlink_subsystem ctnl_subsys = {
1528	.name = "conntrack",	1526	.name = "conntrack",
1529	.subsys_id = NFNL_SUBSYS_CTNETLINK,	1527	.subsys_id = NFNL_SUBSYS_CTNETLINK,
1530	.cb_count = IPCTNL_MSG_MAX,	1528	.cb_count = IPCTNL_MSG_MAX,
1531	.cb = ctnl_cb,	1529	.cb = ctnl_cb,
1532	};	1530	};
1533		1531
1534	static struct nfnetlink_subsystem ctnl_exp_subsys = {	1532	static struct nfnetlink_subsystem ctnl_exp_subsys = {
1535	.name = "conntrack_expect",	1533	.name = "conntrack_expect",
1536	.subsys_id = NFNL_SUBSYS_CTNETLINK_EXP,	1534	.subsys_id = NFNL_SUBSYS_CTNETLINK_EXP,
1537	.cb_count = IPCTNL_MSG_EXP_MAX,	1535	.cb_count = IPCTNL_MSG_EXP_MAX,
1538	.cb = ctnl_exp_cb,	1536	.cb = ctnl_exp_cb,
1539	};	1537	};
1540		1538
1541	MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK);	1539	MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK);
1542	MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK_EXP);	1540	MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK_EXP);
1543		1541
1544	static int __init ctnetlink_init(void)	1542	static int __init ctnetlink_init(void)
1545	{	1543	{
1546	int ret;	1544	int ret;
1547		1545
1548	printk("ctnetlink v%s: registering with nfnetlink.\n", version);	1546	printk("ctnetlink v%s: registering with nfnetlink.\n", version);
1549	ret = nfnetlink_subsys_register(&ctnl_subsys);	1547	ret = nfnetlink_subsys_register(&ctnl_subsys);
1550	if (ret < 0) {	1548	if (ret < 0) {
1551	printk("ctnetlink_init: cannot register with nfnetlink.\n");	1549	printk("ctnetlink_init: cannot register with nfnetlink.\n");
1552	goto err_out;	1550	goto err_out;
1553	}	1551	}
1554		1552
1555	ret = nfnetlink_subsys_register(&ctnl_exp_subsys);	1553	ret = nfnetlink_subsys_register(&ctnl_exp_subsys);
1556	if (ret < 0) {	1554	if (ret < 0) {
1557	printk("ctnetlink_init: cannot register exp with nfnetlink.\n");	1555	printk("ctnetlink_init: cannot register exp with nfnetlink.\n");
1558	goto err_unreg_subsys;	1556	goto err_unreg_subsys;
1559	}	1557	}
1560		1558
1561	#ifdef CONFIG_NF_CONNTRACK_EVENTS	1559	#ifdef CONFIG_NF_CONNTRACK_EVENTS
1562	ret = nf_conntrack_register_notifier(&ctnl_notifier);	1560	ret = nf_conntrack_register_notifier(&ctnl_notifier);
1563	if (ret < 0) {	1561	if (ret < 0) {
1564	printk("ctnetlink_init: cannot register notifier.\n");	1562	printk("ctnetlink_init: cannot register notifier.\n");
1565	goto err_unreg_exp_subsys;	1563	goto err_unreg_exp_subsys;
1566	}	1564	}
1567		1565
1568	ret = nf_conntrack_expect_register_notifier(&ctnl_notifier_exp);	1566	ret = nf_conntrack_expect_register_notifier(&ctnl_notifier_exp);
1569	if (ret < 0) {	1567	if (ret < 0) {
1570	printk("ctnetlink_init: cannot expect register notifier.\n");	1568	printk("ctnetlink_init: cannot expect register notifier.\n");
1571	goto err_unreg_notifier;	1569	goto err_unreg_notifier;
1572	}	1570	}
1573	#endif	1571	#endif
1574		1572
1575	return 0;	1573	return 0;
1576		1574
1577	#ifdef CONFIG_NF_CONNTRACK_EVENTS	1575	#ifdef CONFIG_NF_CONNTRACK_EVENTS
1578	err_unreg_notifier:	1576	err_unreg_notifier:
1579	nf_conntrack_unregister_notifier(&ctnl_notifier);	1577	nf_conntrack_unregister_notifier(&ctnl_notifier);
1580	err_unreg_exp_subsys:	1578	err_unreg_exp_subsys:
1581	nfnetlink_subsys_unregister(&ctnl_exp_subsys);	1579	nfnetlink_subsys_unregister(&ctnl_exp_subsys);
1582	#endif	1580	#endif
1583	err_unreg_subsys:	1581	err_unreg_subsys:
1584	nfnetlink_subsys_unregister(&ctnl_subsys);	1582	nfnetlink_subsys_unregister(&ctnl_subsys);
1585	err_out:	1583	err_out:
1586	return ret;	1584	return ret;
1587	}	1585	}
1588		1586
1589	static void __exit ctnetlink_exit(void)	1587	static void __exit ctnetlink_exit(void)
1590	{	1588	{
1591	printk("ctnetlink: unregistering from nfnetlink.\n");	1589	printk("ctnetlink: unregistering from nfnetlink.\n");
1592		1590
1593	#ifdef CONFIG_NF_CONNTRACK_EVENTS	1591	#ifdef CONFIG_NF_CONNTRACK_EVENTS
1594	nf_conntrack_expect_unregister_notifier(&ctnl_notifier_exp);	1592	nf_conntrack_expect_unregister_notifier(&ctnl_notifier_exp);
1595	nf_conntrack_unregister_notifier(&ctnl_notifier);	1593	nf_conntrack_unregister_notifier(&ctnl_notifier);
1596	#endif	1594	#endif
1597		1595
1598	nfnetlink_subsys_unregister(&ctnl_exp_subsys);	1596	nfnetlink_subsys_unregister(&ctnl_exp_subsys);
1599	nfnetlink_subsys_unregister(&ctnl_subsys);	1597	nfnetlink_subsys_unregister(&ctnl_subsys);
1600	return;	1598	return;
1601	}	1599	}
1602		1600
1603	module_init(ctnetlink_init);	1601	module_init(ctnetlink_init);
1604	module_exit(ctnetlink_exit);	1602	module_exit(ctnetlink_exit);
1605		1603

net/netlink/af_netlink.c

Diff comments View file @ 4e9b826

 /*
  * NETLINK      Kernel-user communication protocol.
  *
  * 		Authors:	Alan Cox <alan@redhat.com>
  * 				Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
  *
  *		This program is free software; you can redistribute it and/or
  *		modify it under the terms of the GNU General Public License
  *		as published by the Free Software Foundation; either version
  *		2 of the License, or (at your option) any later version.
  *
  * Tue Jun 26 14:36:48 MEST 2001 Herbert "herp" Rosmanith
  *                               added netlink_proto_exit
  * Tue Jan 22 18:32:44 BRST 2002 Arnaldo C. de Melo <acme@conectiva.com.br>
  * 				 use nlk_sk, as sk->protinfo is on a diet 8)
  * Fri Jul 22 19:51:12 MEST 2005 Harald Welte <laforge@gnumonks.org>
  * 				 - inc module use count of module that owns
  * 				   the kernel socket in case userspace opens
  * 				   socket of same protocol
  * 				 - remove all module support, since netlink is
  * 				   mandatory if CONFIG_NET=y these days
  */
 #include <linux/module.h>
 #include <linux/capability.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/stat.h>
 #include <linux/socket.h>
 #include <linux/un.h>
 #include <linux/fcntl.h>
 #include <linux/termios.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
 #include <linux/fs.h>
 #include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/rtnetlink.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/smp_lock.h>
 #include <linux/notifier.h>
 #include <linux/security.h>
 #include <linux/jhash.h>
 #include <linux/jiffies.h>
 #include <linux/random.h>
 #include <linux/bitops.h>
 #include <linux/mm.h>
 #include <linux/types.h>
 #include <linux/audit.h>
 #include <linux/selinux.h>
 #include <net/sock.h>
 #include <net/scm.h>
 #include <net/netlink.h>
 #define NLGRPSZ(x)	(ALIGN(x, sizeof(unsigned long) * 8) / 8)
 struct netlink_sock {
 	/* struct sock has to be the first member of netlink_sock */
 	struct sock		sk;
 	u32			pid;
 	u32			dst_pid;
 	u32			dst_group;
 	u32			flags;
 	u32			subscriptions;
 	u32			ngroups;
 	unsigned long		*groups;
 	unsigned long		state;
 	wait_queue_head_t	wait;
 	struct netlink_callback	*cb;
 	spinlock_t		cb_lock;
 	void			(*data_ready)(struct sock *sk, int bytes);
 	struct module		*module;
 };
 #define NETLINK_KERNEL_SOCKET	0x1
 #define NETLINK_RECV_PKTINFO	0x2
 static inline struct netlink_sock *nlk_sk(struct sock *sk)
 {
 	return (struct netlink_sock *)sk;
 }
 struct nl_pid_hash {
 	struct hlist_head *table;
 	unsigned long rehash_time;
 	unsigned int mask;
 	unsigned int shift;
 	unsigned int entries;
 	unsigned int max_shift;
 	u32 rnd;
 };
 struct netlink_table {
 	struct nl_pid_hash hash;
 	struct hlist_head mc_list;
 	unsigned long *listeners;
 	unsigned int nl_nonroot;
 	unsigned int groups;
 	struct module *module;
 	int registered;
 };
 static struct netlink_table *nl_table;
 static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);
 static int netlink_dump(struct sock *sk);
 static void netlink_destroy_callback(struct netlink_callback *cb);
 static DEFINE_RWLOCK(nl_table_lock);
 static atomic_t nl_table_users = ATOMIC_INIT(0);
 static ATOMIC_NOTIFIER_HEAD(netlink_chain);
 static u32 netlink_group_mask(u32 group)
 {
 	return group ? 1 << (group - 1) : 0;
 }
 static struct hlist_head *nl_pid_hashfn(struct nl_pid_hash *hash, u32 pid)
 {
 	return &hash->table[jhash_1word(pid, hash->rnd) & hash->mask];
 }
 static void netlink_sock_destruct(struct sock *sk)
 {
 	skb_queue_purge(&sk->sk_receive_queue);
 	if (!sock_flag(sk, SOCK_DEAD)) {
 		printk("Freeing alive netlink socket %p\n", sk);
 		return;
 	}
 	BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
 	BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
 	BUG_TRAP(!nlk_sk(sk)->cb);
 	BUG_TRAP(!nlk_sk(sk)->groups);
 }
 /* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on SMP.
  * Look, when several writers sleep and reader wakes them up, all but one
  * immediately hit write lock and grab all the cpus. Exclusive sleep solves
  * this, _but_ remember, it adds useless work on UP machines.
  */
 static void netlink_table_grab(void)
 {
 	write_lock_irq(&nl_table_lock);
 	if (atomic_read(&nl_table_users)) {
 		DECLARE_WAITQUEUE(wait, current);
 		add_wait_queue_exclusive(&nl_table_wait, &wait);
 		for(;;) {
 			set_current_state(TASK_UNINTERRUPTIBLE);
 			if (atomic_read(&nl_table_users) == 0)
 				break;
 			write_unlock_irq(&nl_table_lock);
 			schedule();
 			write_lock_irq(&nl_table_lock);
 		}
 		__set_current_state(TASK_RUNNING);
 		remove_wait_queue(&nl_table_wait, &wait);
 	}
 }
 static __inline__ void netlink_table_ungrab(void)
 {
 	write_unlock_irq(&nl_table_lock);
 	wake_up(&nl_table_wait);
 }
 static __inline__ void
 netlink_lock_table(void)
 {
 	/* read_lock() synchronizes us to netlink_table_grab */
 	read_lock(&nl_table_lock);
 	atomic_inc(&nl_table_users);
 	read_unlock(&nl_table_lock);
 }
 static __inline__ void
 netlink_unlock_table(void)
 {
 	if (atomic_dec_and_test(&nl_table_users))
 		wake_up(&nl_table_wait);
 }
 static __inline__ struct sock *netlink_lookup(int protocol, u32 pid)
 {
 	struct nl_pid_hash *hash = &nl_table[protocol].hash;
 	struct hlist_head *head;
 	struct sock *sk;
 	struct hlist_node *node;
 	read_lock(&nl_table_lock);
 	head = nl_pid_hashfn(hash, pid);
 	sk_for_each(sk, node, head) {
 		if (nlk_sk(sk)->pid == pid) {
 			sock_hold(sk);
 			goto found;
 		}
 	}
 	sk = NULL;
 found:
 	read_unlock(&nl_table_lock);
 	return sk;
 }
 static inline struct hlist_head *nl_pid_hash_alloc(size_t size)
 {
 	if (size <= PAGE_SIZE)
 		return kmalloc(size, GFP_ATOMIC);
 	else
 		return (struct hlist_head *)
 			__get_free_pages(GFP_ATOMIC, get_order(size));
 }
 static inline void nl_pid_hash_free(struct hlist_head *table, size_t size)
 {
 	if (size <= PAGE_SIZE)
 		kfree(table);
 	else
 		free_pages((unsigned long)table, get_order(size));
 }
 static int nl_pid_hash_rehash(struct nl_pid_hash *hash, int grow)
 {
 	unsigned int omask, mask, shift;
 	size_t osize, size;
 	struct hlist_head *otable, *table;
 	int i;
 	omask = mask = hash->mask;
 	osize = size = (mask + 1) * sizeof(*table);
 	shift = hash->shift;
 	if (grow) {
 		if (++shift > hash->max_shift)
 			return 0;
 		mask = mask * 2 + 1;
 		size *= 2;
 	}
 	table = nl_pid_hash_alloc(size);
 	if (!table)
 		return 0;
 	memset(table, 0, size);
 	otable = hash->table;
 	hash->table = table;
 	hash->mask = mask;
 	hash->shift = shift;
 	get_random_bytes(&hash->rnd, sizeof(hash->rnd));
 	for (i = 0; i <= omask; i++) {
 		struct sock *sk;
 		struct hlist_node *node, *tmp;
 		sk_for_each_safe(sk, node, tmp, &otable[i])
 			__sk_add_node(sk, nl_pid_hashfn(hash, nlk_sk(sk)->pid));
 	}
 	nl_pid_hash_free(otable, osize);
 	hash->rehash_time = jiffies + 10 * 60 * HZ;
 	return 1;
 }
 static inline int nl_pid_hash_dilute(struct nl_pid_hash *hash, int len)
 {
 	int avg = hash->entries >> hash->shift;
 	if (unlikely(avg > 1) && nl_pid_hash_rehash(hash, 1))
 		return 1;
 	if (unlikely(len > avg) && time_after(jiffies, hash->rehash_time)) {
 		nl_pid_hash_rehash(hash, 0);
 		return 1;
 	}
 	return 0;
 }
 static const struct proto_ops netlink_ops;
 static void
 netlink_update_listeners(struct sock *sk)
 {
 	struct netlink_table *tbl = &nl_table[sk->sk_protocol];
 	struct hlist_node *node;
 	unsigned long mask;
 	unsigned int i;
 	for (i = 0; i < NLGRPSZ(tbl->groups)/sizeof(unsigned long); i++) {
 		mask = 0;
 		sk_for_each_bound(sk, node, &tbl->mc_list)
 			mask |= nlk_sk(sk)->groups[i];
 		tbl->listeners[i] = mask;
 	}
 	/* this function is only called with the netlink table "grabbed", which
 	 * makes sure updates are visible before bind or setsockopt return. */
 }
 static int netlink_insert(struct sock *sk, u32 pid)
 {
 	struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
 	struct hlist_head *head;
 	int err = -EADDRINUSE;
 	struct sock *osk;
 	struct hlist_node *node;
 	int len;
 	netlink_table_grab();
 	head = nl_pid_hashfn(hash, pid);
 	len = 0;
 	sk_for_each(osk, node, head) {
 		if (nlk_sk(osk)->pid == pid)
 			break;
 		len++;
 	}
 	if (node)
 		goto err;
 	err = -EBUSY;
 	if (nlk_sk(sk)->pid)
 		goto err;
 	err = -ENOMEM;
 	if (BITS_PER_LONG > 32 && unlikely(hash->entries >= UINT_MAX))
 		goto err;
 	if (len && nl_pid_hash_dilute(hash, len))
 		head = nl_pid_hashfn(hash, pid);
 	hash->entries++;
 	nlk_sk(sk)->pid = pid;
 	sk_add_node(sk, head);
 	err = 0;
 err:
 	netlink_table_ungrab();
 	return err;
 }
 static void netlink_remove(struct sock *sk)
 {
 	netlink_table_grab();
 	if (sk_del_node_init(sk))
 		nl_table[sk->sk_protocol].hash.entries--;
 	if (nlk_sk(sk)->subscriptions)
 		__sk_del_bind_node(sk);
 	netlink_table_ungrab();
 }
 static struct proto netlink_proto = {
 	.name	  = "NETLINK",
 	.owner	  = THIS_MODULE,
 	.obj_size = sizeof(struct netlink_sock),
 };
 static int __netlink_create(struct socket *sock, int protocol)
 {
 	struct sock *sk;
 	struct netlink_sock *nlk;
 	sock->ops = &netlink_ops;
 	sk = sk_alloc(PF_NETLINK, GFP_KERNEL, &netlink_proto, 1);
 	if (!sk)
 		return -ENOMEM;
 	sock_init_data(sock, sk);
 	nlk = nlk_sk(sk);
 	spin_lock_init(&nlk->cb_lock);
 	init_waitqueue_head(&nlk->wait);
 	sk->sk_destruct = netlink_sock_destruct;
 	sk->sk_protocol = protocol;
 	return 0;
 }
 static int netlink_create(struct socket *sock, int protocol)
 {
 	struct module *module = NULL;
 	struct netlink_sock *nlk;
 	unsigned int groups;
 	int err = 0;
 	sock->state = SS_UNCONNECTED;
 	if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
 		return -ESOCKTNOSUPPORT;
 	if (protocol<0 || protocol >= MAX_LINKS)
 		return -EPROTONOSUPPORT;
 	netlink_lock_table();
 #ifdef CONFIG_KMOD
 	if (!nl_table[protocol].registered) {
 		netlink_unlock_table();
 		request_module("net-pf-%d-proto-%d", PF_NETLINK, protocol);
 		netlink_lock_table();
 	}
 #endif
 	if (nl_table[protocol].registered &&
 	    try_module_get(nl_table[protocol].module))
 		module = nl_table[protocol].module;
 	groups = nl_table[protocol].groups;
 	netlink_unlock_table();
 	if ((err = __netlink_create(sock, protocol)) < 0)
 		goto out_module;
 	nlk = nlk_sk(sock->sk);
 	nlk->module = module;
 out:
 	return err;
 out_module:
 	module_put(module);
 	goto out;
 }
 static int netlink_release(struct socket *sock)
 {
 	struct sock *sk = sock->sk;
 	struct netlink_sock *nlk;
 	if (!sk)
 		return 0;
 	netlink_remove(sk);
 	nlk = nlk_sk(sk);
 	spin_lock(&nlk->cb_lock);
 	if (nlk->cb) {
 		if (nlk->cb->done)
 			nlk->cb->done(nlk->cb);
 		netlink_destroy_callback(nlk->cb);
 		nlk->cb = NULL;
 	}
 	spin_unlock(&nlk->cb_lock);
 	/* OK. Socket is unlinked, and, therefore,
 	   no new packets will arrive */
 	sock_orphan(sk);
 	sock->sk = NULL;
 	wake_up_interruptible_all(&nlk->wait);
 	skb_queue_purge(&sk->sk_write_queue);
 	if (nlk->pid && !nlk->subscriptions) {
 		struct netlink_notify n = {
 						.protocol = sk->sk_protocol,
 						.pid = nlk->pid,
 					  };
 		atomic_notifier_call_chain(&netlink_chain,
 				NETLINK_URELEASE, &n);
 	}
 	if (nlk->module)
 		module_put(nlk->module);
 	netlink_table_grab();
 	if (nlk->flags & NETLINK_KERNEL_SOCKET) {
 		kfree(nl_table[sk->sk_protocol].listeners);
 		nl_table[sk->sk_protocol].module = NULL;
 		nl_table[sk->sk_protocol].registered = 0;
 	} else if (nlk->subscriptions)
 		netlink_update_listeners(sk);
 	netlink_table_ungrab();
 	kfree(nlk->groups);
 	nlk->groups = NULL;
 	sock_put(sk);
 	return 0;
 }
 static int netlink_autobind(struct socket *sock)
 {
 	struct sock *sk = sock->sk;
 	struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
 	struct hlist_head *head;
 	struct sock *osk;
 	struct hlist_node *node;
 	s32 pid = current->tgid;
 	int err;
 	static s32 rover = -4097;
 retry:
 	cond_resched();
 	netlink_table_grab();
 	head = nl_pid_hashfn(hash, pid);
 	sk_for_each(osk, node, head) {
 		if (nlk_sk(osk)->pid == pid) {
 			/* Bind collision, search negative pid values. */
 			pid = rover--;
 			if (rover > -4097)
 				rover = -4097;
 			netlink_table_ungrab();
 			goto retry;
 		}
 	}
 	netlink_table_ungrab();
 	err = netlink_insert(sk, pid);
 	if (err == -EADDRINUSE)
 		goto retry;
 	/* If 2 threads race to autobind, that is fine.  */
 	if (err == -EBUSY)
 		err = 0;
 	return err;
 }
 static inline int netlink_capable(struct socket *sock, unsigned int flag)
 {
 	return (nl_table[sock->sk->sk_protocol].nl_nonroot & flag) ||
 	       capable(CAP_NET_ADMIN);
 }
 static void
 netlink_update_subscriptions(struct sock *sk, unsigned int subscriptions)
 {
 	struct netlink_sock *nlk = nlk_sk(sk);
 	if (nlk->subscriptions && !subscriptions)
 		__sk_del_bind_node(sk);
 	else if (!nlk->subscriptions && subscriptions)
 		sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list);
 	nlk->subscriptions = subscriptions;
 }
 static int netlink_alloc_groups(struct sock *sk)
 {
 	struct netlink_sock *nlk = nlk_sk(sk);
 	unsigned int groups;
 	int err = 0;
 	netlink_lock_table();
 	groups = nl_table[sk->sk_protocol].groups;
 	if (!nl_table[sk->sk_protocol].registered)
 		err = -ENOENT;
 	netlink_unlock_table();
 	if (err)
 		return err;
 	nlk->groups = kzalloc(NLGRPSZ(groups), GFP_KERNEL);
 	if (nlk->groups == NULL)
 		return -ENOMEM;
 	nlk->ngroups = groups;
 	return 0;
 }
 static int netlink_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 {
 	struct sock *sk = sock->sk;
 	struct netlink_sock *nlk = nlk_sk(sk);
 	struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
 	int err;
 	if (nladdr->nl_family != AF_NETLINK)
 		return -EINVAL;
 	/* Only superuser is allowed to listen multicasts */
 	if (nladdr->nl_groups) {
 		if (!netlink_capable(sock, NL_NONROOT_RECV))
 			return -EPERM;
 		if (nlk->groups == NULL) {
 			err = netlink_alloc_groups(sk);
 			if (err)
 				return err;
 		}
 	}
 	if (nlk->pid) {
 		if (nladdr->nl_pid != nlk->pid)
 			return -EINVAL;
 	} else {
 		err = nladdr->nl_pid ?
 			netlink_insert(sk, nladdr->nl_pid) :
 			netlink_autobind(sock);
 		if (err)
 			return err;
 	}
 	if (!nladdr->nl_groups && (nlk->groups == NULL || !(u32)nlk->groups[0]))
 		return 0;
 	netlink_table_grab();
 	netlink_update_subscriptions(sk, nlk->subscriptions +
 	                                 hweight32(nladdr->nl_groups) -
 	                                 hweight32(nlk->groups[0]));
 	nlk->groups[0] = (nlk->groups[0] & ~0xffffffffUL) | nladdr->nl_groups;
 	netlink_update_listeners(sk);
 	netlink_table_ungrab();
 	return 0;
 }
 static int netlink_connect(struct socket *sock, struct sockaddr *addr,
 			   int alen, int flags)
 {
 	int err = 0;
 	struct sock *sk = sock->sk;
 	struct netlink_sock *nlk = nlk_sk(sk);
 	struct sockaddr_nl *nladdr=(struct sockaddr_nl*)addr;
 	if (addr->sa_family == AF_UNSPEC) {
 		sk->sk_state	= NETLINK_UNCONNECTED;
 		nlk->dst_pid	= 0;
 		nlk->dst_group  = 0;
 		return 0;
 	}
 	if (addr->sa_family != AF_NETLINK)
 		return -EINVAL;
 	/* Only superuser is allowed to send multicasts */
 	if (nladdr->nl_groups && !netlink_capable(sock, NL_NONROOT_SEND))
 		return -EPERM;
 	if (!nlk->pid)
 		err = netlink_autobind(sock);
 	if (err == 0) {
 		sk->sk_state	= NETLINK_CONNECTED;
 		nlk->dst_pid 	= nladdr->nl_pid;
 		nlk->dst_group  = ffs(nladdr->nl_groups);
 	}
 	return err;
 }
 static int netlink_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
 {
 	struct sock *sk = sock->sk;
 	struct netlink_sock *nlk = nlk_sk(sk);
 	struct sockaddr_nl *nladdr=(struct sockaddr_nl *)addr;
 	nladdr->nl_family = AF_NETLINK;
 	nladdr->nl_pad = 0;
 	*addr_len = sizeof(*nladdr);
 	if (peer) {
 		nladdr->nl_pid = nlk->dst_pid;
 		nladdr->nl_groups = netlink_group_mask(nlk->dst_group);
 	} else {
 		nladdr->nl_pid = nlk->pid;
 		nladdr->nl_groups = nlk->groups ? nlk->groups[0] : 0;
 	}
 	return 0;
 }
 static void netlink_overrun(struct sock *sk)
 {
 	if (!test_and_set_bit(0, &nlk_sk(sk)->state)) {
 		sk->sk_err = ENOBUFS;
 		sk->sk_error_report(sk);
 	}
 }
 static struct sock *netlink_getsockbypid(struct sock *ssk, u32 pid)
 {
 	int protocol = ssk->sk_protocol;
 	struct sock *sock;
 	struct netlink_sock *nlk;
 	sock = netlink_lookup(protocol, pid);
 	if (!sock)
 		return ERR_PTR(-ECONNREFUSED);
 	/* Don't bother queuing skb if kernel socket has no input function */
 	nlk = nlk_sk(sock);
 	if ((nlk->pid == 0 && !nlk->data_ready) ||
 	    (sock->sk_state == NETLINK_CONNECTED &&
 	     nlk->dst_pid != nlk_sk(ssk)->pid)) {
 		sock_put(sock);
 		return ERR_PTR(-ECONNREFUSED);
 	}
 	return sock;
 }
 struct sock *netlink_getsockbyfilp(struct file *filp)
 {
 	struct inode *inode = filp->f_dentry->d_inode;
 	struct sock *sock;
 	if (!S_ISSOCK(inode->i_mode))
 		return ERR_PTR(-ENOTSOCK);
 	sock = SOCKET_I(inode)->sk;
 	if (sock->sk_family != AF_NETLINK)
 		return ERR_PTR(-EINVAL);
 	sock_hold(sock);
 	return sock;
 }
 /*
  * Attach a skb to a netlink socket.
  * The caller must hold a reference to the destination socket. On error, the
  * reference is dropped. The skb is not send to the destination, just all
  * all error checks are performed and memory in the queue is reserved.
  * Return values:
  * < 0: error. skb freed, reference to sock dropped.
  * 0: continue
  * 1: repeat lookup - reference dropped while waiting for socket memory.
  */
 int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
 		long timeo, struct sock *ssk)
 {
 	struct netlink_sock *nlk;
 	nlk = nlk_sk(sk);
 	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
 	    test_bit(0, &nlk->state)) {
 		DECLARE_WAITQUEUE(wait, current);
 		if (!timeo) {
 			if (!ssk || nlk_sk(ssk)->pid == 0)
 				netlink_overrun(sk);
 			sock_put(sk);
 			kfree_skb(skb);
 			return -EAGAIN;
 		}
 		__set_current_state(TASK_INTERRUPTIBLE);
 		add_wait_queue(&nlk->wait, &wait);
 		if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
 		     test_bit(0, &nlk->state)) &&
 		    !sock_flag(sk, SOCK_DEAD))
 			timeo = schedule_timeout(timeo);
 		__set_current_state(TASK_RUNNING);
 		remove_wait_queue(&nlk->wait, &wait);
 		sock_put(sk);
 		if (signal_pending(current)) {
 			kfree_skb(skb);
 			return sock_intr_errno(timeo);
 		}
 		return 1;
 	}
 	skb_set_owner_r(skb, sk);
 	return 0;
 }
 int netlink_sendskb(struct sock *sk, struct sk_buff *skb, int protocol)
 {
 	int len = skb->len;
 	skb_queue_tail(&sk->sk_receive_queue, skb);
 	sk->sk_data_ready(sk, len);
 	sock_put(sk);
 	return len;
 }
 void netlink_detachskb(struct sock *sk, struct sk_buff *skb)
 {
 	kfree_skb(skb);
 	sock_put(sk);
 }
 static inline struct sk_buff *netlink_trim(struct sk_buff *skb,
 					   gfp_t allocation)
 {
 	int delta;
 	skb_orphan(skb);
 	delta = skb->end - skb->tail;
 	if (delta * 2 < skb->truesize)
 		return skb;
 	if (skb_shared(skb)) {
 		struct sk_buff *nskb = skb_clone(skb, allocation);
 		if (!nskb)
 			return skb;
 		kfree_skb(skb);
 		skb = nskb;
 	}
 	if (!pskb_expand_head(skb, 0, -delta, allocation))
 		skb->truesize -= delta;
 	return skb;
 }
 int netlink_unicast(struct sock *ssk, struct sk_buff *skb, u32 pid, int nonblock)
 {
 	struct sock *sk;
 	int err;
 	long timeo;
 	skb = netlink_trim(skb, gfp_any());
 	timeo = sock_sndtimeo(ssk, nonblock);
 retry:
 	sk = netlink_getsockbypid(ssk, pid);
 	if (IS_ERR(sk)) {
 		kfree_skb(skb);
 		return PTR_ERR(sk);
 	}
 	err = netlink_attachskb(sk, skb, nonblock, timeo, ssk);
 	if (err == 1)
 		goto retry;
 	if (err)
 		return err;
 	return netlink_sendskb(sk, skb, ssk->sk_protocol);
 }
 int netlink_has_listeners(struct sock *sk, unsigned int group)
 {
 	int res = 0;
 	BUG_ON(!(nlk_sk(sk)->flags & NETLINK_KERNEL_SOCKET));
 	if (group - 1 < nl_table[sk->sk_protocol].groups)
 		res = test_bit(group - 1, nl_table[sk->sk_protocol].listeners);
 	return res;
 }
 EXPORT_SYMBOL_GPL(netlink_has_listeners);
 static __inline__ int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb)
 {
 	struct netlink_sock *nlk = nlk_sk(sk);
 	if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
 	    !test_bit(0, &nlk->state)) {
 		skb_set_owner_r(skb, sk);
 		skb_queue_tail(&sk->sk_receive_queue, skb);
 		sk->sk_data_ready(sk, skb->len);
 		return atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf;
 	}
 	return -1;
 }
 struct netlink_broadcast_data {
 	struct sock *exclude_sk;
 	u32 pid;
 	u32 group;
 	int failure;
 	int congested;
 	int delivered;
 	gfp_t allocation;
 	struct sk_buff *skb, *skb2;
 };
 static inline int do_one_broadcast(struct sock *sk,
 				   struct netlink_broadcast_data *p)
 {
 	struct netlink_sock *nlk = nlk_sk(sk);
 	int val;
 	if (p->exclude_sk == sk)
 		goto out;
 	if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups ||
 	    !test_bit(p->group - 1, nlk->groups))
 		goto out;
 	if (p->failure) {
 		netlink_overrun(sk);
 		goto out;
 	}
 	sock_hold(sk);
 	if (p->skb2 == NULL) {
 		if (skb_shared(p->skb)) {
 			p->skb2 = skb_clone(p->skb, p->allocation);
 		} else {
 			p->skb2 = skb_get(p->skb);
 			/*
 			 * skb ownership may have been set when
 			 * delivered to a previous socket.
 			 */
 			skb_orphan(p->skb2);
 		}
 	}
 	if (p->skb2 == NULL) {
 		netlink_overrun(sk);
 		/* Clone failed. Notify ALL listeners. */
 		p->failure = 1;
 	} else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0) {
 		netlink_overrun(sk);
 	} else {
 		p->congested |= val;
 		p->delivered = 1;
 		p->skb2 = NULL;
 	}
 	sock_put(sk);
 out:
 	return 0;
 }
 int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid,
 		      u32 group, gfp_t allocation)
 {
 	struct netlink_broadcast_data info;
 	struct hlist_node *node;
 	struct sock *sk;
 	skb = netlink_trim(skb, allocation);
 	info.exclude_sk = ssk;
 	info.pid = pid;
 	info.group = group;
 	info.failure = 0;
 	info.congested = 0;
 	info.delivered = 0;
 	info.allocation = allocation;
 	info.skb = skb;
 	info.skb2 = NULL;
 	/* While we sleep in clone, do not allow to change socket list */
 	netlink_lock_table();
 	sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list)
 		do_one_broadcast(sk, &info);
 	kfree_skb(skb);
 	netlink_unlock_table();
 	if (info.skb2)
 		kfree_skb(info.skb2);
 	if (info.delivered) {
 		if (info.congested && (allocation & __GFP_WAIT))
 			yield();
 		return 0;
 	}
 	if (info.failure)
 		return -ENOBUFS;
 	return -ESRCH;
 }
 struct netlink_set_err_data {
 	struct sock *exclude_sk;
 	u32 pid;
 	u32 group;
 	int code;
 };
 static inline int do_one_set_err(struct sock *sk,
 				 struct netlink_set_err_data *p)
 {
 	struct netlink_sock *nlk = nlk_sk(sk);
 	if (sk == p->exclude_sk)
 		goto out;
 	if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups ||
 	    !test_bit(p->group - 1, nlk->groups))
 		goto out;
 	sk->sk_err = p->code;
 	sk->sk_error_report(sk);
 out:
 	return 0;
 }
 void netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code)
 {
 	struct netlink_set_err_data info;
 	struct hlist_node *node;
 	struct sock *sk;
 	info.exclude_sk = ssk;
 	info.pid = pid;
 	info.group = group;
 	info.code = code;
 	read_lock(&nl_table_lock);
 	sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list)
 		do_one_set_err(sk, &info);
 	read_unlock(&nl_table_lock);
 }
 static int netlink_setsockopt(struct socket *sock, int level, int optname,
                               char __user *optval, int optlen)
 {
 	struct sock *sk = sock->sk;
 	struct netlink_sock *nlk = nlk_sk(sk);
 	int val = 0, err;
 	if (level != SOL_NETLINK)
 		return -ENOPROTOOPT;
 	if (optlen >= sizeof(int) &&
 	    get_user(val, (int __user *)optval))
 		return -EFAULT;
 	switch (optname) {
 	case NETLINK_PKTINFO:
 		if (val)
 			nlk->flags |= NETLINK_RECV_PKTINFO;
 		else
 			nlk->flags &= ~NETLINK_RECV_PKTINFO;
 		err = 0;
 		break;
 	case NETLINK_ADD_MEMBERSHIP:
 	case NETLINK_DROP_MEMBERSHIP: {
 		unsigned int subscriptions;
 		int old, new = optname == NETLINK_ADD_MEMBERSHIP ? 1 : 0;
 		if (!netlink_capable(sock, NL_NONROOT_RECV))
 			return -EPERM;
 		if (nlk->groups == NULL) {
 			err = netlink_alloc_groups(sk);
 			if (err)
 				return err;
 		}
 		if (!val || val - 1 >= nlk->ngroups)
 			return -EINVAL;
 		netlink_table_grab();
 		old = test_bit(val - 1, nlk->groups);
 		subscriptions = nlk->subscriptions - old + new;
 		if (new)
 			__set_bit(val - 1, nlk->groups);
 		else
 			__clear_bit(val - 1, nlk->groups);
 		netlink_update_subscriptions(sk, subscriptions);
 		netlink_update_listeners(sk);
 		netlink_table_ungrab();
 		err = 0;
 		break;
 	}
 	default:
 		err = -ENOPROTOOPT;
 	}
 	return err;
 }
 static int netlink_getsockopt(struct socket *sock, int level, int optname,
                               char __user *optval, int __user *optlen)
 {
 	struct sock *sk = sock->sk;
 	struct netlink_sock *nlk = nlk_sk(sk);
 	int len, val, err;
 	if (level != SOL_NETLINK)
 		return -ENOPROTOOPT;
 	if (get_user(len, optlen))
 		return -EFAULT;
 	if (len < 0)
 		return -EINVAL;
 	switch (optname) {
 	case NETLINK_PKTINFO:
 		if (len < sizeof(int))
 			return -EINVAL;
 		len = sizeof(int);
 		val = nlk->flags & NETLINK_RECV_PKTINFO ? 1 : 0;
 		if (put_user(len, optlen) ||
 		    put_user(val, optval))
 			return -EFAULT;
 		err = 0;
 		break;
 	default:
 		err = -ENOPROTOOPT;
 	}
 	return err;
 }
 static void netlink_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
 {
 	struct nl_pktinfo info;
 	info.group = NETLINK_CB(skb).dst_group;
 	put_cmsg(msg, SOL_NETLINK, NETLINK_PKTINFO, sizeof(info), &info);
 }
 static inline void netlink_rcv_wake(struct sock *sk)
 {
 	struct netlink_sock *nlk = nlk_sk(sk);
 	if (skb_queue_empty(&sk->sk_receive_queue))
 		clear_bit(0, &nlk->state);
 	if (!test_bit(0, &nlk->state))
 		wake_up_interruptible(&nlk->wait);
 }
 static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
 			   struct msghdr *msg, size_t len)
 {
 	struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
 	struct sock *sk = sock->sk;
 	struct netlink_sock *nlk = nlk_sk(sk);
 	struct sockaddr_nl *addr=msg->msg_name;
 	u32 dst_pid;
 	u32 dst_group;
 	struct sk_buff *skb;
 	int err;
 	struct scm_cookie scm;
 	if (msg->msg_flags&MSG_OOB)
 		return -EOPNOTSUPP;
 	if (NULL == siocb->scm)
 		siocb->scm = &scm;
 	err = scm_send(sock, msg, siocb->scm);
 	if (err < 0)
 		return err;
 	if (msg->msg_namelen) {
 		if (addr->nl_family != AF_NETLINK)
 			return -EINVAL;
 		dst_pid = addr->nl_pid;
 		dst_group = ffs(addr->nl_groups);
 		if (dst_group && !netlink_capable(sock, NL_NONROOT_SEND))
 			return -EPERM;
 	} else {
 		dst_pid = nlk->dst_pid;
 		dst_group = nlk->dst_group;
 	}
 	if (!nlk->pid) {
 		err = netlink_autobind(sock);
 		if (err)
 			goto out;
 	}
 	err = -EMSGSIZE;
 	if (len > sk->sk_sndbuf - 32)
 		goto out;
 	err = -ENOBUFS;
 	skb = alloc_skb(len, GFP_KERNEL);
 	if (skb==NULL)
 		goto out;
 	NETLINK_CB(skb).pid	= nlk->pid;
-	NETLINK_CB(skb).dst_pid = dst_pid;
 	NETLINK_CB(skb).dst_group = dst_group;
 	NETLINK_CB(skb).loginuid = audit_get_loginuid(current->audit_context);
 	selinux_get_task_sid(current, &(NETLINK_CB(skb).sid));
 	memcpy(NETLINK_CREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
 	/* What can I do? Netlink is asynchronous, so that
 	   we will have to save current capabilities to
 	   check them, when this message will be delivered
 	   to corresponding kernel module.   --ANK (980802)
 	 */
 	err = -EFAULT;
 	if (memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len)) {
 		kfree_skb(skb);
 		goto out;
 	}
 	err = security_netlink_send(sk, skb);
 	if (err) {
 		kfree_skb(skb);
 		goto out;
 	}
 	if (dst_group) {
 		atomic_inc(&skb->users);
 		netlink_broadcast(sk, skb, dst_pid, dst_group, GFP_KERNEL);
 	}
 	err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT);
 out:
 	return err;
 }
 static int netlink_recvmsg(struct kiocb *kiocb, struct socket *sock,
 			   struct msghdr *msg, size_t len,
 			   int flags)
 {
 	struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
 	struct scm_cookie scm;
 	struct sock *sk = sock->sk;
 	struct netlink_sock *nlk = nlk_sk(sk);
 	int noblock = flags&MSG_DONTWAIT;
 	size_t copied;
 	struct sk_buff *skb;
 	int err;
 	if (flags&MSG_OOB)
 		return -EOPNOTSUPP;
 	copied = 0;
 	skb = skb_recv_datagram(sk,flags,noblock,&err);
 	if (skb==NULL)
 		goto out;
 	msg->msg_namelen = 0;
 	copied = skb->len;
 	if (len < copied) {
 		msg->msg_flags |= MSG_TRUNC;
 		copied = len;
 	}
 	skb->h.raw = skb->data;
 	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 	if (msg->msg_name) {
 		struct sockaddr_nl *addr = (struct sockaddr_nl*)msg->msg_name;
 		addr->nl_family = AF_NETLINK;
 		addr->nl_pad    = 0;
 		addr->nl_pid	= NETLINK_CB(skb).pid;
 		addr->nl_groups	= netlink_group_mask(NETLINK_CB(skb).dst_group);
 		msg->msg_namelen = sizeof(*addr);
 	}
 	if (nlk->flags & NETLINK_RECV_PKTINFO)
 		netlink_cmsg_recv_pktinfo(msg, skb);
 	if (NULL == siocb->scm) {
 		memset(&scm, 0, sizeof(scm));
 		siocb->scm = &scm;
 	}
 	siocb->scm->creds = *NETLINK_CREDS(skb);
 	skb_free_datagram(sk, skb);
 	if (nlk->cb && atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2)
 		netlink_dump(sk);
 	scm_recv(sock, msg, siocb->scm, flags);
 out:
 	netlink_rcv_wake(sk);
 	return err ? : copied;
 }
 static void netlink_data_ready(struct sock *sk, int len)
 {
 	struct netlink_sock *nlk = nlk_sk(sk);
 	if (nlk->data_ready)
 		nlk->data_ready(sk, len);
 	netlink_rcv_wake(sk);
 }
 /*
  *	We export these functions to other modules. They provide a
  *	complete set of kernel non-blocking support for message
  *	queueing.
  */
 struct sock *
 netlink_kernel_create(int unit, unsigned int groups,
                       void (*input)(struct sock *sk, int len),
                       struct module *module)
 {
 	struct socket *sock;
 	struct sock *sk;
 	struct netlink_sock *nlk;
 	unsigned long *listeners = NULL;
 	BUG_ON(!nl_table);
 	if (unit<0 || unit>=MAX_LINKS)
 		return NULL;
 	if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
 		return NULL;
 	if (__netlink_create(sock, unit) < 0)
 		goto out_sock_release;
 	if (groups < 32)
 		groups = 32;
 	listeners = kzalloc(NLGRPSZ(groups), GFP_KERNEL);
 	if (!listeners)
 		goto out_sock_release;
 	sk = sock->sk;
 	sk->sk_data_ready = netlink_data_ready;
 	if (input)
 		nlk_sk(sk)->data_ready = input;
 	if (netlink_insert(sk, 0))
 		goto out_sock_release;
 	nlk = nlk_sk(sk);
 	nlk->flags |= NETLINK_KERNEL_SOCKET;
 	netlink_table_grab();
 	nl_table[unit].groups = groups;
 	nl_table[unit].listeners = listeners;
 	nl_table[unit].module = module;
 	nl_table[unit].registered = 1;
 	netlink_table_ungrab();
 	return sk;
 out_sock_release:
 	kfree(listeners);
 	sock_release(sock);
 	return NULL;
 }
 void netlink_set_nonroot(int protocol, unsigned int flags)
 {
 	if ((unsigned int)protocol < MAX_LINKS)
 		nl_table[protocol].nl_nonroot = flags;
 }
 static void netlink_destroy_callback(struct netlink_callback *cb)
 {
 	if (cb->skb)
 		kfree_skb(cb->skb);
 	kfree(cb);
 }
 /*
  * It looks a bit ugly.
  * It would be better to create kernel thread.
  */
 static int netlink_dump(struct sock *sk)
 {
 	struct netlink_sock *nlk = nlk_sk(sk);
 	struct netlink_callback *cb;
 	struct sk_buff *skb;
 	struct nlmsghdr *nlh;
 	int len, err = -ENOBUFS;
 	skb = sock_rmalloc(sk, NLMSG_GOODSIZE, 0, GFP_KERNEL);
 	if (!skb)
 		goto errout;
 	spin_lock(&nlk->cb_lock);
 	cb = nlk->cb;
 	if (cb == NULL) {
 		err = -EINVAL;
 		goto errout_skb;
 	}
 	len = cb->dump(skb, cb);
 	if (len > 0) {
 		spin_unlock(&nlk->cb_lock);
 		skb_queue_tail(&sk->sk_receive_queue, skb);
 		sk->sk_data_ready(sk, len);
 		return 0;
 	}
 	nlh = nlmsg_put_answer(skb, cb, NLMSG_DONE, sizeof(len), NLM_F_MULTI);
 	if (!nlh)
 		goto errout_skb;
 	memcpy(nlmsg_data(nlh), &len, sizeof(len));
 	skb_queue_tail(&sk->sk_receive_queue, skb);
 	sk->sk_data_ready(sk, skb->len);
 	if (cb->done)
 		cb->done(cb);
 	nlk->cb = NULL;
 	spin_unlock(&nlk->cb_lock);
 	netlink_destroy_callback(cb);
 	return 0;
 errout_skb:
 	spin_unlock(&nlk->cb_lock);
 	kfree_skb(skb);
 errout:
 	return err;
 }
 int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
 		       struct nlmsghdr *nlh,
 		       int (*dump)(struct sk_buff *skb, struct netlink_callback*),
 		       int (*done)(struct netlink_callback*))
 {
 	struct netlink_callback *cb;
 	struct sock *sk;
 	struct netlink_sock *nlk;
 	cb = kzalloc(sizeof(*cb), GFP_KERNEL);
 	if (cb == NULL)
 		return -ENOBUFS;
 	cb->dump = dump;
 	cb->done = done;
 	cb->nlh = nlh;
 	atomic_inc(&skb->users);
 	cb->skb = skb;
 	sk = netlink_lookup(ssk->sk_protocol, NETLINK_CB(skb).pid);
 	if (sk == NULL) {
 		netlink_destroy_callback(cb);
 		return -ECONNREFUSED;
 	}
 	nlk = nlk_sk(sk);
 	/* A dump is in progress... */
 	spin_lock(&nlk->cb_lock);
 	if (nlk->cb) {
 		spin_unlock(&nlk->cb_lock);
 		netlink_destroy_callback(cb);
 		sock_put(sk);
 		return -EBUSY;
 	}
 	nlk->cb = cb;
 	spin_unlock(&nlk->cb_lock);
 	netlink_dump(sk);
 	sock_put(sk);
 	return 0;
 }
 void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
 {
 	struct sk_buff *skb;
 	struct nlmsghdr *rep;
 	struct nlmsgerr *errmsg;
 	size_t payload = sizeof(*errmsg);
 	/* error messages get the original request appened */
 	if (err)
 		payload += nlmsg_len(nlh);
 	skb = nlmsg_new(payload, GFP_KERNEL);
 	if (!skb) {
 		struct sock *sk;
 		sk = netlink_lookup(in_skb->sk->sk_protocol,
 				    NETLINK_CB(in_skb).pid);
 		if (sk) {
 			sk->sk_err = ENOBUFS;
 			sk->sk_error_report(sk);
 			sock_put(sk);
 		}
 		return;
 	}
 	rep = __nlmsg_put(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
 			  NLMSG_ERROR, sizeof(struct nlmsgerr), 0);
 	errmsg = nlmsg_data(rep);
 	errmsg->error = err;
 	memcpy(&errmsg->msg, nlh, err ? nlh->nlmsg_len : sizeof(*nlh));
 	netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
 }
 static int netlink_rcv_skb(struct sk_buff *skb, int (*cb)(struct sk_buff *,
 						     struct nlmsghdr *, int *))
 {
 	struct nlmsghdr *nlh;
 	int err;
 	while (skb->len >= nlmsg_total_size(0)) {
 		nlh = (struct nlmsghdr *) skb->data;
 		if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len)
 			return 0;
 		if (cb(skb, nlh, &err) < 0) {
 			/* Not an error, but we have to interrupt processing
 			 * here. Note: that in this case we do not pull
 			 * message from skb, it will be processed later.
 			 */
 			if (err == 0)
 				return -1;
 			netlink_ack(skb, nlh, err);
 		} else if (nlh->nlmsg_flags & NLM_F_ACK)
 			netlink_ack(skb, nlh, 0);
 		netlink_queue_skip(nlh, skb);
 	}
 	return 0;
 }
 /**
  * nelink_run_queue - Process netlink receive queue.
  * @sk: Netlink socket containing the queue
  * @qlen: Place to store queue length upon entry
  * @cb: Callback function invoked for each netlink message found
  *
  * Processes as much as there was in the queue upon entry and invokes
  * a callback function for each netlink message found. The callback
  * function may refuse a message by returning a negative error code
  * but setting the error pointer to 0 in which case this function
  * returns with a qlen != 0.
  *
  * qlen must be initialized to 0 before the initial entry, afterwards
  * the function may be called repeatedly until qlen reaches 0.
  */
 void netlink_run_queue(struct sock *sk, unsigned int *qlen,
 		       int (*cb)(struct sk_buff *, struct nlmsghdr *, int *))
 {
 	struct sk_buff *skb;
 	if (!*qlen || *qlen > skb_queue_len(&sk->sk_receive_queue))
 		*qlen = skb_queue_len(&sk->sk_receive_queue);
 	for (; *qlen; (*qlen)--) {
 		skb = skb_dequeue(&sk->sk_receive_queue);
 		if (netlink_rcv_skb(skb, cb)) {
 			if (skb->len)
 				skb_queue_head(&sk->sk_receive_queue, skb);
 			else {
 				kfree_skb(skb);
 				(*qlen)--;
 			}
 			break;
 		}
 		kfree_skb(skb);
 	}
 }
 /**
  * netlink_queue_skip - Skip netlink message while processing queue.
  * @nlh: Netlink message to be skipped
  * @skb: Socket buffer containing the netlink messages.
  *
  * Pulls the given netlink message off the socket buffer so the next
  * call to netlink_queue_run() will not reconsider the message.
  */
 void netlink_queue_skip(struct nlmsghdr *nlh, struct sk_buff *skb)
 {
 	int msglen = NLMSG_ALIGN(nlh->nlmsg_len);
 	if (msglen > skb->len)
 		msglen = skb->len;
 	skb_pull(skb, msglen);
 }
 /**
  * nlmsg_notify - send a notification netlink message
  * @sk: netlink socket to use
  * @skb: notification message
  * @pid: destination netlink pid for reports or 0
  * @group: destination multicast group or 0
  * @report: 1 to report back, 0 to disable
  * @flags: allocation flags
  */
 int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 pid,
 		 unsigned int group, int report, gfp_t flags)
 {
 	int err = 0;
 	if (group) {
 		int exclude_pid = 0;
 		if (report) {
 			atomic_inc(&skb->users);
 			exclude_pid = pid;
 		}
 		/* errors reported via destination sk->sk_err */
 		nlmsg_multicast(sk, skb, exclude_pid, group, flags);
 	}
 	if (report)
 		err = nlmsg_unicast(sk, skb, pid);
 	return err;
 }
 #ifdef CONFIG_PROC_FS
 struct nl_seq_iter {
 	int link;
 	int hash_idx;
 };
 static struct sock *netlink_seq_socket_idx(struct seq_file *seq, loff_t pos)
 {
 	struct nl_seq_iter *iter = seq->private;
 	int i, j;
 	struct sock *s;
 	struct hlist_node *node;
 	loff_t off = 0;
 	for (i=0; i<MAX_LINKS; i++) {
 		struct nl_pid_hash *hash = &nl_table[i].hash;
 		for (j = 0; j <= hash->mask; j++) {
 			sk_for_each(s, node, &hash->table[j]) {
 				if (off == pos) {
 					iter->link = i;
 					iter->hash_idx = j;
 					return s;
 				}
 				++off;
 			}
 		}
 	}
 	return NULL;
 }
 static void *netlink_seq_start(struct seq_file *seq, loff_t *pos)
 {
 	read_lock(&nl_table_lock);
 	return *pos ? netlink_seq_socket_idx(seq, *pos - 1) : SEQ_START_TOKEN;
 }
 static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
 	struct sock *s;
 	struct nl_seq_iter *iter;
 	int i, j;
 	++*pos;
 	if (v == SEQ_START_TOKEN)
 		return netlink_seq_socket_idx(seq, 0);
 	s = sk_next(v);
 	if (s)
 		return s;
 	iter = seq->private;
 	i = iter->link;
 	j = iter->hash_idx + 1;
 	do {
 		struct nl_pid_hash *hash = &nl_table[i].hash;
 		for (; j <= hash->mask; j++) {
 			s = sk_head(&hash->table[j]);
 			if (s) {
 				iter->link = i;
 				iter->hash_idx = j;
 				return s;
 			}
 		}
 		j = 0;
 	} while (++i < MAX_LINKS);
 	return NULL;
 }
 static void netlink_seq_stop(struct seq_file *seq, void *v)
 {
 	read_unlock(&nl_table_lock);
 }
 static int netlink_seq_show(struct seq_file *seq, void *v)
 {
 	if (v == SEQ_START_TOKEN)
 		seq_puts(seq,
 			 "sk       Eth Pid    Groups   "
 			 "Rmem     Wmem     Dump     Locks\n");
 	else {
 		struct sock *s = v;
 		struct netlink_sock *nlk = nlk_sk(s);
 		seq_printf(seq, "%p %-3d %-6d %08x %-8d %-8d %p %d\n",
 			   s,
 			   s->sk_protocol,
 			   nlk->pid,
 			   nlk->groups ? (u32)nlk->groups[0] : 0,
 			   atomic_read(&s->sk_rmem_alloc),
 			   atomic_read(&s->sk_wmem_alloc),
 			   nlk->cb,
 			   atomic_read(&s->sk_refcnt)
 			);
 	}
 	return 0;
 }
 static struct seq_operations netlink_seq_ops = {
 	.start  = netlink_seq_start,
 	.next   = netlink_seq_next,
 	.stop   = netlink_seq_stop,
 	.show   = netlink_seq_show,
 };
 static int netlink_seq_open(struct inode *inode, struct file *file)
 {
 	struct seq_file *seq;
 	struct nl_seq_iter *iter;
 	int err;
 	iter = kzalloc(sizeof(*iter), GFP_KERNEL);
 	if (!iter)
 		return -ENOMEM;
 	err = seq_open(file, &netlink_seq_ops);
 	if (err) {
 		kfree(iter);
 		return err;
 	}
 	seq = file->private_data;
 	seq->private = iter;
 	return 0;
 }
 static struct file_operations netlink_seq_fops = {
 	.owner		= THIS_MODULE,
 	.open		= netlink_seq_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
 	.release	= seq_release_private,
 };
 #endif
 int netlink_register_notifier(struct notifier_block *nb)
 {
 	return atomic_notifier_chain_register(&netlink_chain, nb);
 }
 int netlink_unregister_notifier(struct notifier_block *nb)
 {
 	return atomic_notifier_chain_unregister(&netlink_chain, nb);
 }
 static const struct proto_ops netlink_ops = {
 	.family =	PF_NETLINK,
 	.owner =	THIS_MODULE,
 	.release =	netlink_release,
 	.bind =		netlink_bind,
 	.connect =	netlink_connect,
 	.socketpair =	sock_no_socketpair,
 	.accept =	sock_no_accept,
 	.getname =	netlink_getname,
 	.poll =		datagram_poll,
 	.ioctl =	sock_no_ioctl,
 	.listen =	sock_no_listen,
 	.shutdown =	sock_no_shutdown,
 	.setsockopt =	netlink_setsockopt,
 	.getsockopt =	netlink_getsockopt,
 	.sendmsg =	netlink_sendmsg,
 	.recvmsg =	netlink_recvmsg,
 	.mmap =		sock_no_mmap,
 	.sendpage =	sock_no_sendpage,
 };
 static struct net_proto_family netlink_family_ops = {
 	.family = PF_NETLINK,
 	.create = netlink_create,
 	.owner	= THIS_MODULE,	/* for consistency 8) */
 };
 static int __init netlink_proto_init(void)
 {
 	struct sk_buff *dummy_skb;
 	int i;
 	unsigned long max;
 	unsigned int order;
 	int err = proto_register(&netlink_proto, 0);
 	if (err != 0)
 		goto out;
 	BUILD_BUG_ON(sizeof(struct netlink_skb_parms) > sizeof(dummy_skb->cb));
 	nl_table = kcalloc(MAX_LINKS, sizeof(*nl_table), GFP_KERNEL);
 	if (!nl_table)
 		goto panic;
 	if (num_physpages >= (128 * 1024))
 		max = num_physpages >> (21 - PAGE_SHIFT);
 	else
 		max = num_physpages >> (23 - PAGE_SHIFT);
 	order = get_bitmask_order(max) - 1 + PAGE_SHIFT;
 	max = (1UL << order) / sizeof(struct hlist_head);
 	order = get_bitmask_order(max > UINT_MAX ? UINT_MAX : max) - 1;
 	for (i = 0; i < MAX_LINKS; i++) {
 		struct nl_pid_hash *hash = &nl_table[i].hash;
 		hash->table = nl_pid_hash_alloc(1 * sizeof(*hash->table));
 		if (!hash->table) {
 			while (i-- > 0)
 				nl_pid_hash_free(nl_table[i].hash.table,
 						 1 * sizeof(*hash->table));
 			kfree(nl_table);
 			goto panic;
 		}
 		memset(hash->table, 0, 1 * sizeof(*hash->table));
 		hash->max_shift = order;
 		hash->shift = 0;
 		hash->mask = 0;
 		hash->rehash_time = jiffies;
 	}
 	sock_register(&netlink_family_ops);
 #ifdef CONFIG_PROC_FS
 	proc_net_fops_create("netlink", 0, &netlink_seq_fops);
 #endif
 	/* The netlink device handler may be needed early. */
 	rtnetlink_init();
 out:
 	return err;
 panic:
 	panic("netlink_init: Cannot allocate nl_table\n");
 }
 core_initcall(netlink_proto_init);
 EXPORT_SYMBOL(netlink_ack);
 EXPORT_SYMBOL(netlink_run_queue);
 EXPORT_SYMBOL(netlink_queue_skip);
 EXPORT_SYMBOL(netlink_broadcast);
 EXPORT_SYMBOL(netlink_dump_start);
 EXPORT_SYMBOL(netlink_kernel_create);
 EXPORT_SYMBOL(netlink_register_notifier);
 EXPORT_SYMBOL(netlink_set_err);
 EXPORT_SYMBOL(netlink_set_nonroot);
 EXPORT_SYMBOL(netlink_unicast);
 EXPORT_SYMBOL(netlink_unregister_notifier);
 EXPORT_SYMBOL(nlmsg_notify);

net/xfrm/xfrm_user.c

Diff comments View file @ 4e9b826

 /* xfrm_user.c: User interface to configure xfrm engine.
  *
  * Copyright (C) 2002 David S. Miller (davem@redhat.com)
  *
  * Changes:
  *	Mitsuru KANDA @USAGI
  * 	Kazunori MIYAZAWA @USAGI
  * 	Kunihiro Ishiguro <kunihiro@ipinfusion.com>
  * 		IPv6 support
  *
  */
 #include <linux/crypto.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/socket.h>
 #include <linux/string.h>
 #include <linux/net.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <linux/pfkeyv2.h>
 #include <linux/ipsec.h>
 #include <linux/init.h>
 #include <linux/security.h>
 #include <net/sock.h>
 #include <net/xfrm.h>
 #include <net/netlink.h>
 #include <asm/uaccess.h>
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 #include <linux/in6.h>
 #endif
 static int verify_one_alg(struct rtattr **xfrma, enum xfrm_attr_type_t type)
 {
 	struct rtattr *rt = xfrma[type - 1];
 	struct xfrm_algo *algp;
 	int len;
 	if (!rt)
 		return 0;
 	len = (rt->rta_len - sizeof(*rt)) - sizeof(*algp);
 	if (len < 0)
 		return -EINVAL;
 	algp = RTA_DATA(rt);
 	len -= (algp->alg_key_len + 7U) / 8;
 	if (len < 0)
 		return -EINVAL;
 	switch (type) {
 	case XFRMA_ALG_AUTH:
 		if (!algp->alg_key_len &&
 		    strcmp(algp->alg_name, "digest_null") != 0)
 			return -EINVAL;
 		break;
 	case XFRMA_ALG_CRYPT:
 		if (!algp->alg_key_len &&
 		    strcmp(algp->alg_name, "cipher_null") != 0)
 			return -EINVAL;
 		break;
 	case XFRMA_ALG_COMP:
 		/* Zero length keys are legal.  */
 		break;
 	default:
 		return -EINVAL;
 	};
 	algp->alg_name[CRYPTO_MAX_ALG_NAME - 1] = '\0';
 	return 0;
 }
 static int verify_encap_tmpl(struct rtattr **xfrma)
 {
 	struct rtattr *rt = xfrma[XFRMA_ENCAP - 1];
 	struct xfrm_encap_tmpl *encap;
 	if (!rt)
 		return 0;
 	if ((rt->rta_len - sizeof(*rt)) < sizeof(*encap))
 		return -EINVAL;
 	return 0;
 }
 static int verify_one_addr(struct rtattr **xfrma, enum xfrm_attr_type_t type,
 			   xfrm_address_t **addrp)
 {
 	struct rtattr *rt = xfrma[type - 1];
 	if (!rt)
 		return 0;
 	if ((rt->rta_len - sizeof(*rt)) < sizeof(**addrp))
 		return -EINVAL;
 	if (addrp)
 		*addrp = RTA_DATA(rt);
 	return 0;
 }
 static inline int verify_sec_ctx_len(struct rtattr **xfrma)
 {
 	struct rtattr *rt = xfrma[XFRMA_SEC_CTX - 1];
 	struct xfrm_user_sec_ctx *uctx;
 	int len = 0;
 	if (!rt)
 		return 0;
 	if (rt->rta_len < sizeof(*uctx))
 		return -EINVAL;
 	uctx = RTA_DATA(rt);
 	len += sizeof(struct xfrm_user_sec_ctx);
 	len += uctx->ctx_len;
 	if (uctx->len != len)
 		return -EINVAL;
 	return 0;
 }
 static int verify_newsa_info(struct xfrm_usersa_info *p,
 			     struct rtattr **xfrma)
 {
 	int err;
 	err = -EINVAL;
 	switch (p->family) {
 	case AF_INET:
 		break;
 	case AF_INET6:
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 		break;
 #else
 		err = -EAFNOSUPPORT;
 		goto out;
 #endif
 	default:
 		goto out;
 	};
 	err = -EINVAL;
 	switch (p->id.proto) {
 	case IPPROTO_AH:
 		if (!xfrma[XFRMA_ALG_AUTH-1]	||
 		    xfrma[XFRMA_ALG_CRYPT-1]	||
 		    xfrma[XFRMA_ALG_COMP-1])
 			goto out;
 		break;
 	case IPPROTO_ESP:
 		if ((!xfrma[XFRMA_ALG_AUTH-1] &&
 		     !xfrma[XFRMA_ALG_CRYPT-1])	||
 		    xfrma[XFRMA_ALG_COMP-1])
 			goto out;
 		break;
 	case IPPROTO_COMP:
 		if (!xfrma[XFRMA_ALG_COMP-1]	||
 		    xfrma[XFRMA_ALG_AUTH-1]	||
 		    xfrma[XFRMA_ALG_CRYPT-1])
 			goto out;
 		break;
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 	case IPPROTO_DSTOPTS:
 	case IPPROTO_ROUTING:
 		if (xfrma[XFRMA_ALG_COMP-1]	||
 		    xfrma[XFRMA_ALG_AUTH-1]	||
 		    xfrma[XFRMA_ALG_CRYPT-1]	||
 		    xfrma[XFRMA_ENCAP-1]	||
 		    xfrma[XFRMA_SEC_CTX-1]	||
 		    !xfrma[XFRMA_COADDR-1])
 			goto out;
 		break;
 #endif
 	default:
 		goto out;
 	};
 	if ((err = verify_one_alg(xfrma, XFRMA_ALG_AUTH)))
 		goto out;
 	if ((err = verify_one_alg(xfrma, XFRMA_ALG_CRYPT)))
 		goto out;
 	if ((err = verify_one_alg(xfrma, XFRMA_ALG_COMP)))
 		goto out;
 	if ((err = verify_encap_tmpl(xfrma)))
 		goto out;
 	if ((err = verify_sec_ctx_len(xfrma)))
 		goto out;
 	if ((err = verify_one_addr(xfrma, XFRMA_COADDR, NULL)))
 		goto out;
 	err = -EINVAL;
 	switch (p->mode) {
 	case XFRM_MODE_TRANSPORT:
 	case XFRM_MODE_TUNNEL:
 	case XFRM_MODE_ROUTEOPTIMIZATION:
 	case XFRM_MODE_BEET:
 		break;
 	default:
 		goto out;
 	};
 	err = 0;
 out:
 	return err;
 }
 static int attach_one_algo(struct xfrm_algo **algpp, u8 *props,
 			   struct xfrm_algo_desc *(*get_byname)(char *, int),
 			   struct rtattr *u_arg)
 {
 	struct rtattr *rta = u_arg;
 	struct xfrm_algo *p, *ualg;
 	struct xfrm_algo_desc *algo;
 	int len;
 	if (!rta)
 		return 0;
 	ualg = RTA_DATA(rta);
 	algo = get_byname(ualg->alg_name, 1);
 	if (!algo)
 		return -ENOSYS;
 	*props = algo->desc.sadb_alg_id;
 	len = sizeof(*ualg) + (ualg->alg_key_len + 7U) / 8;
 	p = kmemdup(ualg, len, GFP_KERNEL);
 	if (!p)
 		return -ENOMEM;
 	strcpy(p->alg_name, algo->name);
 	*algpp = p;
 	return 0;
 }
 static int attach_encap_tmpl(struct xfrm_encap_tmpl **encapp, struct rtattr *u_arg)
 {
 	struct rtattr *rta = u_arg;
 	struct xfrm_encap_tmpl *p, *uencap;
 	if (!rta)
 		return 0;
 	uencap = RTA_DATA(rta);
 	p = kmemdup(uencap, sizeof(*p), GFP_KERNEL);
 	if (!p)
 		return -ENOMEM;
 	*encapp = p;
 	return 0;
 }
 static inline int xfrm_user_sec_ctx_size(struct xfrm_policy *xp)
 {
 	struct xfrm_sec_ctx *xfrm_ctx = xp->security;
 	int len = 0;
 	if (xfrm_ctx) {
 		len += sizeof(struct xfrm_user_sec_ctx);
 		len += xfrm_ctx->ctx_len;
 	}
 	return len;
 }
 static int attach_sec_ctx(struct xfrm_state *x, struct rtattr *u_arg)
 {
 	struct xfrm_user_sec_ctx *uctx;
 	if (!u_arg)
 		return 0;
 	uctx = RTA_DATA(u_arg);
 	return security_xfrm_state_alloc(x, uctx);
 }
 static int attach_one_addr(xfrm_address_t **addrpp, struct rtattr *u_arg)
 {
 	struct rtattr *rta = u_arg;
 	xfrm_address_t *p, *uaddrp;
 	if (!rta)
 		return 0;
 	uaddrp = RTA_DATA(rta);
 	p = kmemdup(uaddrp, sizeof(*p), GFP_KERNEL);
 	if (!p)
 		return -ENOMEM;
 	*addrpp = p;
 	return 0;
 }
 static void copy_from_user_state(struct xfrm_state *x, struct xfrm_usersa_info *p)
 {
 	memcpy(&x->id, &p->id, sizeof(x->id));
 	memcpy(&x->sel, &p->sel, sizeof(x->sel));
 	memcpy(&x->lft, &p->lft, sizeof(x->lft));
 	x->props.mode = p->mode;
 	x->props.replay_window = p->replay_window;
 	x->props.reqid = p->reqid;
 	x->props.family = p->family;
 	memcpy(&x->props.saddr, &p->saddr, sizeof(x->props.saddr));
 	x->props.flags = p->flags;
 }
 /*
  * someday when pfkey also has support, we could have the code
  * somehow made shareable and move it to xfrm_state.c - JHS
  *
 */
 static int xfrm_update_ae_params(struct xfrm_state *x, struct rtattr **xfrma)
 {
 	int err = - EINVAL;
 	struct rtattr *rp = xfrma[XFRMA_REPLAY_VAL-1];
 	struct rtattr *lt = xfrma[XFRMA_LTIME_VAL-1];
 	struct rtattr *et = xfrma[XFRMA_ETIMER_THRESH-1];
 	struct rtattr *rt = xfrma[XFRMA_REPLAY_THRESH-1];
 	if (rp) {
 		struct xfrm_replay_state *replay;
 		if (RTA_PAYLOAD(rp) < sizeof(*replay))
 			goto error;
 		replay = RTA_DATA(rp);
 		memcpy(&x->replay, replay, sizeof(*replay));
 		memcpy(&x->preplay, replay, sizeof(*replay));
 	}
 	if (lt) {
 		struct xfrm_lifetime_cur *ltime;
 		if (RTA_PAYLOAD(lt) < sizeof(*ltime))
 			goto error;
 		ltime = RTA_DATA(lt);
 		x->curlft.bytes = ltime->bytes;
 		x->curlft.packets = ltime->packets;
 		x->curlft.add_time = ltime->add_time;
 		x->curlft.use_time = ltime->use_time;
 	}
 	if (et) {
 		if (RTA_PAYLOAD(et) < sizeof(u32))
 			goto error;
 		x->replay_maxage = *(u32*)RTA_DATA(et);
 	}
 	if (rt) {
 		if (RTA_PAYLOAD(rt) < sizeof(u32))
 			goto error;
 		x->replay_maxdiff = *(u32*)RTA_DATA(rt);
 	}
 	return 0;
 error:
 	return err;
 }
 static struct xfrm_state *xfrm_state_construct(struct xfrm_usersa_info *p,
 					       struct rtattr **xfrma,
 					       int *errp)
 {
 	struct xfrm_state *x = xfrm_state_alloc();
 	int err = -ENOMEM;
 	if (!x)
 		goto error_no_put;
 	copy_from_user_state(x, p);
 	if ((err = attach_one_algo(&x->aalg, &x->props.aalgo,
 				   xfrm_aalg_get_byname,
 				   xfrma[XFRMA_ALG_AUTH-1])))
 		goto error;
 	if ((err = attach_one_algo(&x->ealg, &x->props.ealgo,
 				   xfrm_ealg_get_byname,
 				   xfrma[XFRMA_ALG_CRYPT-1])))
 		goto error;
 	if ((err = attach_one_algo(&x->calg, &x->props.calgo,
 				   xfrm_calg_get_byname,
 				   xfrma[XFRMA_ALG_COMP-1])))
 		goto error;
 	if ((err = attach_encap_tmpl(&x->encap, xfrma[XFRMA_ENCAP-1])))
 		goto error;
 	if ((err = attach_one_addr(&x->coaddr, xfrma[XFRMA_COADDR-1])))
 		goto error;
 	err = xfrm_init_state(x);
 	if (err)
 		goto error;
 	if ((err = attach_sec_ctx(x, xfrma[XFRMA_SEC_CTX-1])))
 		goto error;
 	x->km.seq = p->seq;
 	x->replay_maxdiff = sysctl_xfrm_aevent_rseqth;
 	/* sysctl_xfrm_aevent_etime is in 100ms units */
 	x->replay_maxage = (sysctl_xfrm_aevent_etime*HZ)/XFRM_AE_ETH_M;
 	x->preplay.bitmap = 0;
 	x->preplay.seq = x->replay.seq+x->replay_maxdiff;
 	x->preplay.oseq = x->replay.oseq +x->replay_maxdiff;
 	/* override default values from above */
 	err = xfrm_update_ae_params(x, (struct rtattr **)xfrma);
 	if (err	< 0)
 		goto error;
 	return x;
 error:
 	x->km.state = XFRM_STATE_DEAD;
 	xfrm_state_put(x);
 error_no_put:
 	*errp = err;
 	return NULL;
 }
 static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_usersa_info *p = NLMSG_DATA(nlh);
 	struct xfrm_state *x;
 	int err;
 	struct km_event c;
 	err = verify_newsa_info(p, (struct rtattr **)xfrma);
 	if (err)
 		return err;
 	x = xfrm_state_construct(p, (struct rtattr **)xfrma, &err);
 	if (!x)
 		return err;
 	xfrm_state_hold(x);
 	if (nlh->nlmsg_type == XFRM_MSG_NEWSA)
 		err = xfrm_state_add(x);
 	else
 		err = xfrm_state_update(x);
 	if (err < 0) {
 		x->km.state = XFRM_STATE_DEAD;
 		__xfrm_state_put(x);
 		goto out;
 	}
 	c.seq = nlh->nlmsg_seq;
 	c.pid = nlh->nlmsg_pid;
 	c.event = nlh->nlmsg_type;
 	km_state_notify(x, &c);
 out:
 	xfrm_state_put(x);
 	return err;
 }
 static struct xfrm_state *xfrm_user_state_lookup(struct xfrm_usersa_id *p,
 						 struct rtattr **xfrma,
 						 int *errp)
 {
 	struct xfrm_state *x = NULL;
 	int err;
 	if (xfrm_id_proto_match(p->proto, IPSEC_PROTO_ANY)) {
 		err = -ESRCH;
 		x = xfrm_state_lookup(&p->daddr, p->spi, p->proto, p->family);
 	} else {
 		xfrm_address_t *saddr = NULL;
 		err = verify_one_addr(xfrma, XFRMA_SRCADDR, &saddr);
 		if (err)
 			goto out;
 		if (!saddr) {
 			err = -EINVAL;
 			goto out;
 		}
 		err = -ESRCH;
 		x = xfrm_state_lookup_byaddr(&p->daddr, saddr, p->proto,
 					     p->family);
 	}
  out:
 	if (!x && errp)
 		*errp = err;
 	return x;
 }
 static int xfrm_del_sa(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_state *x;
 	int err = -ESRCH;
 	struct km_event c;
 	struct xfrm_usersa_id *p = NLMSG_DATA(nlh);
 	x = xfrm_user_state_lookup(p, (struct rtattr **)xfrma, &err);
 	if (x == NULL)
 		return err;
 	if ((err = security_xfrm_state_delete(x)) != 0)
 		goto out;
 	if (xfrm_state_kern(x)) {
 		err = -EPERM;
 		goto out;
 	}
 	err = xfrm_state_delete(x);
 	if (err < 0)
 		goto out;
 	c.seq = nlh->nlmsg_seq;
 	c.pid = nlh->nlmsg_pid;
 	c.event = nlh->nlmsg_type;
 	km_state_notify(x, &c);
 out:
 	xfrm_state_put(x);
 	return err;
 }
 static void copy_to_user_state(struct xfrm_state *x, struct xfrm_usersa_info *p)
 {
 	memcpy(&p->id, &x->id, sizeof(p->id));
 	memcpy(&p->sel, &x->sel, sizeof(p->sel));
 	memcpy(&p->lft, &x->lft, sizeof(p->lft));
 	memcpy(&p->curlft, &x->curlft, sizeof(p->curlft));
 	memcpy(&p->stats, &x->stats, sizeof(p->stats));
 	memcpy(&p->saddr, &x->props.saddr, sizeof(p->saddr));
 	p->mode = x->props.mode;
 	p->replay_window = x->props.replay_window;
 	p->reqid = x->props.reqid;
 	p->family = x->props.family;
 	p->flags = x->props.flags;
 	p->seq = x->km.seq;
 }
 struct xfrm_dump_info {
 	struct sk_buff *in_skb;
 	struct sk_buff *out_skb;
 	u32 nlmsg_seq;
 	u16 nlmsg_flags;
 	int start_idx;
 	int this_idx;
 };
 static int dump_one_state(struct xfrm_state *x, int count, void *ptr)
 {
 	struct xfrm_dump_info *sp = ptr;
 	struct sk_buff *in_skb = sp->in_skb;
 	struct sk_buff *skb = sp->out_skb;
 	struct xfrm_usersa_info *p;
 	struct nlmsghdr *nlh;
 	unsigned char *b = skb->tail;
 	if (sp->this_idx < sp->start_idx)
 		goto out;
 	nlh = NLMSG_PUT(skb, NETLINK_CB(in_skb).pid,
 			sp->nlmsg_seq,
 			XFRM_MSG_NEWSA, sizeof(*p));
 	nlh->nlmsg_flags = sp->nlmsg_flags;
 	p = NLMSG_DATA(nlh);
 	copy_to_user_state(x, p);
 	if (x->aalg)
 		RTA_PUT(skb, XFRMA_ALG_AUTH,
 			sizeof(*(x->aalg))+(x->aalg->alg_key_len+7)/8, x->aalg);
 	if (x->ealg)
 		RTA_PUT(skb, XFRMA_ALG_CRYPT,
 			sizeof(*(x->ealg))+(x->ealg->alg_key_len+7)/8, x->ealg);
 	if (x->calg)
 		RTA_PUT(skb, XFRMA_ALG_COMP, sizeof(*(x->calg)), x->calg);
 	if (x->encap)
 		RTA_PUT(skb, XFRMA_ENCAP, sizeof(*x->encap), x->encap);
 	if (x->security) {
 		int ctx_size = sizeof(struct xfrm_sec_ctx) +
 				x->security->ctx_len;
 		struct rtattr *rt = __RTA_PUT(skb, XFRMA_SEC_CTX, ctx_size);
 		struct xfrm_user_sec_ctx *uctx = RTA_DATA(rt);
 		uctx->exttype = XFRMA_SEC_CTX;
 		uctx->len = ctx_size;
 		uctx->ctx_doi = x->security->ctx_doi;
 		uctx->ctx_alg = x->security->ctx_alg;
 		uctx->ctx_len = x->security->ctx_len;
 		memcpy(uctx + 1, x->security->ctx_str, x->security->ctx_len);
 	}
 	if (x->coaddr)
 		RTA_PUT(skb, XFRMA_COADDR, sizeof(*x->coaddr), x->coaddr);
 	if (x->lastused)
 		RTA_PUT(skb, XFRMA_LASTUSED, sizeof(x->lastused), &x->lastused);
 	nlh->nlmsg_len = skb->tail - b;
 out:
 	sp->this_idx++;
 	return 0;
 nlmsg_failure:
 rtattr_failure:
 	skb_trim(skb, b - skb->data);
 	return -1;
 }
 static int xfrm_dump_sa(struct sk_buff *skb, struct netlink_callback *cb)
 {
 	struct xfrm_dump_info info;
 	info.in_skb = cb->skb;
 	info.out_skb = skb;
 	info.nlmsg_seq = cb->nlh->nlmsg_seq;
 	info.nlmsg_flags = NLM_F_MULTI;
 	info.this_idx = 0;
 	info.start_idx = cb->args[0];
 	(void) xfrm_state_walk(0, dump_one_state, &info);
 	cb->args[0] = info.this_idx;
 	return skb->len;
 }
 static struct sk_buff *xfrm_state_netlink(struct sk_buff *in_skb,
 					  struct xfrm_state *x, u32 seq)
 {
 	struct xfrm_dump_info info;
 	struct sk_buff *skb;
 	skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
 	if (!skb)
 		return ERR_PTR(-ENOMEM);
-	NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
 	info.in_skb = in_skb;
 	info.out_skb = skb;
 	info.nlmsg_seq = seq;
 	info.nlmsg_flags = 0;
 	info.this_idx = info.start_idx = 0;
 	if (dump_one_state(x, 0, &info)) {
 		kfree_skb(skb);
 		return NULL;
 	}
 	return skb;
 }
 static int xfrm_get_sa(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_usersa_id *p = NLMSG_DATA(nlh);
 	struct xfrm_state *x;
 	struct sk_buff *resp_skb;
 	int err = -ESRCH;
 	x = xfrm_user_state_lookup(p, (struct rtattr **)xfrma, &err);
 	if (x == NULL)
 		goto out_noput;
 	resp_skb = xfrm_state_netlink(skb, x, nlh->nlmsg_seq);
 	if (IS_ERR(resp_skb)) {
 		err = PTR_ERR(resp_skb);
 	} else {
 		err = netlink_unicast(xfrm_nl, resp_skb,
 				      NETLINK_CB(skb).pid, MSG_DONTWAIT);
 	}
 	xfrm_state_put(x);
 out_noput:
 	return err;
 }
 static int verify_userspi_info(struct xfrm_userspi_info *p)
 {
 	switch (p->info.id.proto) {
 	case IPPROTO_AH:
 	case IPPROTO_ESP:
 		break;
 	case IPPROTO_COMP:
 		/* IPCOMP spi is 16-bits. */
 		if (p->max >= 0x10000)
 			return -EINVAL;
 		break;
 	default:
 		return -EINVAL;
 	};
 	if (p->min > p->max)
 		return -EINVAL;
 	return 0;
 }
 static int xfrm_alloc_userspi(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_state *x;
 	struct xfrm_userspi_info *p;
 	struct sk_buff *resp_skb;
 	xfrm_address_t *daddr;
 	int family;
 	int err;
 	p = NLMSG_DATA(nlh);
 	err = verify_userspi_info(p);
 	if (err)
 		goto out_noput;
 	family = p->info.family;
 	daddr = &p->info.id.daddr;
 	x = NULL;
 	if (p->info.seq) {
 		x = xfrm_find_acq_byseq(p->info.seq);
 		if (x && xfrm_addr_cmp(&x->id.daddr, daddr, family)) {
 			xfrm_state_put(x);
 			x = NULL;
 		}
 	}
 	if (!x)
 		x = xfrm_find_acq(p->info.mode, p->info.reqid,
 				  p->info.id.proto, daddr,
 				  &p->info.saddr, 1,
 				  family);
 	err = -ENOENT;
 	if (x == NULL)
 		goto out_noput;
 	resp_skb = ERR_PTR(-ENOENT);
 	spin_lock_bh(&x->lock);
 	if (x->km.state != XFRM_STATE_DEAD) {
 		xfrm_alloc_spi(x, htonl(p->min), htonl(p->max));
 		if (x->id.spi)
 			resp_skb = xfrm_state_netlink(skb, x, nlh->nlmsg_seq);
 	}
 	spin_unlock_bh(&x->lock);
 	if (IS_ERR(resp_skb)) {
 		err = PTR_ERR(resp_skb);
 		goto out;
 	}
 	err = netlink_unicast(xfrm_nl, resp_skb,
 			      NETLINK_CB(skb).pid, MSG_DONTWAIT);
 out:
 	xfrm_state_put(x);
 out_noput:
 	return err;
 }
 static int verify_policy_dir(__u8 dir)
 {
 	switch (dir) {
 	case XFRM_POLICY_IN:
 	case XFRM_POLICY_OUT:
 	case XFRM_POLICY_FWD:
 		break;
 	default:
 		return -EINVAL;
 	};
 	return 0;
 }
 static int verify_policy_type(__u8 type)
 {
 	switch (type) {
 	case XFRM_POLICY_TYPE_MAIN:
 #ifdef CONFIG_XFRM_SUB_POLICY
 	case XFRM_POLICY_TYPE_SUB:
 #endif
 		break;
 	default:
 		return -EINVAL;
 	};
 	return 0;
 }
 static int verify_newpolicy_info(struct xfrm_userpolicy_info *p)
 {
 	switch (p->share) {
 	case XFRM_SHARE_ANY:
 	case XFRM_SHARE_SESSION:
 	case XFRM_SHARE_USER:
 	case XFRM_SHARE_UNIQUE:
 		break;
 	default:
 		return -EINVAL;
 	};
 	switch (p->action) {
 	case XFRM_POLICY_ALLOW:
 	case XFRM_POLICY_BLOCK:
 		break;
 	default:
 		return -EINVAL;
 	};
 	switch (p->sel.family) {
 	case AF_INET:
 		break;
 	case AF_INET6:
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 		break;
 #else
 		return  -EAFNOSUPPORT;
 #endif
 	default:
 		return -EINVAL;
 	};
 	return verify_policy_dir(p->dir);
 }
 static int copy_from_user_sec_ctx(struct xfrm_policy *pol, struct rtattr **xfrma)
 {
 	struct rtattr *rt = xfrma[XFRMA_SEC_CTX-1];
 	struct xfrm_user_sec_ctx *uctx;
 	if (!rt)
 		return 0;
 	uctx = RTA_DATA(rt);
 	return security_xfrm_policy_alloc(pol, uctx);
 }
 static void copy_templates(struct xfrm_policy *xp, struct xfrm_user_tmpl *ut,
 			   int nr)
 {
 	int i;
 	xp->xfrm_nr = nr;
 	for (i = 0; i < nr; i++, ut++) {
 		struct xfrm_tmpl *t = &xp->xfrm_vec[i];
 		memcpy(&t->id, &ut->id, sizeof(struct xfrm_id));
 		memcpy(&t->saddr, &ut->saddr,
 		       sizeof(xfrm_address_t));
 		t->reqid = ut->reqid;
 		t->mode = ut->mode;
 		t->share = ut->share;
 		t->optional = ut->optional;
 		t->aalgos = ut->aalgos;
 		t->ealgos = ut->ealgos;
 		t->calgos = ut->calgos;
 	}
 }
 static int copy_from_user_tmpl(struct xfrm_policy *pol, struct rtattr **xfrma)
 {
 	struct rtattr *rt = xfrma[XFRMA_TMPL-1];
 	struct xfrm_user_tmpl *utmpl;
 	int nr;
 	if (!rt) {
 		pol->xfrm_nr = 0;
 	} else {
 		nr = (rt->rta_len - sizeof(*rt)) / sizeof(*utmpl);
 		if (nr > XFRM_MAX_DEPTH)
 			return -EINVAL;
 		copy_templates(pol, RTA_DATA(rt), nr);
 	}
 	return 0;
 }
 static int copy_from_user_policy_type(u8 *tp, struct rtattr **xfrma)
 {
 	struct rtattr *rt = xfrma[XFRMA_POLICY_TYPE-1];
 	struct xfrm_userpolicy_type *upt;
 	__u8 type = XFRM_POLICY_TYPE_MAIN;
 	int err;
 	if (rt) {
 		if (rt->rta_len < sizeof(*upt))
 			return -EINVAL;
 		upt = RTA_DATA(rt);
 		type = upt->type;
 	}
 	err = verify_policy_type(type);
 	if (err)
 		return err;
 	*tp = type;
 	return 0;
 }
 static void copy_from_user_policy(struct xfrm_policy *xp, struct xfrm_userpolicy_info *p)
 {
 	xp->priority = p->priority;
 	xp->index = p->index;
 	memcpy(&xp->selector, &p->sel, sizeof(xp->selector));
 	memcpy(&xp->lft, &p->lft, sizeof(xp->lft));
 	xp->action = p->action;
 	xp->flags = p->flags;
 	xp->family = p->sel.family;
 	/* XXX xp->share = p->share; */
 }
 static void copy_to_user_policy(struct xfrm_policy *xp, struct xfrm_userpolicy_info *p, int dir)
 {
 	memcpy(&p->sel, &xp->selector, sizeof(p->sel));
 	memcpy(&p->lft, &xp->lft, sizeof(p->lft));
 	memcpy(&p->curlft, &xp->curlft, sizeof(p->curlft));
 	p->priority = xp->priority;
 	p->index = xp->index;
 	p->sel.family = xp->family;
 	p->dir = dir;
 	p->action = xp->action;
 	p->flags = xp->flags;
 	p->share = XFRM_SHARE_ANY; /* XXX xp->share */
 }
 static struct xfrm_policy *xfrm_policy_construct(struct xfrm_userpolicy_info *p, struct rtattr **xfrma, int *errp)
 {
 	struct xfrm_policy *xp = xfrm_policy_alloc(GFP_KERNEL);
 	int err;
 	if (!xp) {
 		*errp = -ENOMEM;
 		return NULL;
 	}
 	copy_from_user_policy(xp, p);
 	err = copy_from_user_policy_type(&xp->type, xfrma);
 	if (err)
 		goto error;
 	if (!(err = copy_from_user_tmpl(xp, xfrma)))
 		err = copy_from_user_sec_ctx(xp, xfrma);
 	if (err)
 		goto error;
 	return xp;
  error:
 	*errp = err;
 	kfree(xp);
 	return NULL;
 }
 static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_userpolicy_info *p = NLMSG_DATA(nlh);
 	struct xfrm_policy *xp;
 	struct km_event c;
 	int err;
 	int excl;
 	err = verify_newpolicy_info(p);
 	if (err)
 		return err;
 	err = verify_sec_ctx_len((struct rtattr **)xfrma);
 	if (err)
 		return err;
 	xp = xfrm_policy_construct(p, (struct rtattr **)xfrma, &err);
 	if (!xp)
 		return err;
 	/* shouldnt excl be based on nlh flags??
 	 * Aha! this is anti-netlink really i.e  more pfkey derived
 	 * in netlink excl is a flag and you wouldnt need
 	 * a type XFRM_MSG_UPDPOLICY - JHS */
 	excl = nlh->nlmsg_type == XFRM_MSG_NEWPOLICY;
 	err = xfrm_policy_insert(p->dir, xp, excl);
 	if (err) {
 		security_xfrm_policy_free(xp);
 		kfree(xp);
 		return err;
 	}
 	c.event = nlh->nlmsg_type;
 	c.seq = nlh->nlmsg_seq;
 	c.pid = nlh->nlmsg_pid;
 	km_policy_notify(xp, p->dir, &c);
 	xfrm_pol_put(xp);
 	return 0;
 }
 static int copy_to_user_tmpl(struct xfrm_policy *xp, struct sk_buff *skb)
 {
 	struct xfrm_user_tmpl vec[XFRM_MAX_DEPTH];
 	int i;
 	if (xp->xfrm_nr == 0)
 		return 0;
 	for (i = 0; i < xp->xfrm_nr; i++) {
 		struct xfrm_user_tmpl *up = &vec[i];
 		struct xfrm_tmpl *kp = &xp->xfrm_vec[i];
 		memcpy(&up->id, &kp->id, sizeof(up->id));
 		up->family = xp->family;
 		memcpy(&up->saddr, &kp->saddr, sizeof(up->saddr));
 		up->reqid = kp->reqid;
 		up->mode = kp->mode;
 		up->share = kp->share;
 		up->optional = kp->optional;
 		up->aalgos = kp->aalgos;
 		up->ealgos = kp->ealgos;
 		up->calgos = kp->calgos;
 	}
 	RTA_PUT(skb, XFRMA_TMPL,
 		(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr),
 		vec);
 	return 0;
 rtattr_failure:
 	return -1;
 }
 static int copy_sec_ctx(struct xfrm_sec_ctx *s, struct sk_buff *skb)
 {
 	int ctx_size = sizeof(struct xfrm_sec_ctx) + s->ctx_len;
 	struct rtattr *rt = __RTA_PUT(skb, XFRMA_SEC_CTX, ctx_size);
 	struct xfrm_user_sec_ctx *uctx = RTA_DATA(rt);
 	uctx->exttype = XFRMA_SEC_CTX;
 	uctx->len = ctx_size;
 	uctx->ctx_doi = s->ctx_doi;
 	uctx->ctx_alg = s->ctx_alg;
 	uctx->ctx_len = s->ctx_len;
 	memcpy(uctx + 1, s->ctx_str, s->ctx_len);
  	return 0;
  rtattr_failure:
 	return -1;
 }
 static inline int copy_to_user_state_sec_ctx(struct xfrm_state *x, struct sk_buff *skb)
 {
 	if (x->security) {
 		return copy_sec_ctx(x->security, skb);
 	}
 	return 0;
 }
 static inline int copy_to_user_sec_ctx(struct xfrm_policy *xp, struct sk_buff *skb)
 {
 	if (xp->security) {
 		return copy_sec_ctx(xp->security, skb);
 	}
 	return 0;
 }
 #ifdef CONFIG_XFRM_SUB_POLICY
 static int copy_to_user_policy_type(__u8 type, struct sk_buff *skb)
 {
 	struct xfrm_userpolicy_type upt;
 	memset(&upt, 0, sizeof(upt));
 	upt.type = type;
 	RTA_PUT(skb, XFRMA_POLICY_TYPE, sizeof(upt), &upt);
 	return 0;
 rtattr_failure:
 	return -1;
 }
 #else
 static inline int copy_to_user_policy_type(__u8 type, struct sk_buff *skb)
 {
 	return 0;
 }
 #endif
 static int dump_one_policy(struct xfrm_policy *xp, int dir, int count, void *ptr)
 {
 	struct xfrm_dump_info *sp = ptr;
 	struct xfrm_userpolicy_info *p;
 	struct sk_buff *in_skb = sp->in_skb;
 	struct sk_buff *skb = sp->out_skb;
 	struct nlmsghdr *nlh;
 	unsigned char *b = skb->tail;
 	if (sp->this_idx < sp->start_idx)
 		goto out;
 	nlh = NLMSG_PUT(skb, NETLINK_CB(in_skb).pid,
 			sp->nlmsg_seq,
 			XFRM_MSG_NEWPOLICY, sizeof(*p));
 	p = NLMSG_DATA(nlh);
 	nlh->nlmsg_flags = sp->nlmsg_flags;
 	copy_to_user_policy(xp, p, dir);
 	if (copy_to_user_tmpl(xp, skb) < 0)
 		goto nlmsg_failure;
 	if (copy_to_user_sec_ctx(xp, skb))
 		goto nlmsg_failure;
 	if (copy_to_user_policy_type(xp->type, skb) < 0)
 		goto nlmsg_failure;
 	nlh->nlmsg_len = skb->tail - b;
 out:
 	sp->this_idx++;
 	return 0;
 nlmsg_failure:
 	skb_trim(skb, b - skb->data);
 	return -1;
 }
 static int xfrm_dump_policy(struct sk_buff *skb, struct netlink_callback *cb)
 {
 	struct xfrm_dump_info info;
 	info.in_skb = cb->skb;
 	info.out_skb = skb;
 	info.nlmsg_seq = cb->nlh->nlmsg_seq;
 	info.nlmsg_flags = NLM_F_MULTI;
 	info.this_idx = 0;
 	info.start_idx = cb->args[0];
 	(void) xfrm_policy_walk(XFRM_POLICY_TYPE_MAIN, dump_one_policy, &info);
 #ifdef CONFIG_XFRM_SUB_POLICY
 	(void) xfrm_policy_walk(XFRM_POLICY_TYPE_SUB, dump_one_policy, &info);
 #endif
 	cb->args[0] = info.this_idx;
 	return skb->len;
 }
 static struct sk_buff *xfrm_policy_netlink(struct sk_buff *in_skb,
 					  struct xfrm_policy *xp,
 					  int dir, u32 seq)
 {
 	struct xfrm_dump_info info;
 	struct sk_buff *skb;
 	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (!skb)
 		return ERR_PTR(-ENOMEM);
-	NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
 	info.in_skb = in_skb;
 	info.out_skb = skb;
 	info.nlmsg_seq = seq;
 	info.nlmsg_flags = 0;
 	info.this_idx = info.start_idx = 0;
 	if (dump_one_policy(xp, dir, 0, &info) < 0) {
 		kfree_skb(skb);
 		return NULL;
 	}
 	return skb;
 }
 static int xfrm_get_policy(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_policy *xp;
 	struct xfrm_userpolicy_id *p;
 	__u8 type = XFRM_POLICY_TYPE_MAIN;
 	int err;
 	struct km_event c;
 	int delete;
 	p = NLMSG_DATA(nlh);
 	delete = nlh->nlmsg_type == XFRM_MSG_DELPOLICY;
 	err = copy_from_user_policy_type(&type, (struct rtattr **)xfrma);
 	if (err)
 		return err;
 	err = verify_policy_dir(p->dir);
 	if (err)
 		return err;
 	if (p->index)
 		xp = xfrm_policy_byid(type, p->dir, p->index, delete);
 	else {
 		struct rtattr **rtattrs = (struct rtattr **)xfrma;
 		struct rtattr *rt = rtattrs[XFRMA_SEC_CTX-1];
 		struct xfrm_policy tmp;
 		err = verify_sec_ctx_len(rtattrs);
 		if (err)
 			return err;
 		memset(&tmp, 0, sizeof(struct xfrm_policy));
 		if (rt) {
 			struct xfrm_user_sec_ctx *uctx = RTA_DATA(rt);
 			if ((err = security_xfrm_policy_alloc(&tmp, uctx)))
 				return err;
 		}
 		xp = xfrm_policy_bysel_ctx(type, p->dir, &p->sel, tmp.security, delete);
 		security_xfrm_policy_free(&tmp);
 	}
 	if (xp == NULL)
 		return -ENOENT;
 	if (!delete) {
 		struct sk_buff *resp_skb;
 		resp_skb = xfrm_policy_netlink(skb, xp, p->dir, nlh->nlmsg_seq);
 		if (IS_ERR(resp_skb)) {
 			err = PTR_ERR(resp_skb);
 		} else {
 			err = netlink_unicast(xfrm_nl, resp_skb,
 					      NETLINK_CB(skb).pid,
 					      MSG_DONTWAIT);
 		}
 	} else {
 		if ((err = security_xfrm_policy_delete(xp)) != 0)
 			goto out;
 		c.data.byid = p->index;
 		c.event = nlh->nlmsg_type;
 		c.seq = nlh->nlmsg_seq;
 		c.pid = nlh->nlmsg_pid;
 		km_policy_notify(xp, p->dir, &c);
 	}
 	xfrm_pol_put(xp);
 out:
 	return err;
 }
 static int xfrm_flush_sa(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct km_event c;
 	struct xfrm_usersa_flush *p = NLMSG_DATA(nlh);
 	xfrm_state_flush(p->proto);
 	c.data.proto = p->proto;
 	c.event = nlh->nlmsg_type;
 	c.seq = nlh->nlmsg_seq;
 	c.pid = nlh->nlmsg_pid;
 	km_state_notify(NULL, &c);
 	return 0;
 }
 static int build_aevent(struct sk_buff *skb, struct xfrm_state *x, struct km_event *c)
 {
 	struct xfrm_aevent_id *id;
 	struct nlmsghdr *nlh;
 	struct xfrm_lifetime_cur ltime;
 	unsigned char *b = skb->tail;
 	nlh = NLMSG_PUT(skb, c->pid, c->seq, XFRM_MSG_NEWAE, sizeof(*id));
 	id = NLMSG_DATA(nlh);
 	nlh->nlmsg_flags = 0;
 	id->sa_id.daddr = x->id.daddr;
 	id->sa_id.spi = x->id.spi;
 	id->sa_id.family = x->props.family;
 	id->sa_id.proto = x->id.proto;
 	id->flags = c->data.aevent;
 	RTA_PUT(skb, XFRMA_REPLAY_VAL, sizeof(x->replay), &x->replay);
 	ltime.bytes = x->curlft.bytes;
 	ltime.packets = x->curlft.packets;
 	ltime.add_time = x->curlft.add_time;
 	ltime.use_time = x->curlft.use_time;
 	RTA_PUT(skb, XFRMA_LTIME_VAL, sizeof(struct xfrm_lifetime_cur), &ltime);
 	if (id->flags&XFRM_AE_RTHR) {
 		RTA_PUT(skb,XFRMA_REPLAY_THRESH,sizeof(u32),&x->replay_maxdiff);
 	}
 	if (id->flags&XFRM_AE_ETHR) {
 		u32 etimer = x->replay_maxage*10/HZ;
 		RTA_PUT(skb,XFRMA_ETIMER_THRESH,sizeof(u32),&etimer);
 	}
 	nlh->nlmsg_len = skb->tail - b;
 	return skb->len;
 rtattr_failure:
 nlmsg_failure:
 	skb_trim(skb, b - skb->data);
 	return -1;
 }
 static int xfrm_get_ae(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_state *x;
 	struct sk_buff *r_skb;
 	int err;
 	struct km_event c;
 	struct xfrm_aevent_id *p = NLMSG_DATA(nlh);
 	int len = NLMSG_LENGTH(sizeof(struct xfrm_aevent_id));
 	struct xfrm_usersa_id *id = &p->sa_id;
 	len += RTA_SPACE(sizeof(struct xfrm_replay_state));
 	len += RTA_SPACE(sizeof(struct xfrm_lifetime_cur));
 	if (p->flags&XFRM_AE_RTHR)
 		len+=RTA_SPACE(sizeof(u32));
 	if (p->flags&XFRM_AE_ETHR)
 		len+=RTA_SPACE(sizeof(u32));
 	r_skb = alloc_skb(len, GFP_ATOMIC);
 	if (r_skb == NULL)
 		return -ENOMEM;
 	x = xfrm_state_lookup(&id->daddr, id->spi, id->proto, id->family);
 	if (x == NULL) {
 		kfree(r_skb);
 		return -ESRCH;
 	}
 	/*
 	 * XXX: is this lock really needed - none of the other
 	 * gets lock (the concern is things getting updated
 	 * while we are still reading) - jhs
 	*/
 	spin_lock_bh(&x->lock);
 	c.data.aevent = p->flags;
 	c.seq = nlh->nlmsg_seq;
 	c.pid = nlh->nlmsg_pid;
 	if (build_aevent(r_skb, x, &c) < 0)
 		BUG();
 	err = netlink_unicast(xfrm_nl, r_skb,
 			      NETLINK_CB(skb).pid, MSG_DONTWAIT);
 	spin_unlock_bh(&x->lock);
 	xfrm_state_put(x);
 	return err;
 }
 static int xfrm_new_ae(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_state *x;
 	struct km_event c;
 	int err = - EINVAL;
 	struct xfrm_aevent_id *p = NLMSG_DATA(nlh);
 	struct rtattr *rp = xfrma[XFRMA_REPLAY_VAL-1];
 	struct rtattr *lt = xfrma[XFRMA_LTIME_VAL-1];
 	if (!lt && !rp)
 		return err;
 	/* pedantic mode - thou shalt sayeth replaceth */
 	if (!(nlh->nlmsg_flags&NLM_F_REPLACE))
 		return err;
 	x = xfrm_state_lookup(&p->sa_id.daddr, p->sa_id.spi, p->sa_id.proto, p->sa_id.family);
 	if (x == NULL)
 		return -ESRCH;
 	if (x->km.state != XFRM_STATE_VALID)
 		goto out;
 	spin_lock_bh(&x->lock);
 	err = xfrm_update_ae_params(x,(struct rtattr **)xfrma);
 	spin_unlock_bh(&x->lock);
 	if (err	< 0)
 		goto out;
 	c.event = nlh->nlmsg_type;
 	c.seq = nlh->nlmsg_seq;
 	c.pid = nlh->nlmsg_pid;
 	c.data.aevent = XFRM_AE_CU;
 	km_state_notify(x, &c);
 	err = 0;
 out:
 	xfrm_state_put(x);
 	return err;
 }
 static int xfrm_flush_policy(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct km_event c;
 	__u8 type = XFRM_POLICY_TYPE_MAIN;
 	int err;
 	err = copy_from_user_policy_type(&type, (struct rtattr **)xfrma);
 	if (err)
 		return err;
 	xfrm_policy_flush(type);
 	c.data.type = type;
 	c.event = nlh->nlmsg_type;
 	c.seq = nlh->nlmsg_seq;
 	c.pid = nlh->nlmsg_pid;
 	km_policy_notify(NULL, 0, &c);
 	return 0;
 }
 static int xfrm_add_pol_expire(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_policy *xp;
 	struct xfrm_user_polexpire *up = NLMSG_DATA(nlh);
 	struct xfrm_userpolicy_info *p = &up->pol;
 	__u8 type = XFRM_POLICY_TYPE_MAIN;
 	int err = -ENOENT;
 	err = copy_from_user_policy_type(&type, (struct rtattr **)xfrma);
 	if (err)
 		return err;
 	if (p->index)
 		xp = xfrm_policy_byid(type, p->dir, p->index, 0);
 	else {
 		struct rtattr **rtattrs = (struct rtattr **)xfrma;
 		struct rtattr *rt = rtattrs[XFRMA_SEC_CTX-1];
 		struct xfrm_policy tmp;
 		err = verify_sec_ctx_len(rtattrs);
 		if (err)
 			return err;
 		memset(&tmp, 0, sizeof(struct xfrm_policy));
 		if (rt) {
 			struct xfrm_user_sec_ctx *uctx = RTA_DATA(rt);
 			if ((err = security_xfrm_policy_alloc(&tmp, uctx)))
 				return err;
 		}
 		xp = xfrm_policy_bysel_ctx(type, p->dir, &p->sel, tmp.security, 0);
 		security_xfrm_policy_free(&tmp);
 	}
 	if (xp == NULL)
 		return err;
 											read_lock(&xp->lock);
 	if (xp->dead) {
 		read_unlock(&xp->lock);
 		goto out;
 	}
 	read_unlock(&xp->lock);
 	err = 0;
 	if (up->hard) {
 		xfrm_policy_delete(xp, p->dir);
 	} else {
 		// reset the timers here?
 		printk("Dont know what to do with soft policy expire\n");
 	}
 	km_policy_expired(xp, p->dir, up->hard, current->pid);
 out:
 	xfrm_pol_put(xp);
 	return err;
 }
 static int xfrm_add_sa_expire(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_state *x;
 	int err;
 	struct xfrm_user_expire *ue = NLMSG_DATA(nlh);
 	struct xfrm_usersa_info *p = &ue->state;
 	x = xfrm_state_lookup(&p->id.daddr, p->id.spi, p->id.proto, p->family);
 		err = -ENOENT;
 	if (x == NULL)
 		return err;
 	err = -EINVAL;
 	spin_lock_bh(&x->lock);
 	if (x->km.state != XFRM_STATE_VALID)
 		goto out;
 	km_state_expired(x, ue->hard, current->pid);
 	if (ue->hard)
 		__xfrm_state_delete(x);
 out:
 	spin_unlock_bh(&x->lock);
 	xfrm_state_put(x);
 	return err;
 }
 static int xfrm_add_acquire(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma)
 {
 	struct xfrm_policy *xp;
 	struct xfrm_user_tmpl *ut;
 	int i;
 	struct rtattr *rt = xfrma[XFRMA_TMPL-1];
 	struct xfrm_user_acquire *ua = NLMSG_DATA(nlh);
 	struct xfrm_state *x = xfrm_state_alloc();
 	int err = -ENOMEM;
 	if (!x)
 		return err;
 	err = verify_newpolicy_info(&ua->policy);
 	if (err) {
 		printk("BAD policy passed\n");
 		kfree(x);
 		return err;
 	}
 	/*   build an XP */
 	xp = xfrm_policy_construct(&ua->policy, (struct rtattr **) xfrma, &err);        if (!xp) {
 		kfree(x);
 		return err;
 	}
 	memcpy(&x->id, &ua->id, sizeof(ua->id));
 	memcpy(&x->props.saddr, &ua->saddr, sizeof(ua->saddr));
 	memcpy(&x->sel, &ua->sel, sizeof(ua->sel));
 	ut = RTA_DATA(rt);
 	/* extract the templates and for each call km_key */
 	for (i = 0; i < xp->xfrm_nr; i++, ut++) {
 		struct xfrm_tmpl *t = &xp->xfrm_vec[i];
 		memcpy(&x->id, &t->id, sizeof(x->id));
 		x->props.mode = t->mode;
 		x->props.reqid = t->reqid;
 		x->props.family = ut->family;
 		t->aalgos = ua->aalgos;
 		t->ealgos = ua->ealgos;
 		t->calgos = ua->calgos;
 		err = km_query(x, t, xp);
 	}
 	kfree(x);
 	kfree(xp);
 	return 0;
 }
 #define XMSGSIZE(type) NLMSG_LENGTH(sizeof(struct type))
 static const int xfrm_msg_min[XFRM_NR_MSGTYPES] = {
 	[XFRM_MSG_NEWSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_info),
 	[XFRM_MSG_DELSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_id),
 	[XFRM_MSG_GETSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_id),
 	[XFRM_MSG_NEWPOLICY   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_info),
 	[XFRM_MSG_DELPOLICY   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
 	[XFRM_MSG_GETPOLICY   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
 	[XFRM_MSG_ALLOCSPI    - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userspi_info),
 	[XFRM_MSG_ACQUIRE     - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_acquire),
 	[XFRM_MSG_EXPIRE      - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_expire),
 	[XFRM_MSG_UPDPOLICY   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_info),
 	[XFRM_MSG_UPDSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_info),
 	[XFRM_MSG_POLEXPIRE   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_polexpire),
 	[XFRM_MSG_FLUSHSA     - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_flush),
 	[XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = NLMSG_LENGTH(0),
 	[XFRM_MSG_NEWAE       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
 	[XFRM_MSG_GETAE       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
 	[XFRM_MSG_REPORT      - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_report),
 };
 #undef XMSGSIZE
 static struct xfrm_link {
 	int (*doit)(struct sk_buff *, struct nlmsghdr *, void **);
 	int (*dump)(struct sk_buff *, struct netlink_callback *);
 } xfrm_dispatch[XFRM_NR_MSGTYPES] = {
 	[XFRM_MSG_NEWSA       - XFRM_MSG_BASE] = { .doit = xfrm_add_sa        },
 	[XFRM_MSG_DELSA       - XFRM_MSG_BASE] = { .doit = xfrm_del_sa        },
 	[XFRM_MSG_GETSA       - XFRM_MSG_BASE] = { .doit = xfrm_get_sa,
 						   .dump = xfrm_dump_sa       },
 	[XFRM_MSG_NEWPOLICY   - XFRM_MSG_BASE] = { .doit = xfrm_add_policy    },
 	[XFRM_MSG_DELPOLICY   - XFRM_MSG_BASE] = { .doit = xfrm_get_policy    },
 	[XFRM_MSG_GETPOLICY   - XFRM_MSG_BASE] = { .doit = xfrm_get_policy,
 						   .dump = xfrm_dump_policy   },
 	[XFRM_MSG_ALLOCSPI    - XFRM_MSG_BASE] = { .doit = xfrm_alloc_userspi },
 	[XFRM_MSG_ACQUIRE     - XFRM_MSG_BASE] = { .doit = xfrm_add_acquire   },
 	[XFRM_MSG_EXPIRE      - XFRM_MSG_BASE] = { .doit = xfrm_add_sa_expire },
 	[XFRM_MSG_UPDPOLICY   - XFRM_MSG_BASE] = { .doit = xfrm_add_policy    },
 	[XFRM_MSG_UPDSA       - XFRM_MSG_BASE] = { .doit = xfrm_add_sa        },
 	[XFRM_MSG_POLEXPIRE   - XFRM_MSG_BASE] = { .doit = xfrm_add_pol_expire},
 	[XFRM_MSG_FLUSHSA     - XFRM_MSG_BASE] = { .doit = xfrm_flush_sa      },
 	[XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_flush_policy  },
 	[XFRM_MSG_NEWAE       - XFRM_MSG_BASE] = { .doit = xfrm_new_ae  },
 	[XFRM_MSG_GETAE       - XFRM_MSG_BASE] = { .doit = xfrm_get_ae  },
 };
 static int xfrm_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, int *errp)
 {
 	struct rtattr *xfrma[XFRMA_MAX];
 	struct xfrm_link *link;
 	int type, min_len;
 	if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
 		return 0;
 	type = nlh->nlmsg_type;
 	/* A control message: ignore them */
 	if (type < XFRM_MSG_BASE)
 		return 0;
 	/* Unknown message: reply with EINVAL */
 	if (type > XFRM_MSG_MAX)
 		goto err_einval;
 	type -= XFRM_MSG_BASE;
 	link = &xfrm_dispatch[type];
 	/* All operations require privileges, even GET */
 	if (security_netlink_recv(skb, CAP_NET_ADMIN)) {
 		*errp = -EPERM;
 		return -1;
 	}
 	if ((type == (XFRM_MSG_GETSA - XFRM_MSG_BASE) ||
 	     type == (XFRM_MSG_GETPOLICY - XFRM_MSG_BASE)) &&
 	    (nlh->nlmsg_flags & NLM_F_DUMP)) {
 		if (link->dump == NULL)
 			goto err_einval;
 		if ((*errp = netlink_dump_start(xfrm_nl, skb, nlh,
 						link->dump, NULL)) != 0) {
 			return -1;
 		}
 		netlink_queue_skip(nlh, skb);
 		return -1;
 	}
 	memset(xfrma, 0, sizeof(xfrma));
 	if (nlh->nlmsg_len < (min_len = xfrm_msg_min[type]))
 		goto err_einval;
 	if (nlh->nlmsg_len > min_len) {
 		int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len);
 		struct rtattr *attr = (void *) nlh + NLMSG_ALIGN(min_len);
 		while (RTA_OK(attr, attrlen)) {
 			unsigned short flavor = attr->rta_type;
 			if (flavor) {
 				if (flavor > XFRMA_MAX)
 					goto err_einval;
 				xfrma[flavor - 1] = attr;
 			}
 			attr = RTA_NEXT(attr, attrlen);
 		}
 	}
 	if (link->doit == NULL)
 		goto err_einval;
 	*errp = link->doit(skb, nlh, (void **) &xfrma);
 	return *errp;
 err_einval:
 	*errp = -EINVAL;
 	return -1;
 }
 static void xfrm_netlink_rcv(struct sock *sk, int len)
 {
 	unsigned int qlen = 0;
 	do {
 		mutex_lock(&xfrm_cfg_mutex);
 		netlink_run_queue(sk, &qlen, &xfrm_user_rcv_msg);
 		mutex_unlock(&xfrm_cfg_mutex);
 	} while (qlen);
 }
 static int build_expire(struct sk_buff *skb, struct xfrm_state *x, struct km_event *c)
 {
 	struct xfrm_user_expire *ue;
 	struct nlmsghdr *nlh;
 	unsigned char *b = skb->tail;
 	nlh = NLMSG_PUT(skb, c->pid, 0, XFRM_MSG_EXPIRE,
 			sizeof(*ue));
 	ue = NLMSG_DATA(nlh);
 	nlh->nlmsg_flags = 0;
 	copy_to_user_state(x, &ue->state);
 	ue->hard = (c->data.hard != 0) ? 1 : 0;
 	nlh->nlmsg_len = skb->tail - b;
 	return skb->len;
 nlmsg_failure:
 	skb_trim(skb, b - skb->data);
 	return -1;
 }
 static int xfrm_exp_state_notify(struct xfrm_state *x, struct km_event *c)
 {
 	struct sk_buff *skb;
 	int len = NLMSG_LENGTH(sizeof(struct xfrm_user_expire));
 	skb = alloc_skb(len, GFP_ATOMIC);
 	if (skb == NULL)
 		return -ENOMEM;
 	if (build_expire(skb, x, c) < 0)
 		BUG();
 	NETLINK_CB(skb).dst_group = XFRMNLGRP_EXPIRE;
 	return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_EXPIRE, GFP_ATOMIC);
 }
 static int xfrm_aevent_state_notify(struct xfrm_state *x, struct km_event *c)
 {
 	struct sk_buff *skb;
 	int len = NLMSG_LENGTH(sizeof(struct xfrm_aevent_id));
 	len += RTA_SPACE(sizeof(struct xfrm_replay_state));
 	len += RTA_SPACE(sizeof(struct xfrm_lifetime_cur));
 	skb = alloc_skb(len, GFP_ATOMIC);
 	if (skb == NULL)
 		return -ENOMEM;
 	if (build_aevent(skb, x, c) < 0)
 		BUG();
 	NETLINK_CB(skb).dst_group = XFRMNLGRP_AEVENTS;
 	return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_AEVENTS, GFP_ATOMIC);
 }
 static int xfrm_notify_sa_flush(struct km_event *c)
 {
 	struct xfrm_usersa_flush *p;
 	struct nlmsghdr *nlh;
 	struct sk_buff *skb;
 	unsigned char *b;
 	int len = NLMSG_LENGTH(sizeof(struct xfrm_usersa_flush));
 	skb = alloc_skb(len, GFP_ATOMIC);
 	if (skb == NULL)
 		return -ENOMEM;
 	b = skb->tail;
 	nlh = NLMSG_PUT(skb, c->pid, c->seq,
 			XFRM_MSG_FLUSHSA, sizeof(*p));
 	nlh->nlmsg_flags = 0;
 	p = NLMSG_DATA(nlh);
 	p->proto = c->data.proto;
 	nlh->nlmsg_len = skb->tail - b;
 	NETLINK_CB(skb).dst_group = XFRMNLGRP_SA;
 	return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_SA, GFP_ATOMIC);
 nlmsg_failure:
 	kfree_skb(skb);
 	return -1;
 }
 static int inline xfrm_sa_len(struct xfrm_state *x)
 {
 	int l = 0;
 	if (x->aalg)
 		l += RTA_SPACE(sizeof(*x->aalg) + (x->aalg->alg_key_len+7)/8);
 	if (x->ealg)
 		l += RTA_SPACE(sizeof(*x->ealg) + (x->ealg->alg_key_len+7)/8);
 	if (x->calg)
 		l += RTA_SPACE(sizeof(*x->calg));
 	if (x->encap)
 		l += RTA_SPACE(sizeof(*x->encap));
 	return l;
 }
 static int xfrm_notify_sa(struct xfrm_state *x, struct km_event *c)
 {
 	struct xfrm_usersa_info *p;
 	struct xfrm_usersa_id *id;
 	struct nlmsghdr *nlh;
 	struct sk_buff *skb;
 	unsigned char *b;
 	int len = xfrm_sa_len(x);
 	int headlen;
 	headlen = sizeof(*p);
 	if (c->event == XFRM_MSG_DELSA) {
 		len += RTA_SPACE(headlen);
 		headlen = sizeof(*id);
 	}
 	len += NLMSG_SPACE(headlen);
 	skb = alloc_skb(len, GFP_ATOMIC);
 	if (skb == NULL)
 		return -ENOMEM;
 	b = skb->tail;
 	nlh = NLMSG_PUT(skb, c->pid, c->seq, c->event, headlen);
 	nlh->nlmsg_flags = 0;
 	p = NLMSG_DATA(nlh);
 	if (c->event == XFRM_MSG_DELSA) {
 		id = NLMSG_DATA(nlh);
 		memcpy(&id->daddr, &x->id.daddr, sizeof(id->daddr));
 		id->spi = x->id.spi;
 		id->family = x->props.family;
 		id->proto = x->id.proto;
 		p = RTA_DATA(__RTA_PUT(skb, XFRMA_SA, sizeof(*p)));
 	}
 	copy_to_user_state(x, p);
 	if (x->aalg)
 		RTA_PUT(skb, XFRMA_ALG_AUTH,
 			sizeof(*(x->aalg))+(x->aalg->alg_key_len+7)/8, x->aalg);
 	if (x->ealg)
 		RTA_PUT(skb, XFRMA_ALG_CRYPT,
 			sizeof(*(x->ealg))+(x->ealg->alg_key_len+7)/8, x->ealg);
 	if (x->calg)
 		RTA_PUT(skb, XFRMA_ALG_COMP, sizeof(*(x->calg)), x->calg);
 	if (x->encap)
 		RTA_PUT(skb, XFRMA_ENCAP, sizeof(*x->encap), x->encap);
 	nlh->nlmsg_len = skb->tail - b;
 	NETLINK_CB(skb).dst_group = XFRMNLGRP_SA;
 	return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_SA, GFP_ATOMIC);
 nlmsg_failure:
 rtattr_failure:
 	kfree_skb(skb);
 	return -1;
 }
 static int xfrm_send_state_notify(struct xfrm_state *x, struct km_event *c)
 {
 	switch (c->event) {
 	case XFRM_MSG_EXPIRE:
 		return xfrm_exp_state_notify(x, c);
 	case XFRM_MSG_NEWAE:
 		return xfrm_aevent_state_notify(x, c);
 	case XFRM_MSG_DELSA:
 	case XFRM_MSG_UPDSA:
 	case XFRM_MSG_NEWSA:
 		return xfrm_notify_sa(x, c);
 	case XFRM_MSG_FLUSHSA:
 		return xfrm_notify_sa_flush(c);
 	default:
 		 printk("xfrm_user: Unknown SA event %d\n", c->event);
 		 break;
 	}
 	return 0;
 }
 static int build_acquire(struct sk_buff *skb, struct xfrm_state *x,
 			 struct xfrm_tmpl *xt, struct xfrm_policy *xp,
 			 int dir)
 {
 	struct xfrm_user_acquire *ua;
 	struct nlmsghdr *nlh;
 	unsigned char *b = skb->tail;
 	__u32 seq = xfrm_get_acqseq();
 	nlh = NLMSG_PUT(skb, 0, 0, XFRM_MSG_ACQUIRE,
 			sizeof(*ua));
 	ua = NLMSG_DATA(nlh);
 	nlh->nlmsg_flags = 0;
 	memcpy(&ua->id, &x->id, sizeof(ua->id));
 	memcpy(&ua->saddr, &x->props.saddr, sizeof(ua->saddr));
 	memcpy(&ua->sel, &x->sel, sizeof(ua->sel));
 	copy_to_user_policy(xp, &ua->policy, dir);
 	ua->aalgos = xt->aalgos;
 	ua->ealgos = xt->ealgos;
 	ua->calgos = xt->calgos;
 	ua->seq = x->km.seq = seq;
 	if (copy_to_user_tmpl(xp, skb) < 0)
 		goto nlmsg_failure;
 	if (copy_to_user_state_sec_ctx(x, skb))
 		goto nlmsg_failure;
 	if (copy_to_user_policy_type(xp->type, skb) < 0)
 		goto nlmsg_failure;
 	nlh->nlmsg_len = skb->tail - b;
 	return skb->len;
 nlmsg_failure:
 	skb_trim(skb, b - skb->data);
 	return -1;
 }
 static int xfrm_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *xt,
 			     struct xfrm_policy *xp, int dir)
 {
 	struct sk_buff *skb;
 	size_t len;
 	len = RTA_SPACE(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr);
 	len += NLMSG_SPACE(sizeof(struct xfrm_user_acquire));
 	len += RTA_SPACE(xfrm_user_sec_ctx_size(xp));
 #ifdef CONFIG_XFRM_SUB_POLICY
 	len += RTA_SPACE(sizeof(struct xfrm_userpolicy_type));
 #endif
 	skb = alloc_skb(len, GFP_ATOMIC);
 	if (skb == NULL)
 		return -ENOMEM;
 	if (build_acquire(skb, x, xt, xp, dir) < 0)
 		BUG();
 	NETLINK_CB(skb).dst_group = XFRMNLGRP_ACQUIRE;
 	return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_ACQUIRE, GFP_ATOMIC);
 }
 /* User gives us xfrm_user_policy_info followed by an array of 0
  * or more templates.
  */
 static struct xfrm_policy *xfrm_compile_policy(struct sock *sk, int opt,
 					       u8 *data, int len, int *dir)
 {
 	struct xfrm_userpolicy_info *p = (struct xfrm_userpolicy_info *)data;
 	struct xfrm_user_tmpl *ut = (struct xfrm_user_tmpl *) (p + 1);
 	struct xfrm_policy *xp;
 	int nr;
 	switch (sk->sk_family) {
 	case AF_INET:
 		if (opt != IP_XFRM_POLICY) {
 			*dir = -EOPNOTSUPP;
 			return NULL;
 		}
 		break;
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 	case AF_INET6:
 		if (opt != IPV6_XFRM_POLICY) {
 			*dir = -EOPNOTSUPP;
 			return NULL;
 		}
 		break;
 #endif
 	default:
 		*dir = -EINVAL;
 		return NULL;
 	}
 	*dir = -EINVAL;
 	if (len < sizeof(*p) ||
 	    verify_newpolicy_info(p))
 		return NULL;
 	nr = ((len - sizeof(*p)) / sizeof(*ut));
 	if (nr > XFRM_MAX_DEPTH)
 		return NULL;
 	if (p->dir > XFRM_POLICY_OUT)
 		return NULL;
 	xp = xfrm_policy_alloc(GFP_KERNEL);
 	if (xp == NULL) {
 		*dir = -ENOBUFS;
 		return NULL;
 	}
 	copy_from_user_policy(xp, p);
 	xp->type = XFRM_POLICY_TYPE_MAIN;
 	copy_templates(xp, ut, nr);
 	*dir = p->dir;
 	return xp;
 }
 static int build_polexpire(struct sk_buff *skb, struct xfrm_policy *xp,
 			   int dir, struct km_event *c)
 {
 	struct xfrm_user_polexpire *upe;
 	struct nlmsghdr *nlh;
 	int hard = c->data.hard;
 	unsigned char *b = skb->tail;
 	nlh = NLMSG_PUT(skb, c->pid, 0, XFRM_MSG_POLEXPIRE, sizeof(*upe));
 	upe = NLMSG_DATA(nlh);
 	nlh->nlmsg_flags = 0;
 	copy_to_user_policy(xp, &upe->pol, dir);
 	if (copy_to_user_tmpl(xp, skb) < 0)
 		goto nlmsg_failure;
 	if (copy_to_user_sec_ctx(xp, skb))
 		goto nlmsg_failure;
 	if (copy_to_user_policy_type(xp->type, skb) < 0)
 		goto nlmsg_failure;
 	upe->hard = !!hard;
 	nlh->nlmsg_len = skb->tail - b;
 	return skb->len;
 nlmsg_failure:
 	skb_trim(skb, b - skb->data);
 	return -1;
 }
 static int xfrm_exp_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c)
 {
 	struct sk_buff *skb;
 	size_t len;
 	len = RTA_SPACE(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr);
 	len += NLMSG_SPACE(sizeof(struct xfrm_user_polexpire));
 	len += RTA_SPACE(xfrm_user_sec_ctx_size(xp));
 #ifdef CONFIG_XFRM_SUB_POLICY
 	len += RTA_SPACE(sizeof(struct xfrm_userpolicy_type));
 #endif
 	skb = alloc_skb(len, GFP_ATOMIC);
 	if (skb == NULL)
 		return -ENOMEM;
 	if (build_polexpire(skb, xp, dir, c) < 0)
 		BUG();
 	NETLINK_CB(skb).dst_group = XFRMNLGRP_EXPIRE;
 	return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_EXPIRE, GFP_ATOMIC);
 }
 static int xfrm_notify_policy(struct xfrm_policy *xp, int dir, struct km_event *c)
 {
 	struct xfrm_userpolicy_info *p;
 	struct xfrm_userpolicy_id *id;
 	struct nlmsghdr *nlh;
 	struct sk_buff *skb;
 	unsigned char *b;
 	int len = RTA_SPACE(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr);
 	int headlen;
 	headlen = sizeof(*p);
 	if (c->event == XFRM_MSG_DELPOLICY) {
 		len += RTA_SPACE(headlen);
 		headlen = sizeof(*id);
 	}
 #ifdef CONFIG_XFRM_SUB_POLICY
 	len += RTA_SPACE(sizeof(struct xfrm_userpolicy_type));
 #endif
 	len += NLMSG_SPACE(headlen);
 	skb = alloc_skb(len, GFP_ATOMIC);
 	if (skb == NULL)
 		return -ENOMEM;
 	b = skb->tail;
 	nlh = NLMSG_PUT(skb, c->pid, c->seq, c->event, headlen);
 	p = NLMSG_DATA(nlh);
 	if (c->event == XFRM_MSG_DELPOLICY) {
 		id = NLMSG_DATA(nlh);
 		memset(id, 0, sizeof(*id));
 		id->dir = dir;
 		if (c->data.byid)
 			id->index = xp->index;
 		else
 			memcpy(&id->sel, &xp->selector, sizeof(id->sel));
 		p = RTA_DATA(__RTA_PUT(skb, XFRMA_POLICY, sizeof(*p)));
 	}
 	nlh->nlmsg_flags = 0;
 	copy_to_user_policy(xp, p, dir);
 	if (copy_to_user_tmpl(xp, skb) < 0)
 		goto nlmsg_failure;
 	if (copy_to_user_policy_type(xp->type, skb) < 0)
 		goto nlmsg_failure;
 	nlh->nlmsg_len = skb->tail - b;
 	NETLINK_CB(skb).dst_group = XFRMNLGRP_POLICY;
 	return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_POLICY, GFP_ATOMIC);
 nlmsg_failure:
 rtattr_failure:
 	kfree_skb(skb);
 	return -1;
 }
 static int xfrm_notify_policy_flush(struct km_event *c)
 {
 	struct nlmsghdr *nlh;
 	struct sk_buff *skb;
 	unsigned char *b;
 	int len = 0;
 #ifdef CONFIG_XFRM_SUB_POLICY
 	struct xfrm_userpolicy_type upt;
 	len += RTA_SPACE(sizeof(struct xfrm_userpolicy_type));
 #endif
 	len += NLMSG_LENGTH(0);
 	skb = alloc_skb(len, GFP_ATOMIC);
 	if (skb == NULL)
 		return -ENOMEM;
 	b = skb->tail;
 	nlh = NLMSG_PUT(skb, c->pid, c->seq, XFRM_MSG_FLUSHPOLICY, 0);
 	nlh->nlmsg_flags = 0;
 #ifdef CONFIG_XFRM_SUB_POLICY
 	memset(&upt, 0, sizeof(upt));
 	upt.type = c->data.type;
 	RTA_PUT(skb, XFRMA_POLICY_TYPE, sizeof(upt), &upt);
 #endif
 	nlh->nlmsg_len = skb->tail - b;
 	NETLINK_CB(skb).dst_group = XFRMNLGRP_POLICY;
 	return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_POLICY, GFP_ATOMIC);
 nlmsg_failure:
 #ifdef CONFIG_XFRM_SUB_POLICY
 rtattr_failure:
 #endif
 	kfree_skb(skb);
 	return -1;
 }
 static int xfrm_send_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c)
 {
 	switch (c->event) {
 	case XFRM_MSG_NEWPOLICY:
 	case XFRM_MSG_UPDPOLICY:
 	case XFRM_MSG_DELPOLICY:
 		return xfrm_notify_policy(xp, dir, c);
 	case XFRM_MSG_FLUSHPOLICY:
 		return xfrm_notify_policy_flush(c);
 	case XFRM_MSG_POLEXPIRE:
 		return xfrm_exp_policy_notify(xp, dir, c);
 	default:
 		printk("xfrm_user: Unknown Policy event %d\n", c->event);
 	}
 	return 0;
 }
 static int build_report(struct sk_buff *skb, u8 proto,
 			struct xfrm_selector *sel, xfrm_address_t *addr)
 {
 	struct xfrm_user_report *ur;
 	struct nlmsghdr *nlh;
 	unsigned char *b = skb->tail;
 	nlh = NLMSG_PUT(skb, 0, 0, XFRM_MSG_REPORT, sizeof(*ur));
 	ur = NLMSG_DATA(nlh);
 	nlh->nlmsg_flags = 0;
 	ur->proto = proto;
 	memcpy(&ur->sel, sel, sizeof(ur->sel));
 	if (addr)
 		RTA_PUT(skb, XFRMA_COADDR, sizeof(*addr), addr);
 	nlh->nlmsg_len = skb->tail - b;
 	return skb->len;
 nlmsg_failure:
 rtattr_failure:
 	skb_trim(skb, b - skb->data);
 	return -1;
 }
 static int xfrm_send_report(u8 proto, struct xfrm_selector *sel,
 			    xfrm_address_t *addr)
 {
 	struct sk_buff *skb;
 	size_t len;
 	len = NLMSG_ALIGN(NLMSG_LENGTH(sizeof(struct xfrm_user_report)));
 	skb = alloc_skb(len, GFP_ATOMIC);
 	if (skb == NULL)
 		return -ENOMEM;
 	if (build_report(skb, proto, sel, addr) < 0)
 		BUG();
 	NETLINK_CB(skb).dst_group = XFRMNLGRP_REPORT;
 	return netlink_broadcast(xfrm_nl, skb, 0, XFRMNLGRP_REPORT, GFP_ATOMIC);
 }
 static struct xfrm_mgr netlink_mgr = {
 	.id		= "netlink",
 	.notify		= xfrm_send_state_notify,
 	.acquire	= xfrm_send_acquire,
 	.compile_policy	= xfrm_compile_policy,
 	.notify_policy	= xfrm_send_policy_notify,
 	.report		= xfrm_send_report,
 };
 static int __init xfrm_user_init(void)
 {
 	struct sock *nlsk;
 	printk(KERN_INFO "Initializing XFRM netlink socket\n");
 	nlsk = netlink_kernel_create(NETLINK_XFRM, XFRMNLGRP_MAX,
 	                             xfrm_netlink_rcv, THIS_MODULE);
 	if (nlsk == NULL)
 		return -ENOMEM;
 	rcu_assign_pointer(xfrm_nl, nlsk);
 	xfrm_register_km(&netlink_mgr);
 	return 0;
 }
 static void __exit xfrm_user_exit(void)
 {
 	struct sock *nlsk = xfrm_nl;
 	xfrm_unregister_km(&netlink_mgr);
 	rcu_assign_pointer(xfrm_nl, NULL);
 	synchronize_rcu();
 	sock_release(nlsk->sk_socket);
 }
 module_init(xfrm_user_init);
 module_exit(xfrm_user_exit);
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_XFRM);