1#ifndef _NET_XFRM_H
   2#define _NET_XFRM_H
   3
   4#include <linux/compiler.h>
   5#include <linux/xfrm.h>
   6#include <linux/spinlock.h>
   7#include <linux/list.h>
   8#include <linux/skbuff.h>
   9#include <linux/socket.h>
  10#include <linux/pfkeyv2.h>
  11#include <linux/ipsec.h>
  12#include <linux/in6.h>
  13#include <linux/mutex.h>
  14#include <linux/audit.h>
  15#include <linux/slab.h>
  16
  17#include <net/sock.h>
  18#include <net/dst.h>
  19#include <net/ip.h>
  20#include <net/route.h>
  21#include <net/ipv6.h>
  22#include <net/ip6_fib.h>
  23#include <net/flow.h>
  24
  25#include <linux/interrupt.h>
  26
  27#ifdef CONFIG_XFRM_STATISTICS
  28#include <net/snmp.h>
  29#endif
  30
  31#define XFRM_PROTO_ESP		50
  32#define XFRM_PROTO_AH		51
  33#define XFRM_PROTO_COMP		108
  34#define XFRM_PROTO_IPIP		4
  35#define XFRM_PROTO_IPV6		41
  36#define XFRM_PROTO_ROUTING	IPPROTO_ROUTING
  37#define XFRM_PROTO_DSTOPTS	IPPROTO_DSTOPTS
  38
  39#define XFRM_ALIGN4(len)	(((len) + 3) & ~3)
  40#define XFRM_ALIGN8(len)	(((len) + 7) & ~7)
  41#define MODULE_ALIAS_XFRM_MODE(family, encap) \
  42	MODULE_ALIAS("xfrm-mode-" __stringify(family) "-" __stringify(encap))
  43#define MODULE_ALIAS_XFRM_TYPE(family, proto) \
  44	MODULE_ALIAS("xfrm-type-" __stringify(family) "-" __stringify(proto))
  45
  46#ifdef CONFIG_XFRM_STATISTICS
  47#define XFRM_INC_STATS(net, field)	SNMP_INC_STATS((net)->mib.xfrm_statistics, field)
  48#define XFRM_INC_STATS_BH(net, field)	SNMP_INC_STATS_BH((net)->mib.xfrm_statistics, field)
  49#define XFRM_INC_STATS_USER(net, field)	SNMP_INC_STATS_USER((net)-mib.xfrm_statistics, field)
  50#else
  51#define XFRM_INC_STATS(net, field)	((void)(net))
  52#define XFRM_INC_STATS_BH(net, field)	((void)(net))
  53#define XFRM_INC_STATS_USER(net, field)	((void)(net))
  54#endif
  55
  56extern struct mutex xfrm_cfg_mutex;
  57
  58/* Organization of SPD aka "XFRM rules"
  59   ------------------------------------
  60
  61   Basic objects:
  62   - policy rule, struct xfrm_policy (=SPD entry)
  63   - bundle of transformations, struct dst_entry == struct xfrm_dst (=SA bundle)
  64   - instance of a transformer, struct xfrm_state (=SA)
  65   - template to clone xfrm_state, struct xfrm_tmpl
  66
  67   SPD is plain linear list of xfrm_policy rules, ordered by priority.
  68   (To be compatible with existing pfkeyv2 implementations,
  69   many rules with priority of 0x7fffffff are allowed to exist and
  70   such rules are ordered in an unpredictable way, thanks to bsd folks.)
  71
  72   Lookup is plain linear search until the first match with selector.
  73
  74   If "action" is "block", then we prohibit the flow, otherwise:
  75   if "xfrms_nr" is zero, the flow passes untransformed. Otherwise,
  76   policy entry has list of up to XFRM_MAX_DEPTH transformations,
  77   described by templates xfrm_tmpl. Each template is resolved
  78   to a complete xfrm_state (see below) and we pack bundle of transformations
  79   to a dst_entry returned to requestor.
  80
  81   dst -. xfrm  .-> xfrm_state #1
  82    |---. child .-> dst -. xfrm .-> xfrm_state #2
  83                     |---. child .-> dst -. xfrm .-> xfrm_state #3
  84                                      |---. child .-> NULL
  85
  86   Bundles are cached at xrfm_policy struct (field ->bundles).
  87
  88
  89   Resolution of xrfm_tmpl
  90   -----------------------
  91   Template contains:
  92   1. ->mode		Mode: transport or tunnel
  93   2. ->id.proto	Protocol: AH/ESP/IPCOMP
  94   3. ->id.daddr	Remote tunnel endpoint, ignored for transport mode.
  95      Q: allow to resolve security gateway?
  96   4. ->id.spi          If not zero, static SPI.
  97   5. ->saddr		Local tunnel endpoint, ignored for transport mode.
  98   6. ->algos		List of allowed algos. Plain bitmask now.
  99      Q: ealgos, aalgos, calgos. What a mess...
 100   7. ->share		Sharing mode.
 101      Q: how to implement private sharing mode? To add struct sock* to
 102      flow id?
 103
 104   Having this template we search through SAD searching for entries
 105   with appropriate mode/proto/algo, permitted by selector.
 106   If no appropriate entry found, it is requested from key manager.
 107
 108   PROBLEMS:
 109   Q: How to find all the bundles referring to a physical path for
 110      PMTU discovery? Seems, dst should contain list of all parents...
 111      and enter to infinite locking hierarchy disaster.
 112      No! It is easier, we will not search for them, let them find us.
 113      We add genid to each dst plus pointer to genid of raw IP route,
 114      pmtu disc will update pmtu on raw IP route and increase its genid.
 115      dst_check() will see this for top level and trigger resyncing
 116      metrics. Plus, it will be made via sk->sk_dst_cache. Solved.
 117 */
 118
 119struct xfrm_state_walk {
 120	struct list_head	all;
 121	u8			state;
 122	union {
 123		u8		dying;
 124		u8		proto;
 125	};
 126	u32			seq;
 127};
 128
 129/* Full description of state of transformer. */
 130struct xfrm_state {
 131#ifdef CONFIG_NET_NS
 132	struct net		*xs_net;
 133#endif
 134	union {
 135		struct hlist_node	gclist;
 136		struct hlist_node	bydst;
 137	};
 138	struct hlist_node	bysrc;
 139	struct hlist_node	byspi;
 140
 141	atomic_t		refcnt;
 142	spinlock_t		lock;
 143
 144	struct xfrm_id		id;
 145	struct xfrm_selector	sel;
 146	struct xfrm_mark	mark;
 147	u32			tfcpad;
 148
 149	u32			genid;
 150
 151	/* Key manager bits */
 152	struct xfrm_state_walk	km;
 153
 154	/* Parameters of this state. */
 155	struct {
 156		u32		reqid;
 157		u8		mode;
 158		u8		replay_window;
 159		u8		aalgo, ealgo, calgo;
 160		u8		flags;
 161		u16		family;
 162		xfrm_address_t	saddr;
 163		int		header_len;
 164		int		trailer_len;
 165	} props;
 166
 167	struct xfrm_lifetime_cfg lft;
 168
 169	/* Data for transformer */
 170	struct xfrm_algo_auth	*aalg;
 171	struct xfrm_algo	*ealg;
 172	struct xfrm_algo	*calg;
 173	struct xfrm_algo_aead	*aead;
 174
 175	/* Data for encapsulator */
 176	struct xfrm_encap_tmpl	*encap;
 177
 178	/* Data for care-of address */
 179	xfrm_address_t	*coaddr;
 180
 181	/* IPComp needs an IPIP tunnel for handling uncompressed packets */
 182	struct xfrm_state	*tunnel;
 183
 184	/* If a tunnel, number of users + 1 */
 185	atomic_t		tunnel_users;
 186
 187	/* State for replay detection */
 188	struct xfrm_replay_state replay;
 189	struct xfrm_replay_state_esn *replay_esn;
 190
 191	/* Replay detection state at the time we sent the last notification */
 192	struct xfrm_replay_state preplay;
 193	struct xfrm_replay_state_esn *preplay_esn;
 194
 195	/* The functions for replay detection. */
 196	struct xfrm_replay	*repl;
 197
 198	/* internal flag that only holds state for delayed aevent at the
 199	 * moment
 200	*/
 201	u32			xflags;
 202
 203	/* Replay detection notification settings */
 204	u32			replay_maxage;
 205	u32			replay_maxdiff;
 206
 207	/* Replay detection notification timer */
 208	struct timer_list	rtimer;
 209
 210	/* Statistics */
 211	struct xfrm_stats	stats;
 212
 213	struct xfrm_lifetime_cur curlft;
 214	struct tasklet_hrtimer	mtimer;
 215
 216	/* Last used time */
 217	unsigned long		lastused;
 218
 219	/* Reference to data common to all the instances of this
 220	 * transformer. */
 221	const struct xfrm_type	*type;
 222	struct xfrm_mode	*inner_mode;
 223	struct xfrm_mode	*inner_mode_iaf;
 224	struct xfrm_mode	*outer_mode;
 225
 226	/* Security context */
 227	struct xfrm_sec_ctx	*security;
 228
 229	/* Private data of this transformer, format is opaque,
 230	 * interpreted by xfrm_type methods. */
 231	void			*data;
 232};
 233
 234static inline struct net *xs_net(struct xfrm_state *x)
 235{
 236	return read_pnet(&x->xs_net);
 237}
 238
 239/* xflags - make enum if more show up */
 240#define XFRM_TIME_DEFER	1
 241
 242enum {
 243	XFRM_STATE_VOID,
 244	XFRM_STATE_ACQ,
 245	XFRM_STATE_VALID,
 246	XFRM_STATE_ERROR,
 247	XFRM_STATE_EXPIRED,
 248	XFRM_STATE_DEAD
 249};
 250
 251/* callback structure passed from either netlink or pfkey */
 252struct km_event {
 253	union {
 254		u32 hard;
 255		u32 proto;
 256		u32 byid;
 257		u32 aevent;
 258		u32 type;
 259	} data;
 260
 261	u32	seq;
 262	u32	pid;
 263	u32	event;
 264	struct net *net;
 265};
 266
 267struct xfrm_replay {
 268	void	(*advance)(struct xfrm_state *x, __be32 net_seq);
 269	int	(*check)(struct xfrm_state *x,
 270			 struct sk_buff *skb,
 271			 __be32 net_seq);
 272	void	(*notify)(struct xfrm_state *x, int event);
 273	int	(*overflow)(struct xfrm_state *x, struct sk_buff *skb);
 274};
 275
 276struct net_device;
 277struct xfrm_type;
 278struct xfrm_dst;
 279struct xfrm_policy_afinfo {
 280	unsigned short		family;
 281	struct dst_ops		*dst_ops;
 282	void			(*garbage_collect)(struct net *net);
 283	struct dst_entry	*(*dst_lookup)(struct net *net, int tos,
 284					       const xfrm_address_t *saddr,
 285					       const xfrm_address_t *daddr);
 286	int			(*get_saddr)(struct net *net, xfrm_address_t *saddr, xfrm_address_t *daddr);
 287	void			(*decode_session)(struct sk_buff *skb,
 288						  struct flowi *fl,
 289						  int reverse);
 290	int			(*get_tos)(const struct flowi *fl);
 291	int			(*init_path)(struct xfrm_dst *path,
 292					     struct dst_entry *dst,
 293					     int nfheader_len);
 294	int			(*fill_dst)(struct xfrm_dst *xdst,
 295					    struct net_device *dev,
 296					    const struct flowi *fl);
 297	struct dst_entry	*(*blackhole_route)(struct net *net, struct dst_entry *orig);
 298};
 299
 300extern int xfrm_policy_register_afinfo(struct xfrm_policy_afinfo *afinfo);
 301extern int xfrm_policy_unregister_afinfo(struct xfrm_policy_afinfo *afinfo);
 302extern void km_policy_notify(struct xfrm_policy *xp, int dir, const struct km_event *c);
 303extern void km_state_notify(struct xfrm_state *x, const struct km_event *c);
 304
 305struct xfrm_tmpl;
 306extern int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol);
 307extern void km_state_expired(struct xfrm_state *x, int hard, u32 pid);
 308extern int __xfrm_state_delete(struct xfrm_state *x);
 309
 310struct xfrm_state_afinfo {
 311	unsigned int		family;
 312	unsigned int		proto;
 313	__be16			eth_proto;
 314	struct module		*owner;
 315	const struct xfrm_type	*type_map[IPPROTO_MAX];
 316	struct xfrm_mode	*mode_map[XFRM_MODE_MAX];
 317	int			(*init_flags)(struct xfrm_state *x);
 318	void			(*init_tempsel)(struct xfrm_selector *sel,
 319						const struct flowi *fl);
 320	void			(*init_temprop)(struct xfrm_state *x,
 321						const struct xfrm_tmpl *tmpl,
 322						const xfrm_address_t *daddr,
 323						const xfrm_address_t *saddr);
 324	int			(*tmpl_sort)(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n);
 325	int			(*state_sort)(struct xfrm_state **dst, struct xfrm_state **src, int n);
 326	int			(*output)(struct sk_buff *skb);
 327	int			(*output_finish)(struct sk_buff *skb);
 328	int			(*extract_input)(struct xfrm_state *x,
 329						 struct sk_buff *skb);
 330	int			(*extract_output)(struct xfrm_state *x,
 331						  struct sk_buff *skb);
 332	int			(*transport_finish)(struct sk_buff *skb,
 333						    int async);
 334};
 335
 336extern int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo);
 337extern int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo);
 338
 339extern void xfrm_state_delete_tunnel(struct xfrm_state *x);
 340
 341struct xfrm_type {
 342	char			*description;
 343	struct module		*owner;
 344	u8			proto;
 345	u8			flags;
 346#define XFRM_TYPE_NON_FRAGMENT	1
 347#define XFRM_TYPE_REPLAY_PROT	2
 348#define XFRM_TYPE_LOCAL_COADDR	4
 349#define XFRM_TYPE_REMOTE_COADDR	8
 350
 351	int			(*init_state)(struct xfrm_state *x);
 352	void			(*destructor)(struct xfrm_state *);
 353	int			(*input)(struct xfrm_state *, struct sk_buff *skb);
 354	int			(*output)(struct xfrm_state *, struct sk_buff *pskb);
 355	int			(*reject)(struct xfrm_state *, struct sk_buff *,
 356					  const struct flowi *);
 357	int			(*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);
 358	/* Estimate maximal size of result of transformation of a dgram */
 359	u32			(*get_mtu)(struct xfrm_state *, int size);
 360};
 361
 362extern int xfrm_register_type(const struct xfrm_type *type, unsigned short family);
 363extern int xfrm_unregister_type(const struct xfrm_type *type, unsigned short family);
 364
 365struct xfrm_mode {
 366	/*
 367	 * Remove encapsulation header.
 368	 *
 369	 * The IP header will be moved over the top of the encapsulation
 370	 * header.
 371	 *
 372	 * On entry, the transport header shall point to where the IP header
 373	 * should be and the network header shall be set to where the IP
 374	 * header currently is.  skb->data shall point to the start of the
 375	 * payload.
 376	 */
 377	int (*input2)(struct xfrm_state *x, struct sk_buff *skb);
 378
 379	/*
 380	 * This is the actual input entry point.
 381	 *
 382	 * For transport mode and equivalent this would be identical to
 383	 * input2 (which does not need to be set).  While tunnel mode
 384	 * and equivalent would set this to the tunnel encapsulation function
 385	 * xfrm4_prepare_input that would in turn call input2.
 386	 */
 387	int (*input)(struct xfrm_state *x, struct sk_buff *skb);
 388
 389	/*
 390	 * Add encapsulation header.
 391	 *
 392	 * On exit, the transport header will be set to the start of the
 393	 * encapsulation header to be filled in by x->type->output and
 394	 * the mac header will be set to the nextheader (protocol for
 395	 * IPv4) field of the extension header directly preceding the
 396	 * encapsulation header, or in its absence, that of the top IP
 397	 * header.  The value of the network header will always point
 398	 * to the top IP header while skb->data will point to the payload.
 399	 */
 400	int (*output2)(struct xfrm_state *x,struct sk_buff *skb);
 401
 402	/*
 403	 * This is the actual output entry point.
 404	 *
 405	 * For transport mode and equivalent this would be identical to
 406	 * output2 (which does not need to be set).  While tunnel mode
 407	 * and equivalent would set this to a tunnel encapsulation function
 408	 * (xfrm4_prepare_output or xfrm6_prepare_output) that would in turn
 409	 * call output2.
 410	 */
 411	int (*output)(struct xfrm_state *x, struct sk_buff *skb);
 412
 413	struct xfrm_state_afinfo *afinfo;
 414	struct module *owner;
 415	unsigned int encap;
 416	int flags;
 417};
 418
 419/* Flags for xfrm_mode. */
 420enum {
 421	XFRM_MODE_FLAG_TUNNEL = 1,
 422};
 423
 424extern int xfrm_register_mode(struct xfrm_mode *mode, int family);
 425extern int xfrm_unregister_mode(struct xfrm_mode *mode, int family);
 426
 427static inline int xfrm_af2proto(unsigned int family)
 428{
 429	switch(family) {
 430	case AF_INET:
 431		return IPPROTO_IPIP;
 432	case AF_INET6:
 433		return IPPROTO_IPV6;
 434	default:
 435		return 0;
 436	}
 437}
 438
 439static inline struct xfrm_mode *xfrm_ip2inner_mode(struct xfrm_state *x, int ipproto)
 440{
 441	if ((ipproto == IPPROTO_IPIP && x->props.family == AF_INET) ||
 442	    (ipproto == IPPROTO_IPV6 && x->props.family == AF_INET6))
 443		return x->inner_mode;
 444	else
 445		return x->inner_mode_iaf;
 446}
 447
 448struct xfrm_tmpl {
 449/* id in template is interpreted as:
 450 * daddr - destination of tunnel, may be zero for transport mode.
 451 * spi   - zero to acquire spi. Not zero if spi is static, then
 452 *	   daddr must be fixed too.
 453 * proto - AH/ESP/IPCOMP
 454 */
 455	struct xfrm_id		id;
 456
 457/* Source address of tunnel. Ignored, if it is not a tunnel. */
 458	xfrm_address_t		saddr;
 459
 460	unsigned short		encap_family;
 461
 462	u32			reqid;
 463
 464/* Mode: transport, tunnel etc. */
 465	u8			mode;
 466
 467/* Sharing mode: unique, this session only, this user only etc. */
 468	u8			share;
 469
 470/* May skip this transfomration if no SA is found */
 471	u8			optional;
 472
 473/* Skip aalgos/ealgos/calgos checks. */
 474	u8			allalgs;
 475
 476/* Bit mask of algos allowed for acquisition */
 477	u32			aalgos;
 478	u32			ealgos;
 479	u32			calgos;
 480};
 481
 482#define XFRM_MAX_DEPTH		6
 483
 484struct xfrm_policy_walk_entry {
 485	struct list_head	all;
 486	u8			dead;
 487};
 488
 489struct xfrm_policy_walk {
 490	struct xfrm_policy_walk_entry walk;
 491	u8 type;
 492	u32 seq;
 493};
 494
 495struct xfrm_policy {
 496#ifdef CONFIG_NET_NS
 497	struct net		*xp_net;
 498#endif
 499	struct hlist_node	bydst;
 500	struct hlist_node	byidx;
 501
 502	/* This lock only affects elements except for entry. */
 503	rwlock_t		lock;
 504	atomic_t		refcnt;
 505	struct timer_list	timer;
 506
 507	struct flow_cache_object flo;
 508	atomic_t		genid;
 509	u32			priority;
 510	u32			index;
 511	struct xfrm_mark	mark;
 512	struct xfrm_selector	selector;
 513	struct xfrm_lifetime_cfg lft;
 514	struct xfrm_lifetime_cur curlft;
 515	struct xfrm_policy_walk_entry walk;
 516	u8			type;
 517	u8			action;
 518	u8			flags;
 519	u8			xfrm_nr;
 520	u16			family;
 521	struct xfrm_sec_ctx	*security;
 522	struct xfrm_tmpl       	xfrm_vec[XFRM_MAX_DEPTH];
 523};
 524
 525static inline struct net *xp_net(const struct xfrm_policy *xp)
 526{
 527	return read_pnet(&xp->xp_net);
 528}
 529
 530struct xfrm_kmaddress {
 531	xfrm_address_t          local;
 532	xfrm_address_t          remote;
 533	u32			reserved;
 534	u16			family;
 535};
 536
 537struct xfrm_migrate {
 538	xfrm_address_t		old_daddr;
 539	xfrm_address_t		old_saddr;
 540	xfrm_address_t		new_daddr;
 541	xfrm_address_t		new_saddr;
 542	u8			proto;
 543	u8			mode;
 544	u16			reserved;
 545	u32			reqid;
 546	u16			old_family;
 547	u16			new_family;
 548};
 549
 550#define XFRM_KM_TIMEOUT                30
 551/* which seqno */
 552#define XFRM_REPLAY_SEQ		1
 553#define XFRM_REPLAY_OSEQ	2
 554#define XFRM_REPLAY_SEQ_MASK	3
 555/* what happened */
 556#define XFRM_REPLAY_UPDATE	XFRM_AE_CR
 557#define XFRM_REPLAY_TIMEOUT	XFRM_AE_CE
 558
 559/* default aevent timeout in units of 100ms */
 560#define XFRM_AE_ETIME			10
 561/* Async Event timer multiplier */
 562#define XFRM_AE_ETH_M			10
 563/* default seq threshold size */
 564#define XFRM_AE_SEQT_SIZE		2
 565
 566struct xfrm_mgr {
 567	struct list_head	list;
 568	char			*id;
 569	int			(*notify)(struct xfrm_state *x, const struct km_event *c);
 570	int			(*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);
 571	struct xfrm_policy	*(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
 572	int			(*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
 573	int			(*notify_policy)(struct xfrm_policy *x, int dir, const struct km_event *c);
 574	int			(*report)(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
 575	int			(*migrate)(const struct xfrm_selector *sel,
 576					   u8 dir, u8 type,
 577					   const struct xfrm_migrate *m,
 578					   int num_bundles,
 579					   const struct xfrm_kmaddress *k);
 580};
 581
 582extern int xfrm_register_km(struct xfrm_mgr *km);
 583extern int xfrm_unregister_km(struct xfrm_mgr *km);
 584
 585/*
 586 * This structure is used for the duration where packets are being
 587 * transformed by IPsec.  As soon as the packet leaves IPsec the
 588 * area beyond the generic IP part may be overwritten.
 589 */
 590struct xfrm_skb_cb {
 591	union {
 592		struct inet_skb_parm h4;
 593		struct inet6_skb_parm h6;
 594        } header;
 595
 596        /* Sequence number for replay protection. */
 597	union {
 598		struct {
 599			__u32 low;
 600			__u32 hi;
 601		} output;
 602		struct {
 603			__be32 low;
 604			__be32 hi;
 605		} input;
 606	} seq;
 607};
 608
 609#define XFRM_SKB_CB(__skb) ((struct xfrm_skb_cb *)&((__skb)->cb[0]))
 610
 611/*
 612 * This structure is used by the afinfo prepare_input/prepare_output functions
 613 * to transmit header information to the mode input/output functions.
 614 */
 615struct xfrm_mode_skb_cb {
 616	union {
 617		struct inet_skb_parm h4;
 618		struct inet6_skb_parm h6;
 619	} header;
 620
 621	/* Copied from header for IPv4, always set to zero and DF for IPv6. */
 622	__be16 id;
 623	__be16 frag_off;
 624
 625	/* IP header length (excluding options or extension headers). */
 626	u8 ihl;
 627
 628	/* TOS for IPv4, class for IPv6. */
 629	u8 tos;
 630
 631	/* TTL for IPv4, hop limitfor IPv6. */
 632	u8 ttl;
 633
 634	/* Protocol for IPv4, NH for IPv6. */
 635	u8 protocol;
 636
 637	/* Option length for IPv4, zero for IPv6. */
 638	u8 optlen;
 639
 640	/* Used by IPv6 only, zero for IPv4. */
 641	u8 flow_lbl[3];
 642};
 643
 644#define XFRM_MODE_SKB_CB(__skb) ((struct xfrm_mode_skb_cb *)&((__skb)->cb[0]))
 645
 646/*
 647 * This structure is used by the input processing to locate the SPI and
 648 * related information.
 649 */
 650struct xfrm_spi_skb_cb {
 651	union {
 652		struct inet_skb_parm h4;
 653		struct inet6_skb_parm h6;
 654	} header;
 655
 656	unsigned int daddroff;
 657	unsigned int family;
 658};
 659
 660#define XFRM_SPI_SKB_CB(__skb) ((struct xfrm_spi_skb_cb *)&((__skb)->cb[0]))
 661
 662/* Audit Information */
 663struct xfrm_audit {
 664	u32	secid;
 665	uid_t	loginuid;
 666	u32	sessionid;
 667};
 668
 669#ifdef CONFIG_AUDITSYSCALL
 670static inline struct audit_buffer *xfrm_audit_start(const char *op)
 671{
 672	struct audit_buffer *audit_buf = NULL;
 673
 674	if (audit_enabled == 0)
 675		return NULL;
 676	audit_buf = audit_log_start(current->audit_context, GFP_ATOMIC,
 677				    AUDIT_MAC_IPSEC_EVENT);
 678	if (audit_buf == NULL)
 679		return NULL;
 680	audit_log_format(audit_buf, "op=%s", op);
 681	return audit_buf;
 682}
 683
 684static inline void xfrm_audit_helper_usrinfo(uid_t auid, u32 ses, u32 secid,
 685					     struct audit_buffer *audit_buf)
 686{
 687	char *secctx;
 688	u32 secctx_len;
 689
 690	audit_log_format(audit_buf, " auid=%u ses=%u", auid, ses);
 691	if (secid != 0 &&
 692	    security_secid_to_secctx(secid, &secctx, &secctx_len) == 0) {
 693		audit_log_format(audit_buf, " subj=%s", secctx);
 694		security_release_secctx(secctx, secctx_len);
 695	} else
 696		audit_log_task_context(audit_buf);
 697}
 698
 699extern void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
 700				  u32 auid, u32 ses, u32 secid);
 701extern void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
 702				  u32 auid, u32 ses, u32 secid);
 703extern void xfrm_audit_state_add(struct xfrm_state *x, int result,
 704				 u32 auid, u32 ses, u32 secid);
 705extern void xfrm_audit_state_delete(struct xfrm_state *x, int result,
 706				    u32 auid, u32 ses, u32 secid);
 707extern void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
 708					     struct sk_buff *skb);
 709extern void xfrm_audit_state_replay(struct xfrm_state *x,
 710				    struct sk_buff *skb, __be32 net_seq);
 711extern void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family);
 712extern void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
 713				      __be32 net_spi, __be32 net_seq);
 714extern void xfrm_audit_state_icvfail(struct xfrm_state *x,
 715				     struct sk_buff *skb, u8 proto);
 716#else
 717
 718static inline void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
 719				  u32 auid, u32 ses, u32 secid)
 720{
 721}
 722
 723static inline void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
 724				  u32 auid, u32 ses, u32 secid)
 725{
 726}
 727
 728static inline void xfrm_audit_state_add(struct xfrm_state *x, int result,
 729				 u32 auid, u32 ses, u32 secid)
 730{
 731}
 732
 733static inline void xfrm_audit_state_delete(struct xfrm_state *x, int result,
 734				    u32 auid, u32 ses, u32 secid)
 735{
 736}
 737
 738static inline void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
 739					     struct sk_buff *skb)
 740{
 741}
 742
 743static inline void xfrm_audit_state_replay(struct xfrm_state *x,
 744					   struct sk_buff *skb, __be32 net_seq)
 745{
 746}
 747
 748static inline void xfrm_audit_state_notfound_simple(struct sk_buff *skb,
 749				      u16 family)
 750{
 751}
 752
 753static inline void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
 754				      __be32 net_spi, __be32 net_seq)
 755{
 756}
 757
 758static inline void xfrm_audit_state_icvfail(struct xfrm_state *x,
 759				     struct sk_buff *skb, u8 proto)
 760{
 761}
 762#endif /* CONFIG_AUDITSYSCALL */
 763
 764static inline void xfrm_pol_hold(struct xfrm_policy *policy)
 765{
 766	if (likely(policy != NULL))
 767		atomic_inc(&policy->refcnt);
 768}
 769
 770extern void xfrm_policy_destroy(struct xfrm_policy *policy);
 771
 772static inline void xfrm_pol_put(struct xfrm_policy *policy)
 773{
 774	if (atomic_dec_and_test(&policy->refcnt))
 775		xfrm_policy_destroy(policy);
 776}
 777
 778static inline void xfrm_pols_put(struct xfrm_policy **pols, int npols)
 779{
 780	int i;
 781	for (i = npols - 1; i >= 0; --i)
 782		xfrm_pol_put(pols[i]);
 783}
 784
 785extern void __xfrm_state_destroy(struct xfrm_state *);
 786
 787static inline void __xfrm_state_put(struct xfrm_state *x)
 788{
 789	atomic_dec(&x->refcnt);
 790}
 791
 792static inline void xfrm_state_put(struct xfrm_state *x)
 793{
 794	if (atomic_dec_and_test(&x->refcnt))
 795		__xfrm_state_destroy(x);
 796}
 797
 798static inline void xfrm_state_hold(struct xfrm_state *x)
 799{
 800	atomic_inc(&x->refcnt);
 801}
 802
 803static inline bool addr_match(const void *token1, const void *token2,
 804			      int prefixlen)
 805{
 806	const __be32 *a1 = token1;
 807	const __be32 *a2 = token2;
 808	int pdw;
 809	int pbi;
 810
 811	pdw = prefixlen >> 5;	  /* num of whole u32 in prefix */
 812	pbi = prefixlen &  0x1f;  /* num of bits in incomplete u32 in prefix */
 813
 814	if (pdw)
 815		if (memcmp(a1, a2, pdw << 2))
 816			return false;
 817
 818	if (pbi) {
 819		__be32 mask;
 820
 821		mask = htonl((0xffffffff) << (32 - pbi));
 822
 823		if ((a1[pdw] ^ a2[pdw]) & mask)
 824			return false;
 825	}
 826
 827	return true;
 828}
 829
 
 
 
 
 
 
 
 
 830static __inline__
 831__be16 xfrm_flowi_sport(const struct flowi *fl, const union flowi_uli *uli)
 832{
 833	__be16 port;
 834	switch(fl->flowi_proto) {
 835	case IPPROTO_TCP:
 836	case IPPROTO_UDP:
 837	case IPPROTO_UDPLITE:
 838	case IPPROTO_SCTP:
 839		port = uli->ports.sport;
 840		break;
 841	case IPPROTO_ICMP:
 842	case IPPROTO_ICMPV6:
 843		port = htons(uli->icmpt.type);
 844		break;
 845	case IPPROTO_MH:
 846		port = htons(uli->mht.type);
 847		break;
 848	case IPPROTO_GRE:
 849		port = htons(ntohl(uli->gre_key) >> 16);
 850		break;
 851	default:
 852		port = 0;	/*XXX*/
 853	}
 854	return port;
 855}
 856
 857static __inline__
 858__be16 xfrm_flowi_dport(const struct flowi *fl, const union flowi_uli *uli)
 859{
 860	__be16 port;
 861	switch(fl->flowi_proto) {
 862	case IPPROTO_TCP:
 863	case IPPROTO_UDP:
 864	case IPPROTO_UDPLITE:
 865	case IPPROTO_SCTP:
 866		port = uli->ports.dport;
 867		break;
 868	case IPPROTO_ICMP:
 869	case IPPROTO_ICMPV6:
 870		port = htons(uli->icmpt.code);
 871		break;
 872	case IPPROTO_GRE:
 873		port = htons(ntohl(uli->gre_key) & 0xffff);
 874		break;
 875	default:
 876		port = 0;	/*XXX*/
 877	}
 878	return port;
 879}
 880
 881extern int xfrm_selector_match(const struct xfrm_selector *sel,
 882			       const struct flowi *fl,
 883			       unsigned short family);
 884
 885#ifdef CONFIG_SECURITY_NETWORK_XFRM
 886/*	If neither has a context --> match
 887 * 	Otherwise, both must have a context and the sids, doi, alg must match
 888 */
 889static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 890{
 891	return ((!s1 && !s2) ||
 892		(s1 && s2 &&
 893		 (s1->ctx_sid == s2->ctx_sid) &&
 894		 (s1->ctx_doi == s2->ctx_doi) &&
 895		 (s1->ctx_alg == s2->ctx_alg)));
 896}
 897#else
 898static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 899{
 900	return 1;
 901}
 902#endif
 903
 904/* A struct encoding bundle of transformations to apply to some set of flow.
 905 *
 906 * dst->child points to the next element of bundle.
 907 * dst->xfrm  points to an instanse of transformer.
 908 *
 909 * Due to unfortunate limitations of current routing cache, which we
 910 * have no time to fix, it mirrors struct rtable and bound to the same
 911 * routing key, including saddr,daddr. However, we can have many of
 912 * bundles differing by session id. All the bundles grow from a parent
 913 * policy rule.
 914 */
 915struct xfrm_dst {
 916	union {
 917		struct dst_entry	dst;
 918		struct rtable		rt;
 919		struct rt6_info		rt6;
 920	} u;
 921	struct dst_entry *route;
 922	struct flow_cache_object flo;
 923	struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX];
 924	int num_pols, num_xfrms;
 925#ifdef CONFIG_XFRM_SUB_POLICY
 926	struct flowi *origin;
 927	struct xfrm_selector *partner;
 928#endif
 929	u32 xfrm_genid;
 930	u32 policy_genid;
 931	u32 route_mtu_cached;
 932	u32 child_mtu_cached;
 933	u32 route_cookie;
 934	u32 path_cookie;
 935};
 936
 937#ifdef CONFIG_XFRM
 938static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
 939{
 940	xfrm_pols_put(xdst->pols, xdst->num_pols);
 941	dst_release(xdst->route);
 942	if (likely(xdst->u.dst.xfrm))
 943		xfrm_state_put(xdst->u.dst.xfrm);
 944#ifdef CONFIG_XFRM_SUB_POLICY
 945	kfree(xdst->origin);
 946	xdst->origin = NULL;
 947	kfree(xdst->partner);
 948	xdst->partner = NULL;
 949#endif
 950}
 951#endif
 952
 953extern void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
 954
 955struct sec_path {
 956	atomic_t		refcnt;
 957	int			len;
 958	struct xfrm_state	*xvec[XFRM_MAX_DEPTH];
 959};
 960
 961static inline int secpath_exists(struct sk_buff *skb)
 962{
 963#ifdef CONFIG_XFRM
 964	return skb->sp != NULL;
 965#else
 966	return 0;
 967#endif
 968}
 969
 970static inline struct sec_path *
 971secpath_get(struct sec_path *sp)
 972{
 973	if (sp)
 974		atomic_inc(&sp->refcnt);
 975	return sp;
 976}
 977
 978extern void __secpath_destroy(struct sec_path *sp);
 979
 980static inline void
 981secpath_put(struct sec_path *sp)
 982{
 983	if (sp && atomic_dec_and_test(&sp->refcnt))
 984		__secpath_destroy(sp);
 985}
 986
 987extern struct sec_path *secpath_dup(struct sec_path *src);
 988
 989static inline void
 990secpath_reset(struct sk_buff *skb)
 991{
 992#ifdef CONFIG_XFRM
 993	secpath_put(skb->sp);
 994	skb->sp = NULL;
 995#endif
 996}
 997
 998static inline int
 999xfrm_addr_any(const xfrm_address_t *addr, unsigned short family)
1000{
1001	switch (family) {
1002	case AF_INET:
1003		return addr->a4 == 0;
1004	case AF_INET6:
1005		return ipv6_addr_any((struct in6_addr *)&addr->a6);
1006	}
1007	return 0;
1008}
1009
1010static inline int
1011__xfrm4_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
1012{
1013	return	(tmpl->saddr.a4 &&
1014		 tmpl->saddr.a4 != x->props.saddr.a4);
1015}
1016
1017static inline int
1018__xfrm6_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
1019{
1020	return	(!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
1021		 ipv6_addr_cmp((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
1022}
1023
1024static inline int
1025xfrm_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x, unsigned short family)
1026{
1027	switch (family) {
1028	case AF_INET:
1029		return __xfrm4_state_addr_cmp(tmpl, x);
1030	case AF_INET6:
1031		return __xfrm6_state_addr_cmp(tmpl, x);
1032	}
1033	return !0;
1034}
1035
1036#ifdef CONFIG_XFRM
1037extern int __xfrm_policy_check(struct sock *, int dir, struct sk_buff *skb, unsigned short family);
1038
1039static inline int __xfrm_policy_check2(struct sock *sk, int dir,
1040				       struct sk_buff *skb,
1041				       unsigned int family, int reverse)
1042{
1043	struct net *net = dev_net(skb->dev);
1044	int ndir = dir | (reverse ? XFRM_POLICY_MASK + 1 : 0);
1045
1046	if (sk && sk->sk_policy[XFRM_POLICY_IN])
1047		return __xfrm_policy_check(sk, ndir, skb, family);
1048
1049	return	(!net->xfrm.policy_count[dir] && !skb->sp) ||
1050		(skb_dst(skb)->flags & DST_NOPOLICY) ||
1051		__xfrm_policy_check(sk, ndir, skb, family);
1052}
1053
1054static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
1055{
1056	return __xfrm_policy_check2(sk, dir, skb, family, 0);
1057}
1058
1059static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1060{
1061	return xfrm_policy_check(sk, dir, skb, AF_INET);
1062}
1063
1064static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1065{
1066	return xfrm_policy_check(sk, dir, skb, AF_INET6);
1067}
1068
1069static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
1070					     struct sk_buff *skb)
1071{
1072	return __xfrm_policy_check2(sk, dir, skb, AF_INET, 1);
1073}
1074
1075static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
1076					     struct sk_buff *skb)
1077{
1078	return __xfrm_policy_check2(sk, dir, skb, AF_INET6, 1);
1079}
1080
1081extern int __xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
1082				 unsigned int family, int reverse);
1083
1084static inline int xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
1085				      unsigned int family)
1086{
1087	return __xfrm_decode_session(skb, fl, family, 0);
1088}
1089
1090static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
1091					      struct flowi *fl,
1092					      unsigned int family)
1093{
1094	return __xfrm_decode_session(skb, fl, family, 1);
1095}
1096
1097extern int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
1098
1099static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
1100{
1101	struct net *net = dev_net(skb->dev);
1102
1103	return	!net->xfrm.policy_count[XFRM_POLICY_OUT] ||
1104		(skb_dst(skb)->flags & DST_NOXFRM) ||
1105		__xfrm_route_forward(skb, family);
1106}
1107
1108static inline int xfrm4_route_forward(struct sk_buff *skb)
1109{
1110	return xfrm_route_forward(skb, AF_INET);
1111}
1112
1113static inline int xfrm6_route_forward(struct sk_buff *skb)
1114{
1115	return xfrm_route_forward(skb, AF_INET6);
1116}
1117
1118extern int __xfrm_sk_clone_policy(struct sock *sk);
1119
1120static inline int xfrm_sk_clone_policy(struct sock *sk)
1121{
1122	if (unlikely(sk->sk_policy[0] || sk->sk_policy[1]))
1123		return __xfrm_sk_clone_policy(sk);
1124	return 0;
1125}
1126
1127extern int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
1128
1129static inline void xfrm_sk_free_policy(struct sock *sk)
1130{
1131	if (unlikely(sk->sk_policy[0] != NULL)) {
1132		xfrm_policy_delete(sk->sk_policy[0], XFRM_POLICY_MAX);
1133		sk->sk_policy[0] = NULL;
1134	}
1135	if (unlikely(sk->sk_policy[1] != NULL)) {
1136		xfrm_policy_delete(sk->sk_policy[1], XFRM_POLICY_MAX+1);
1137		sk->sk_policy[1] = NULL;
1138	}
1139}
1140
1141#else
1142
1143static inline void xfrm_sk_free_policy(struct sock *sk) {}
1144static inline int xfrm_sk_clone_policy(struct sock *sk) { return 0; }
1145static inline int xfrm6_route_forward(struct sk_buff *skb) { return 1; }  
1146static inline int xfrm4_route_forward(struct sk_buff *skb) { return 1; } 
1147static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1148{ 
1149	return 1; 
1150} 
1151static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1152{
1153	return 1;
1154}
1155static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
1156{
1157	return 1;
1158}
1159static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
1160					      struct flowi *fl,
1161					      unsigned int family)
1162{
1163	return -ENOSYS;
1164}
1165static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
1166					     struct sk_buff *skb)
1167{
1168	return 1;
1169}
1170static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
1171					     struct sk_buff *skb)
1172{
1173	return 1;
1174}
1175#endif
1176
1177static __inline__
1178xfrm_address_t *xfrm_flowi_daddr(const struct flowi *fl, unsigned short family)
1179{
1180	switch (family){
1181	case AF_INET:
1182		return (xfrm_address_t *)&fl->u.ip4.daddr;
1183	case AF_INET6:
1184		return (xfrm_address_t *)&fl->u.ip6.daddr;
1185	}
1186	return NULL;
1187}
1188
1189static __inline__
1190xfrm_address_t *xfrm_flowi_saddr(const struct flowi *fl, unsigned short family)
1191{
1192	switch (family){
1193	case AF_INET:
1194		return (xfrm_address_t *)&fl->u.ip4.saddr;
1195	case AF_INET6:
1196		return (xfrm_address_t *)&fl->u.ip6.saddr;
1197	}
1198	return NULL;
1199}
1200
1201static __inline__
1202void xfrm_flowi_addr_get(const struct flowi *fl,
1203			 xfrm_address_t *saddr, xfrm_address_t *daddr,
1204			 unsigned short family)
1205{
1206	switch(family) {
1207	case AF_INET:
1208		memcpy(&saddr->a4, &fl->u.ip4.saddr, sizeof(saddr->a4));
1209		memcpy(&daddr->a4, &fl->u.ip4.daddr, sizeof(daddr->a4));
1210		break;
1211	case AF_INET6:
1212		ipv6_addr_copy((struct in6_addr *)&saddr->a6, &fl->u.ip6.saddr);
1213		ipv6_addr_copy((struct in6_addr *)&daddr->a6, &fl->u.ip6.daddr);
1214		break;
1215	}
1216}
1217
1218static __inline__ int
1219__xfrm4_state_addr_check(const struct xfrm_state *x,
1220			 const xfrm_address_t *daddr, const xfrm_address_t *saddr)
1221{
1222	if (daddr->a4 == x->id.daddr.a4 &&
1223	    (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
1224		return 1;
1225	return 0;
1226}
1227
1228static __inline__ int
1229__xfrm6_state_addr_check(const struct xfrm_state *x,
1230			 const xfrm_address_t *daddr, const xfrm_address_t *saddr)
1231{
1232	if (!ipv6_addr_cmp((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
1233	    (!ipv6_addr_cmp((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr)|| 
1234	     ipv6_addr_any((struct in6_addr *)saddr) || 
1235	     ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
1236		return 1;
1237	return 0;
1238}
1239
1240static __inline__ int
1241xfrm_state_addr_check(const struct xfrm_state *x,
1242		      const xfrm_address_t *daddr, const xfrm_address_t *saddr,
1243		      unsigned short family)
1244{
1245	switch (family) {
1246	case AF_INET:
1247		return __xfrm4_state_addr_check(x, daddr, saddr);
1248	case AF_INET6:
1249		return __xfrm6_state_addr_check(x, daddr, saddr);
1250	}
1251	return 0;
1252}
1253
1254static __inline__ int
1255xfrm_state_addr_flow_check(const struct xfrm_state *x, const struct flowi *fl,
1256			   unsigned short family)
1257{
1258	switch (family) {
1259	case AF_INET:
1260		return __xfrm4_state_addr_check(x,
1261						(const xfrm_address_t *)&fl->u.ip4.daddr,
1262						(const xfrm_address_t *)&fl->u.ip4.saddr);
1263	case AF_INET6:
1264		return __xfrm6_state_addr_check(x,
1265						(const xfrm_address_t *)&fl->u.ip6.daddr,
1266						(const xfrm_address_t *)&fl->u.ip6.saddr);
1267	}
1268	return 0;
1269}
1270
1271static inline int xfrm_state_kern(const struct xfrm_state *x)
1272{
1273	return atomic_read(&x->tunnel_users);
1274}
1275
1276static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
1277{
1278	return (!userproto || proto == userproto ||
1279		(userproto == IPSEC_PROTO_ANY && (proto == IPPROTO_AH ||
1280						  proto == IPPROTO_ESP ||
1281						  proto == IPPROTO_COMP)));
1282}
1283
1284/*
1285 * xfrm algorithm information
1286 */
1287struct xfrm_algo_aead_info {
1288	u16 icv_truncbits;
1289};
1290
1291struct xfrm_algo_auth_info {
1292	u16 icv_truncbits;
1293	u16 icv_fullbits;
1294};
1295
1296struct xfrm_algo_encr_info {
1297	u16 blockbits;
1298	u16 defkeybits;
1299};
1300
1301struct xfrm_algo_comp_info {
1302	u16 threshold;
1303};
1304
1305struct xfrm_algo_desc {
1306	char *name;
1307	char *compat;
1308	u8 available:1;
1309	union {
1310		struct xfrm_algo_aead_info aead;
1311		struct xfrm_algo_auth_info auth;
1312		struct xfrm_algo_encr_info encr;
1313		struct xfrm_algo_comp_info comp;
1314	} uinfo;
1315	struct sadb_alg desc;
1316};
1317
1318/* XFRM tunnel handlers.  */
1319struct xfrm_tunnel {
1320	int (*handler)(struct sk_buff *skb);
1321	int (*err_handler)(struct sk_buff *skb, u32 info);
1322
1323	struct xfrm_tunnel __rcu *next;
1324	int priority;
1325};
1326
1327struct xfrm6_tunnel {
1328	int (*handler)(struct sk_buff *skb);
1329	int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
1330			   u8 type, u8 code, int offset, __be32 info);
1331	struct xfrm6_tunnel __rcu *next;
1332	int priority;
1333};
1334
1335extern void xfrm_init(void);
1336extern void xfrm4_init(int rt_hash_size);
1337extern int xfrm_state_init(struct net *net);
1338extern void xfrm_state_fini(struct net *net);
1339extern void xfrm4_state_init(void);
1340#ifdef CONFIG_XFRM
1341extern int xfrm6_init(void);
1342extern void xfrm6_fini(void);
1343extern int xfrm6_state_init(void);
1344extern void xfrm6_state_fini(void);
1345#else
1346static inline int xfrm6_init(void)
1347{
1348	return 0;
1349}
1350static inline void xfrm6_fini(void)
1351{
1352	;
1353}
1354#endif
1355
1356#ifdef CONFIG_XFRM_STATISTICS
1357extern int xfrm_proc_init(struct net *net);
1358extern void xfrm_proc_fini(struct net *net);
1359#endif
1360
1361extern int xfrm_sysctl_init(struct net *net);
1362#ifdef CONFIG_SYSCTL
1363extern void xfrm_sysctl_fini(struct net *net);
1364#else
1365static inline void xfrm_sysctl_fini(struct net *net)
1366{
1367}
1368#endif
1369
1370extern void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto);
1371extern int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
1372			   int (*func)(struct xfrm_state *, int, void*), void *);
1373extern void xfrm_state_walk_done(struct xfrm_state_walk *walk);
1374extern struct xfrm_state *xfrm_state_alloc(struct net *net);
1375extern struct xfrm_state *xfrm_state_find(const xfrm_address_t *daddr,
1376					  const xfrm_address_t *saddr,
1377					  const struct flowi *fl,
1378					  struct xfrm_tmpl *tmpl,
1379					  struct xfrm_policy *pol, int *err,
1380					  unsigned short family);
1381extern struct xfrm_state *xfrm_stateonly_find(struct net *net, u32 mark,
1382					       xfrm_address_t *daddr,
1383					       xfrm_address_t *saddr,
1384					       unsigned short family,
1385					       u8 mode, u8 proto, u32 reqid);
1386extern int xfrm_state_check_expire(struct xfrm_state *x);
1387extern void xfrm_state_insert(struct xfrm_state *x);
1388extern int xfrm_state_add(struct xfrm_state *x);
1389extern int xfrm_state_update(struct xfrm_state *x);
1390extern struct xfrm_state *xfrm_state_lookup(struct net *net, u32 mark,
1391					    const xfrm_address_t *daddr, __be32 spi,
1392					    u8 proto, unsigned short family);
1393extern struct xfrm_state *xfrm_state_lookup_byaddr(struct net *net, u32 mark,
1394						   const xfrm_address_t *daddr,
1395						   const xfrm_address_t *saddr,
1396						   u8 proto,
1397						   unsigned short family);
1398#ifdef CONFIG_XFRM_SUB_POLICY
1399extern int xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src,
1400			  int n, unsigned short family);
1401extern int xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src,
1402			   int n, unsigned short family);
1403#else
1404static inline int xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src,
1405				 int n, unsigned short family)
1406{
1407	return -ENOSYS;
1408}
1409
1410static inline int xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src,
1411				  int n, unsigned short family)
1412{
1413	return -ENOSYS;
1414}
1415#endif
1416
1417struct xfrmk_sadinfo {
1418	u32 sadhcnt; /* current hash bkts */
1419	u32 sadhmcnt; /* max allowed hash bkts */
1420	u32 sadcnt; /* current running count */
1421};
1422
1423struct xfrmk_spdinfo {
1424	u32 incnt;
1425	u32 outcnt;
1426	u32 fwdcnt;
1427	u32 inscnt;
1428	u32 outscnt;
1429	u32 fwdscnt;
1430	u32 spdhcnt;
1431	u32 spdhmcnt;
1432};
1433
1434extern struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 mark,
1435					      u32 seq);
1436extern int xfrm_state_delete(struct xfrm_state *x);
1437extern int xfrm_state_flush(struct net *net, u8 proto, struct xfrm_audit *audit_info);
1438extern void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si);
1439extern void xfrm_spd_getinfo(struct net *net, struct xfrmk_spdinfo *si);
1440extern u32 xfrm_replay_seqhi(struct xfrm_state *x, __be32 net_seq);
1441extern int xfrm_init_replay(struct xfrm_state *x);
1442extern int xfrm_state_mtu(struct xfrm_state *x, int mtu);
1443extern int __xfrm_init_state(struct xfrm_state *x, bool init_replay);
1444extern int xfrm_init_state(struct xfrm_state *x);
1445extern int xfrm_prepare_input(struct xfrm_state *x, struct sk_buff *skb);
1446extern int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi,
1447		      int encap_type);
1448extern int xfrm_input_resume(struct sk_buff *skb, int nexthdr);
1449extern int xfrm_output_resume(struct sk_buff *skb, int err);
1450extern int xfrm_output(struct sk_buff *skb);
1451extern int xfrm_inner_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1452extern int xfrm4_extract_header(struct sk_buff *skb);
1453extern int xfrm4_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1454extern int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
1455			   int encap_type);
1456extern int xfrm4_transport_finish(struct sk_buff *skb, int async);
1457extern int xfrm4_rcv(struct sk_buff *skb);
1458
1459static inline int xfrm4_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi)
1460{
1461	return xfrm4_rcv_encap(skb, nexthdr, spi, 0);
1462}
1463
1464extern int xfrm4_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1465extern int xfrm4_prepare_output(struct xfrm_state *x, struct sk_buff *skb);
1466extern int xfrm4_output(struct sk_buff *skb);
1467extern int xfrm4_output_finish(struct sk_buff *skb);
1468extern int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family);
1469extern int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family);
1470extern int xfrm6_extract_header(struct sk_buff *skb);
1471extern int xfrm6_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1472extern int xfrm6_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi);
1473extern int xfrm6_transport_finish(struct sk_buff *skb, int async);
1474extern int xfrm6_rcv(struct sk_buff *skb);
1475extern int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
1476			    xfrm_address_t *saddr, u8 proto);
1477extern int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family);
1478extern int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family);
1479extern __be32 xfrm6_tunnel_alloc_spi(struct net *net, xfrm_address_t *saddr);
1480extern __be32 xfrm6_tunnel_spi_lookup(struct net *net, const xfrm_address_t *saddr);
1481extern int xfrm6_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1482extern int xfrm6_prepare_output(struct xfrm_state *x, struct sk_buff *skb);
1483extern int xfrm6_output(struct sk_buff *skb);
1484extern int xfrm6_output_finish(struct sk_buff *skb);
1485extern int xfrm6_find_1stfragopt(struct xfrm_state *x, struct sk_buff *skb,
1486				 u8 **prevhdr);
1487
1488#ifdef CONFIG_XFRM
1489extern int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
1490extern int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen);
1491#else
1492static inline int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
1493{
1494 	return -ENOPROTOOPT;
1495} 
1496
1497static inline int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb)
1498{
1499 	/* should not happen */
1500 	kfree_skb(skb);
1501	return 0;
1502}
1503#endif
1504
1505struct xfrm_policy *xfrm_policy_alloc(struct net *net, gfp_t gfp);
1506
1507extern void xfrm_policy_walk_init(struct xfrm_policy_walk *walk, u8 type);
1508extern int xfrm_policy_walk(struct net *net, struct xfrm_policy_walk *walk,
1509	int (*func)(struct xfrm_policy *, int, int, void*), void *);
1510extern void xfrm_policy_walk_done(struct xfrm_policy_walk *walk);
1511int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
1512struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net, u32 mark,
1513					  u8 type, int dir,
1514					  struct xfrm_selector *sel,
1515					  struct xfrm_sec_ctx *ctx, int delete,
1516					  int *err);
1517struct xfrm_policy *xfrm_policy_byid(struct net *net, u32 mark, u8, int dir, u32 id, int delete, int *err);
1518int xfrm_policy_flush(struct net *net, u8 type, struct xfrm_audit *audit_info);
1519u32 xfrm_get_acqseq(void);
1520extern int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
1521struct xfrm_state *xfrm_find_acq(struct net *net, struct xfrm_mark *mark,
1522				 u8 mode, u32 reqid, u8 proto,
1523				 const xfrm_address_t *daddr,
1524				 const xfrm_address_t *saddr, int create,
1525				 unsigned short family);
1526extern int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
1527
1528#ifdef CONFIG_XFRM_MIGRATE
1529extern int km_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
1530		      const struct xfrm_migrate *m, int num_bundles,
1531		      const struct xfrm_kmaddress *k);
1532extern struct xfrm_state * xfrm_migrate_state_find(struct xfrm_migrate *m);
1533extern struct xfrm_state * xfrm_state_migrate(struct xfrm_state *x,
1534					      struct xfrm_migrate *m);
1535extern int xfrm_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
1536			struct xfrm_migrate *m, int num_bundles,
1537			struct xfrm_kmaddress *k);
1538#endif
1539
1540extern int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
1541extern void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 pid);
1542extern int km_report(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
1543
1544extern void xfrm_input_init(void);
1545extern int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
1546
1547extern void xfrm_probe_algs(void);
1548extern int xfrm_count_auth_supported(void);
1549extern int xfrm_count_enc_supported(void);
1550extern struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
1551extern struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
1552extern struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
1553extern struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
1554extern struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
1555extern struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe);
1556extern struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe);
1557extern struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe);
1558extern struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len,
1559						   int probe);
1560
1561struct hash_desc;
1562struct scatterlist;
1563typedef int (icv_update_fn_t)(struct hash_desc *, struct scatterlist *,
1564			      unsigned int);
1565
1566static inline int xfrm_addr_cmp(const xfrm_address_t *a,
1567				const xfrm_address_t *b,
1568				int family)
1569{
1570	switch (family) {
1571	default:
1572	case AF_INET:
1573		return (__force u32)a->a4 - (__force u32)b->a4;
1574	case AF_INET6:
1575		return ipv6_addr_cmp((const struct in6_addr *)a,
1576				     (const struct in6_addr *)b);
1577	}
1578}
1579
1580static inline int xfrm_policy_id2dir(u32 index)
1581{
1582	return index & 7;
1583}
1584
1585#ifdef CONFIG_XFRM
1586static inline int xfrm_aevent_is_on(struct net *net)
1587{
1588	struct sock *nlsk;
1589	int ret = 0;
1590
1591	rcu_read_lock();
1592	nlsk = rcu_dereference(net->xfrm.nlsk);
1593	if (nlsk)
1594		ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
1595	rcu_read_unlock();
1596	return ret;
1597}
1598#endif
1599
1600static inline int xfrm_alg_len(const struct xfrm_algo *alg)
1601{
1602	return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1603}
1604
1605static inline int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg)
1606{
1607	return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1608}
1609
1610static inline int xfrm_replay_state_esn_len(struct xfrm_replay_state_esn *replay_esn)
1611{
1612	return sizeof(*replay_esn) + replay_esn->bmp_len * sizeof(__u32);
1613}
1614
1615#ifdef CONFIG_XFRM_MIGRATE
1616static inline int xfrm_replay_clone(struct xfrm_state *x,
1617				     struct xfrm_state *orig)
1618{
1619	x->replay_esn = kzalloc(xfrm_replay_state_esn_len(orig->replay_esn),
1620				GFP_KERNEL);
1621	if (!x->replay_esn)
1622		return -ENOMEM;
1623
1624	x->replay_esn->bmp_len = orig->replay_esn->bmp_len;
1625	x->replay_esn->replay_window = orig->replay_esn->replay_window;
1626
1627	x->preplay_esn = kmemdup(x->replay_esn,
1628				 xfrm_replay_state_esn_len(x->replay_esn),
1629				 GFP_KERNEL);
1630	if (!x->preplay_esn) {
1631		kfree(x->replay_esn);
1632		return -ENOMEM;
1633	}
1634
1635	return 0;
1636}
1637
1638static inline struct xfrm_algo *xfrm_algo_clone(struct xfrm_algo *orig)
1639{
1640	return kmemdup(orig, xfrm_alg_len(orig), GFP_KERNEL);
1641}
1642
1643static inline struct xfrm_algo_auth *xfrm_algo_auth_clone(struct xfrm_algo_auth *orig)
1644{
1645	return kmemdup(orig, xfrm_alg_auth_len(orig), GFP_KERNEL);
1646}
1647
1648static inline void xfrm_states_put(struct xfrm_state **states, int n)
1649{
1650	int i;
1651	for (i = 0; i < n; i++)
1652		xfrm_state_put(*(states + i));
1653}
1654
1655static inline void xfrm_states_delete(struct xfrm_state **states, int n)
1656{
1657	int i;
1658	for (i = 0; i < n; i++)
1659		xfrm_state_delete(*(states + i));
1660}
1661#endif
1662
1663#ifdef CONFIG_XFRM
1664static inline struct xfrm_state *xfrm_input_state(struct sk_buff *skb)
1665{
1666	return skb->sp->xvec[skb->sp->len - 1];
1667}
1668#endif
1669
1670static inline int xfrm_mark_get(struct nlattr **attrs, struct xfrm_mark *m)
1671{
1672	if (attrs[XFRMA_MARK])
1673		memcpy(m, nla_data(attrs[XFRMA_MARK]), sizeof(struct xfrm_mark));
1674	else
1675		m->v = m->m = 0;
1676
1677	return m->v & m->m;
1678}
1679
1680static inline int xfrm_mark_put(struct sk_buff *skb, const struct xfrm_mark *m)
1681{
1682	if (m->m | m->v)
1683		NLA_PUT(skb, XFRMA_MARK, sizeof(struct xfrm_mark), m);
 
1684	return 0;
1685
1686nla_put_failure:
1687	return -1;
1688}
1689
1690#endif	/* _NET_XFRM_H */