cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

xfrm.h (56360B)


      1/* SPDX-License-Identifier: GPL-2.0 */
      2#ifndef _NET_XFRM_H
      3#define _NET_XFRM_H
      4
      5#include <linux/compiler.h>
      6#include <linux/xfrm.h>
      7#include <linux/spinlock.h>
      8#include <linux/list.h>
      9#include <linux/skbuff.h>
     10#include <linux/socket.h>
     11#include <linux/pfkeyv2.h>
     12#include <linux/ipsec.h>
     13#include <linux/in6.h>
     14#include <linux/mutex.h>
     15#include <linux/audit.h>
     16#include <linux/slab.h>
     17#include <linux/refcount.h>
     18#include <linux/sockptr.h>
     19
     20#include <net/sock.h>
     21#include <net/dst.h>
     22#include <net/ip.h>
     23#include <net/route.h>
     24#include <net/ipv6.h>
     25#include <net/ip6_fib.h>
     26#include <net/flow.h>
     27#include <net/gro_cells.h>
     28
     29#include <linux/interrupt.h>
     30
     31#ifdef CONFIG_XFRM_STATISTICS
     32#include <net/snmp.h>
     33#endif
     34
     35#define XFRM_PROTO_ESP		50
     36#define XFRM_PROTO_AH		51
     37#define XFRM_PROTO_COMP		108
     38#define XFRM_PROTO_IPIP		4
     39#define XFRM_PROTO_IPV6		41
     40#define XFRM_PROTO_ROUTING	IPPROTO_ROUTING
     41#define XFRM_PROTO_DSTOPTS	IPPROTO_DSTOPTS
     42
     43#define XFRM_ALIGN4(len)	(((len) + 3) & ~3)
     44#define XFRM_ALIGN8(len)	(((len) + 7) & ~7)
     45#define MODULE_ALIAS_XFRM_MODE(family, encap) \
     46	MODULE_ALIAS("xfrm-mode-" __stringify(family) "-" __stringify(encap))
     47#define MODULE_ALIAS_XFRM_TYPE(family, proto) \
     48	MODULE_ALIAS("xfrm-type-" __stringify(family) "-" __stringify(proto))
     49#define MODULE_ALIAS_XFRM_OFFLOAD_TYPE(family, proto) \
     50	MODULE_ALIAS("xfrm-offload-" __stringify(family) "-" __stringify(proto))
     51
     52#ifdef CONFIG_XFRM_STATISTICS
     53#define XFRM_INC_STATS(net, field)	SNMP_INC_STATS((net)->mib.xfrm_statistics, field)
     54#else
     55#define XFRM_INC_STATS(net, field)	((void)(net))
     56#endif
     57
     58
     59/* Organization of SPD aka "XFRM rules"
     60   ------------------------------------
     61
     62   Basic objects:
     63   - policy rule, struct xfrm_policy (=SPD entry)
     64   - bundle of transformations, struct dst_entry == struct xfrm_dst (=SA bundle)
     65   - instance of a transformer, struct xfrm_state (=SA)
     66   - template to clone xfrm_state, struct xfrm_tmpl
     67
     68   SPD is plain linear list of xfrm_policy rules, ordered by priority.
     69   (To be compatible with existing pfkeyv2 implementations,
     70   many rules with priority of 0x7fffffff are allowed to exist and
     71   such rules are ordered in an unpredictable way, thanks to bsd folks.)
     72
     73   Lookup is plain linear search until the first match with selector.
     74
     75   If "action" is "block", then we prohibit the flow, otherwise:
     76   if "xfrms_nr" is zero, the flow passes untransformed. Otherwise,
     77   policy entry has list of up to XFRM_MAX_DEPTH transformations,
     78   described by templates xfrm_tmpl. Each template is resolved
     79   to a complete xfrm_state (see below) and we pack bundle of transformations
     80   to a dst_entry returned to requestor.
     81
     82   dst -. xfrm  .-> xfrm_state #1
     83    |---. child .-> dst -. xfrm .-> xfrm_state #2
     84                     |---. child .-> dst -. xfrm .-> xfrm_state #3
     85                                      |---. child .-> NULL
     86
     87   Bundles are cached at xrfm_policy struct (field ->bundles).
     88
     89
     90   Resolution of xrfm_tmpl
     91   -----------------------
     92   Template contains:
     93   1. ->mode		Mode: transport or tunnel
     94   2. ->id.proto	Protocol: AH/ESP/IPCOMP
     95   3. ->id.daddr	Remote tunnel endpoint, ignored for transport mode.
     96      Q: allow to resolve security gateway?
     97   4. ->id.spi          If not zero, static SPI.
     98   5. ->saddr		Local tunnel endpoint, ignored for transport mode.
     99   6. ->algos		List of allowed algos. Plain bitmask now.
    100      Q: ealgos, aalgos, calgos. What a mess...
    101   7. ->share		Sharing mode.
    102      Q: how to implement private sharing mode? To add struct sock* to
    103      flow id?
    104
    105   Having this template we search through SAD searching for entries
    106   with appropriate mode/proto/algo, permitted by selector.
    107   If no appropriate entry found, it is requested from key manager.
    108
    109   PROBLEMS:
    110   Q: How to find all the bundles referring to a physical path for
    111      PMTU discovery? Seems, dst should contain list of all parents...
    112      and enter to infinite locking hierarchy disaster.
    113      No! It is easier, we will not search for them, let them find us.
    114      We add genid to each dst plus pointer to genid of raw IP route,
    115      pmtu disc will update pmtu on raw IP route and increase its genid.
    116      dst_check() will see this for top level and trigger resyncing
    117      metrics. Plus, it will be made via sk->sk_dst_cache. Solved.
    118 */
    119
    120struct xfrm_state_walk {
    121	struct list_head	all;
    122	u8			state;
    123	u8			dying;
    124	u8			proto;
    125	u32			seq;
    126	struct xfrm_address_filter *filter;
    127};
    128
    129enum {
    130	XFRM_DEV_OFFLOAD_IN = 1,
    131	XFRM_DEV_OFFLOAD_OUT,
    132};
    133
    134struct xfrm_dev_offload {
    135	struct net_device	*dev;
    136	netdevice_tracker	dev_tracker;
    137	struct net_device	*real_dev;
    138	unsigned long		offload_handle;
    139	u8			dir : 2;
    140};
    141
    142struct xfrm_mode {
    143	u8 encap;
    144	u8 family;
    145	u8 flags;
    146};
    147
    148/* Flags for xfrm_mode. */
    149enum {
    150	XFRM_MODE_FLAG_TUNNEL = 1,
    151};
    152
    153enum xfrm_replay_mode {
    154	XFRM_REPLAY_MODE_LEGACY,
    155	XFRM_REPLAY_MODE_BMP,
    156	XFRM_REPLAY_MODE_ESN,
    157};
    158
    159/* Full description of state of transformer. */
    160struct xfrm_state {
    161	possible_net_t		xs_net;
    162	union {
    163		struct hlist_node	gclist;
    164		struct hlist_node	bydst;
    165	};
    166	struct hlist_node	bysrc;
    167	struct hlist_node	byspi;
    168	struct hlist_node	byseq;
    169
    170	refcount_t		refcnt;
    171	spinlock_t		lock;
    172
    173	struct xfrm_id		id;
    174	struct xfrm_selector	sel;
    175	struct xfrm_mark	mark;
    176	u32			if_id;
    177	u32			tfcpad;
    178
    179	u32			genid;
    180
    181	/* Key manager bits */
    182	struct xfrm_state_walk	km;
    183
    184	/* Parameters of this state. */
    185	struct {
    186		u32		reqid;
    187		u8		mode;
    188		u8		replay_window;
    189		u8		aalgo, ealgo, calgo;
    190		u8		flags;
    191		u16		family;
    192		xfrm_address_t	saddr;
    193		int		header_len;
    194		int		trailer_len;
    195		u32		extra_flags;
    196		struct xfrm_mark	smark;
    197	} props;
    198
    199	struct xfrm_lifetime_cfg lft;
    200
    201	/* Data for transformer */
    202	struct xfrm_algo_auth	*aalg;
    203	struct xfrm_algo	*ealg;
    204	struct xfrm_algo	*calg;
    205	struct xfrm_algo_aead	*aead;
    206	const char		*geniv;
    207
    208	/* mapping change rate limiting */
    209	__be16 new_mapping_sport;
    210	u32 new_mapping;	/* seconds */
    211	u32 mapping_maxage;	/* seconds for input SA */
    212
    213	/* Data for encapsulator */
    214	struct xfrm_encap_tmpl	*encap;
    215	struct sock __rcu	*encap_sk;
    216
    217	/* Data for care-of address */
    218	xfrm_address_t	*coaddr;
    219
    220	/* IPComp needs an IPIP tunnel for handling uncompressed packets */
    221	struct xfrm_state	*tunnel;
    222
    223	/* If a tunnel, number of users + 1 */
    224	atomic_t		tunnel_users;
    225
    226	/* State for replay detection */
    227	struct xfrm_replay_state replay;
    228	struct xfrm_replay_state_esn *replay_esn;
    229
    230	/* Replay detection state at the time we sent the last notification */
    231	struct xfrm_replay_state preplay;
    232	struct xfrm_replay_state_esn *preplay_esn;
    233
    234	/* replay detection mode */
    235	enum xfrm_replay_mode    repl_mode;
    236	/* internal flag that only holds state for delayed aevent at the
    237	 * moment
    238	*/
    239	u32			xflags;
    240
    241	/* Replay detection notification settings */
    242	u32			replay_maxage;
    243	u32			replay_maxdiff;
    244
    245	/* Replay detection notification timer */
    246	struct timer_list	rtimer;
    247
    248	/* Statistics */
    249	struct xfrm_stats	stats;
    250
    251	struct xfrm_lifetime_cur curlft;
    252	struct hrtimer		mtimer;
    253
    254	struct xfrm_dev_offload xso;
    255
    256	/* used to fix curlft->add_time when changing date */
    257	long		saved_tmo;
    258
    259	/* Last used time */
    260	time64_t		lastused;
    261
    262	struct page_frag xfrag;
    263
    264	/* Reference to data common to all the instances of this
    265	 * transformer. */
    266	const struct xfrm_type	*type;
    267	struct xfrm_mode	inner_mode;
    268	struct xfrm_mode	inner_mode_iaf;
    269	struct xfrm_mode	outer_mode;
    270
    271	const struct xfrm_type_offload	*type_offload;
    272
    273	/* Security context */
    274	struct xfrm_sec_ctx	*security;
    275
    276	/* Private data of this transformer, format is opaque,
    277	 * interpreted by xfrm_type methods. */
    278	void			*data;
    279};
    280
    281static inline struct net *xs_net(struct xfrm_state *x)
    282{
    283	return read_pnet(&x->xs_net);
    284}
    285
    286/* xflags - make enum if more show up */
    287#define XFRM_TIME_DEFER	1
    288#define XFRM_SOFT_EXPIRE 2
    289
    290enum {
    291	XFRM_STATE_VOID,
    292	XFRM_STATE_ACQ,
    293	XFRM_STATE_VALID,
    294	XFRM_STATE_ERROR,
    295	XFRM_STATE_EXPIRED,
    296	XFRM_STATE_DEAD
    297};
    298
    299/* callback structure passed from either netlink or pfkey */
    300struct km_event {
    301	union {
    302		u32 hard;
    303		u32 proto;
    304		u32 byid;
    305		u32 aevent;
    306		u32 type;
    307	} data;
    308
    309	u32	seq;
    310	u32	portid;
    311	u32	event;
    312	struct net *net;
    313};
    314
    315struct xfrm_if_cb {
    316	struct xfrm_if	*(*decode_session)(struct sk_buff *skb,
    317					   unsigned short family);
    318};
    319
    320void xfrm_if_register_cb(const struct xfrm_if_cb *ifcb);
    321void xfrm_if_unregister_cb(void);
    322
    323struct net_device;
    324struct xfrm_type;
    325struct xfrm_dst;
    326struct xfrm_policy_afinfo {
    327	struct dst_ops		*dst_ops;
    328	struct dst_entry	*(*dst_lookup)(struct net *net,
    329					       int tos, int oif,
    330					       const xfrm_address_t *saddr,
    331					       const xfrm_address_t *daddr,
    332					       u32 mark);
    333	int			(*get_saddr)(struct net *net, int oif,
    334					     xfrm_address_t *saddr,
    335					     xfrm_address_t *daddr,
    336					     u32 mark);
    337	int			(*fill_dst)(struct xfrm_dst *xdst,
    338					    struct net_device *dev,
    339					    const struct flowi *fl);
    340	struct dst_entry	*(*blackhole_route)(struct net *net, struct dst_entry *orig);
    341};
    342
    343int xfrm_policy_register_afinfo(const struct xfrm_policy_afinfo *afinfo, int family);
    344void xfrm_policy_unregister_afinfo(const struct xfrm_policy_afinfo *afinfo);
    345void km_policy_notify(struct xfrm_policy *xp, int dir,
    346		      const struct km_event *c);
    347void km_state_notify(struct xfrm_state *x, const struct km_event *c);
    348
    349struct xfrm_tmpl;
    350int km_query(struct xfrm_state *x, struct xfrm_tmpl *t,
    351	     struct xfrm_policy *pol);
    352void km_state_expired(struct xfrm_state *x, int hard, u32 portid);
    353int __xfrm_state_delete(struct xfrm_state *x);
    354
    355struct xfrm_state_afinfo {
    356	u8				family;
    357	u8				proto;
    358
    359	const struct xfrm_type_offload *type_offload_esp;
    360
    361	const struct xfrm_type		*type_esp;
    362	const struct xfrm_type		*type_ipip;
    363	const struct xfrm_type		*type_ipip6;
    364	const struct xfrm_type		*type_comp;
    365	const struct xfrm_type		*type_ah;
    366	const struct xfrm_type		*type_routing;
    367	const struct xfrm_type		*type_dstopts;
    368
    369	int			(*output)(struct net *net, struct sock *sk, struct sk_buff *skb);
    370	int			(*transport_finish)(struct sk_buff *skb,
    371						    int async);
    372	void			(*local_error)(struct sk_buff *skb, u32 mtu);
    373};
    374
    375int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo);
    376int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo);
    377struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned int family);
    378struct xfrm_state_afinfo *xfrm_state_afinfo_get_rcu(unsigned int family);
    379
    380struct xfrm_input_afinfo {
    381	u8			family;
    382	bool			is_ipip;
    383	int			(*callback)(struct sk_buff *skb, u8 protocol,
    384					    int err);
    385};
    386
    387int xfrm_input_register_afinfo(const struct xfrm_input_afinfo *afinfo);
    388int xfrm_input_unregister_afinfo(const struct xfrm_input_afinfo *afinfo);
    389
    390void xfrm_flush_gc(void);
    391void xfrm_state_delete_tunnel(struct xfrm_state *x);
    392
    393struct xfrm_type {
    394	struct module		*owner;
    395	u8			proto;
    396	u8			flags;
    397#define XFRM_TYPE_NON_FRAGMENT	1
    398#define XFRM_TYPE_REPLAY_PROT	2
    399#define XFRM_TYPE_LOCAL_COADDR	4
    400#define XFRM_TYPE_REMOTE_COADDR	8
    401
    402	int			(*init_state)(struct xfrm_state *x);
    403	void			(*destructor)(struct xfrm_state *);
    404	int			(*input)(struct xfrm_state *, struct sk_buff *skb);
    405	int			(*output)(struct xfrm_state *, struct sk_buff *pskb);
    406	int			(*reject)(struct xfrm_state *, struct sk_buff *,
    407					  const struct flowi *);
    408};
    409
    410int xfrm_register_type(const struct xfrm_type *type, unsigned short family);
    411void xfrm_unregister_type(const struct xfrm_type *type, unsigned short family);
    412
    413struct xfrm_type_offload {
    414	struct module	*owner;
    415	u8		proto;
    416	void		(*encap)(struct xfrm_state *, struct sk_buff *pskb);
    417	int		(*input_tail)(struct xfrm_state *x, struct sk_buff *skb);
    418	int		(*xmit)(struct xfrm_state *, struct sk_buff *pskb, netdev_features_t features);
    419};
    420
    421int xfrm_register_type_offload(const struct xfrm_type_offload *type, unsigned short family);
    422void xfrm_unregister_type_offload(const struct xfrm_type_offload *type, unsigned short family);
    423
    424static inline int xfrm_af2proto(unsigned int family)
    425{
    426	switch(family) {
    427	case AF_INET:
    428		return IPPROTO_IPIP;
    429	case AF_INET6:
    430		return IPPROTO_IPV6;
    431	default:
    432		return 0;
    433	}
    434}
    435
    436static inline const struct xfrm_mode *xfrm_ip2inner_mode(struct xfrm_state *x, int ipproto)
    437{
    438	if ((ipproto == IPPROTO_IPIP && x->props.family == AF_INET) ||
    439	    (ipproto == IPPROTO_IPV6 && x->props.family == AF_INET6))
    440		return &x->inner_mode;
    441	else
    442		return &x->inner_mode_iaf;
    443}
    444
    445struct xfrm_tmpl {
    446/* id in template is interpreted as:
    447 * daddr - destination of tunnel, may be zero for transport mode.
    448 * spi   - zero to acquire spi. Not zero if spi is static, then
    449 *	   daddr must be fixed too.
    450 * proto - AH/ESP/IPCOMP
    451 */
    452	struct xfrm_id		id;
    453
    454/* Source address of tunnel. Ignored, if it is not a tunnel. */
    455	xfrm_address_t		saddr;
    456
    457	unsigned short		encap_family;
    458
    459	u32			reqid;
    460
    461/* Mode: transport, tunnel etc. */
    462	u8			mode;
    463
    464/* Sharing mode: unique, this session only, this user only etc. */
    465	u8			share;
    466
    467/* May skip this transfomration if no SA is found */
    468	u8			optional;
    469
    470/* Skip aalgos/ealgos/calgos checks. */
    471	u8			allalgs;
    472
    473/* Bit mask of algos allowed for acquisition */
    474	u32			aalgos;
    475	u32			ealgos;
    476	u32			calgos;
    477};
    478
    479#define XFRM_MAX_DEPTH		6
    480#define XFRM_MAX_OFFLOAD_DEPTH	1
    481
    482struct xfrm_policy_walk_entry {
    483	struct list_head	all;
    484	u8			dead;
    485};
    486
    487struct xfrm_policy_walk {
    488	struct xfrm_policy_walk_entry walk;
    489	u8 type;
    490	u32 seq;
    491};
    492
    493struct xfrm_policy_queue {
    494	struct sk_buff_head	hold_queue;
    495	struct timer_list	hold_timer;
    496	unsigned long		timeout;
    497};
    498
    499struct xfrm_policy {
    500	possible_net_t		xp_net;
    501	struct hlist_node	bydst;
    502	struct hlist_node	byidx;
    503
    504	/* This lock only affects elements except for entry. */
    505	rwlock_t		lock;
    506	refcount_t		refcnt;
    507	u32			pos;
    508	struct timer_list	timer;
    509
    510	atomic_t		genid;
    511	u32			priority;
    512	u32			index;
    513	u32			if_id;
    514	struct xfrm_mark	mark;
    515	struct xfrm_selector	selector;
    516	struct xfrm_lifetime_cfg lft;
    517	struct xfrm_lifetime_cur curlft;
    518	struct xfrm_policy_walk_entry walk;
    519	struct xfrm_policy_queue polq;
    520	bool                    bydst_reinsert;
    521	u8			type;
    522	u8			action;
    523	u8			flags;
    524	u8			xfrm_nr;
    525	u16			family;
    526	struct xfrm_sec_ctx	*security;
    527	struct xfrm_tmpl       	xfrm_vec[XFRM_MAX_DEPTH];
    528	struct hlist_node	bydst_inexact_list;
    529	struct rcu_head		rcu;
    530};
    531
    532static inline struct net *xp_net(const struct xfrm_policy *xp)
    533{
    534	return read_pnet(&xp->xp_net);
    535}
    536
    537struct xfrm_kmaddress {
    538	xfrm_address_t          local;
    539	xfrm_address_t          remote;
    540	u32			reserved;
    541	u16			family;
    542};
    543
    544struct xfrm_migrate {
    545	xfrm_address_t		old_daddr;
    546	xfrm_address_t		old_saddr;
    547	xfrm_address_t		new_daddr;
    548	xfrm_address_t		new_saddr;
    549	u8			proto;
    550	u8			mode;
    551	u16			reserved;
    552	u32			reqid;
    553	u16			old_family;
    554	u16			new_family;
    555};
    556
    557#define XFRM_KM_TIMEOUT                30
    558/* what happened */
    559#define XFRM_REPLAY_UPDATE	XFRM_AE_CR
    560#define XFRM_REPLAY_TIMEOUT	XFRM_AE_CE
    561
    562/* default aevent timeout in units of 100ms */
    563#define XFRM_AE_ETIME			10
    564/* Async Event timer multiplier */
    565#define XFRM_AE_ETH_M			10
    566/* default seq threshold size */
    567#define XFRM_AE_SEQT_SIZE		2
    568
    569struct xfrm_mgr {
    570	struct list_head	list;
    571	int			(*notify)(struct xfrm_state *x, const struct km_event *c);
    572	int			(*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp);
    573	struct xfrm_policy	*(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
    574	int			(*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
    575	int			(*notify_policy)(struct xfrm_policy *x, int dir, const struct km_event *c);
    576	int			(*report)(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
    577	int			(*migrate)(const struct xfrm_selector *sel,
    578					   u8 dir, u8 type,
    579					   const struct xfrm_migrate *m,
    580					   int num_bundles,
    581					   const struct xfrm_kmaddress *k,
    582					   const struct xfrm_encap_tmpl *encap);
    583	bool			(*is_alive)(const struct km_event *c);
    584};
    585
    586int xfrm_register_km(struct xfrm_mgr *km);
    587int xfrm_unregister_km(struct xfrm_mgr *km);
    588
    589struct xfrm_tunnel_skb_cb {
    590	union {
    591		struct inet_skb_parm h4;
    592		struct inet6_skb_parm h6;
    593	} header;
    594
    595	union {
    596		struct ip_tunnel *ip4;
    597		struct ip6_tnl *ip6;
    598	} tunnel;
    599};
    600
    601#define XFRM_TUNNEL_SKB_CB(__skb) ((struct xfrm_tunnel_skb_cb *)&((__skb)->cb[0]))
    602
    603/*
    604 * This structure is used for the duration where packets are being
    605 * transformed by IPsec.  As soon as the packet leaves IPsec the
    606 * area beyond the generic IP part may be overwritten.
    607 */
    608struct xfrm_skb_cb {
    609	struct xfrm_tunnel_skb_cb header;
    610
    611        /* Sequence number for replay protection. */
    612	union {
    613		struct {
    614			__u32 low;
    615			__u32 hi;
    616		} output;
    617		struct {
    618			__be32 low;
    619			__be32 hi;
    620		} input;
    621	} seq;
    622};
    623
    624#define XFRM_SKB_CB(__skb) ((struct xfrm_skb_cb *)&((__skb)->cb[0]))
    625
    626/*
    627 * This structure is used by the afinfo prepare_input/prepare_output functions
    628 * to transmit header information to the mode input/output functions.
    629 */
    630struct xfrm_mode_skb_cb {
    631	struct xfrm_tunnel_skb_cb header;
    632
    633	/* Copied from header for IPv4, always set to zero and DF for IPv6. */
    634	__be16 id;
    635	__be16 frag_off;
    636
    637	/* IP header length (excluding options or extension headers). */
    638	u8 ihl;
    639
    640	/* TOS for IPv4, class for IPv6. */
    641	u8 tos;
    642
    643	/* TTL for IPv4, hop limitfor IPv6. */
    644	u8 ttl;
    645
    646	/* Protocol for IPv4, NH for IPv6. */
    647	u8 protocol;
    648
    649	/* Option length for IPv4, zero for IPv6. */
    650	u8 optlen;
    651
    652	/* Used by IPv6 only, zero for IPv4. */
    653	u8 flow_lbl[3];
    654};
    655
    656#define XFRM_MODE_SKB_CB(__skb) ((struct xfrm_mode_skb_cb *)&((__skb)->cb[0]))
    657
    658/*
    659 * This structure is used by the input processing to locate the SPI and
    660 * related information.
    661 */
    662struct xfrm_spi_skb_cb {
    663	struct xfrm_tunnel_skb_cb header;
    664
    665	unsigned int daddroff;
    666	unsigned int family;
    667	__be32 seq;
    668};
    669
    670#define XFRM_SPI_SKB_CB(__skb) ((struct xfrm_spi_skb_cb *)&((__skb)->cb[0]))
    671
    672#ifdef CONFIG_AUDITSYSCALL
    673static inline struct audit_buffer *xfrm_audit_start(const char *op)
    674{
    675	struct audit_buffer *audit_buf = NULL;
    676
    677	if (audit_enabled == AUDIT_OFF)
    678		return NULL;
    679	audit_buf = audit_log_start(audit_context(), GFP_ATOMIC,
    680				    AUDIT_MAC_IPSEC_EVENT);
    681	if (audit_buf == NULL)
    682		return NULL;
    683	audit_log_format(audit_buf, "op=%s", op);
    684	return audit_buf;
    685}
    686
    687static inline void xfrm_audit_helper_usrinfo(bool task_valid,
    688					     struct audit_buffer *audit_buf)
    689{
    690	const unsigned int auid = from_kuid(&init_user_ns, task_valid ?
    691					    audit_get_loginuid(current) :
    692					    INVALID_UID);
    693	const unsigned int ses = task_valid ? audit_get_sessionid(current) :
    694		AUDIT_SID_UNSET;
    695
    696	audit_log_format(audit_buf, " auid=%u ses=%u", auid, ses);
    697	audit_log_task_context(audit_buf);
    698}
    699
    700void xfrm_audit_policy_add(struct xfrm_policy *xp, int result, bool task_valid);
    701void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
    702			      bool task_valid);
    703void xfrm_audit_state_add(struct xfrm_state *x, int result, bool task_valid);
    704void xfrm_audit_state_delete(struct xfrm_state *x, int result, bool task_valid);
    705void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
    706				      struct sk_buff *skb);
    707void xfrm_audit_state_replay(struct xfrm_state *x, struct sk_buff *skb,
    708			     __be32 net_seq);
    709void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family);
    710void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family, __be32 net_spi,
    711			       __be32 net_seq);
    712void xfrm_audit_state_icvfail(struct xfrm_state *x, struct sk_buff *skb,
    713			      u8 proto);
    714#else
    715
    716static inline void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
    717					 bool task_valid)
    718{
    719}
    720
    721static inline void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
    722					    bool task_valid)
    723{
    724}
    725
    726static inline void xfrm_audit_state_add(struct xfrm_state *x, int result,
    727					bool task_valid)
    728{
    729}
    730
    731static inline void xfrm_audit_state_delete(struct xfrm_state *x, int result,
    732					   bool task_valid)
    733{
    734}
    735
    736static inline void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
    737					     struct sk_buff *skb)
    738{
    739}
    740
    741static inline void xfrm_audit_state_replay(struct xfrm_state *x,
    742					   struct sk_buff *skb, __be32 net_seq)
    743{
    744}
    745
    746static inline void xfrm_audit_state_notfound_simple(struct sk_buff *skb,
    747				      u16 family)
    748{
    749}
    750
    751static inline void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
    752				      __be32 net_spi, __be32 net_seq)
    753{
    754}
    755
    756static inline void xfrm_audit_state_icvfail(struct xfrm_state *x,
    757				     struct sk_buff *skb, u8 proto)
    758{
    759}
    760#endif /* CONFIG_AUDITSYSCALL */
    761
    762static inline void xfrm_pol_hold(struct xfrm_policy *policy)
    763{
    764	if (likely(policy != NULL))
    765		refcount_inc(&policy->refcnt);
    766}
    767
    768void xfrm_policy_destroy(struct xfrm_policy *policy);
    769
    770static inline void xfrm_pol_put(struct xfrm_policy *policy)
    771{
    772	if (refcount_dec_and_test(&policy->refcnt))
    773		xfrm_policy_destroy(policy);
    774}
    775
    776static inline void xfrm_pols_put(struct xfrm_policy **pols, int npols)
    777{
    778	int i;
    779	for (i = npols - 1; i >= 0; --i)
    780		xfrm_pol_put(pols[i]);
    781}
    782
    783void __xfrm_state_destroy(struct xfrm_state *, bool);
    784
    785static inline void __xfrm_state_put(struct xfrm_state *x)
    786{
    787	refcount_dec(&x->refcnt);
    788}
    789
    790static inline void xfrm_state_put(struct xfrm_state *x)
    791{
    792	if (refcount_dec_and_test(&x->refcnt))
    793		__xfrm_state_destroy(x, false);
    794}
    795
    796static inline void xfrm_state_put_sync(struct xfrm_state *x)
    797{
    798	if (refcount_dec_and_test(&x->refcnt))
    799		__xfrm_state_destroy(x, true);
    800}
    801
    802static inline void xfrm_state_hold(struct xfrm_state *x)
    803{
    804	refcount_inc(&x->refcnt);
    805}
    806
    807static inline bool addr_match(const void *token1, const void *token2,
    808			      unsigned int prefixlen)
    809{
    810	const __be32 *a1 = token1;
    811	const __be32 *a2 = token2;
    812	unsigned int pdw;
    813	unsigned int pbi;
    814
    815	pdw = prefixlen >> 5;	  /* num of whole u32 in prefix */
    816	pbi = prefixlen &  0x1f;  /* num of bits in incomplete u32 in prefix */
    817
    818	if (pdw)
    819		if (memcmp(a1, a2, pdw << 2))
    820			return false;
    821
    822	if (pbi) {
    823		__be32 mask;
    824
    825		mask = htonl((0xffffffff) << (32 - pbi));
    826
    827		if ((a1[pdw] ^ a2[pdw]) & mask)
    828			return false;
    829	}
    830
    831	return true;
    832}
    833
    834static inline bool addr4_match(__be32 a1, __be32 a2, u8 prefixlen)
    835{
    836	/* C99 6.5.7 (3): u32 << 32 is undefined behaviour */
    837	if (sizeof(long) == 4 && prefixlen == 0)
    838		return true;
    839	return !((a1 ^ a2) & htonl(~0UL << (32 - prefixlen)));
    840}
    841
    842static __inline__
    843__be16 xfrm_flowi_sport(const struct flowi *fl, const union flowi_uli *uli)
    844{
    845	__be16 port;
    846	switch(fl->flowi_proto) {
    847	case IPPROTO_TCP:
    848	case IPPROTO_UDP:
    849	case IPPROTO_UDPLITE:
    850	case IPPROTO_SCTP:
    851		port = uli->ports.sport;
    852		break;
    853	case IPPROTO_ICMP:
    854	case IPPROTO_ICMPV6:
    855		port = htons(uli->icmpt.type);
    856		break;
    857	case IPPROTO_MH:
    858		port = htons(uli->mht.type);
    859		break;
    860	case IPPROTO_GRE:
    861		port = htons(ntohl(uli->gre_key) >> 16);
    862		break;
    863	default:
    864		port = 0;	/*XXX*/
    865	}
    866	return port;
    867}
    868
    869static __inline__
    870__be16 xfrm_flowi_dport(const struct flowi *fl, const union flowi_uli *uli)
    871{
    872	__be16 port;
    873	switch(fl->flowi_proto) {
    874	case IPPROTO_TCP:
    875	case IPPROTO_UDP:
    876	case IPPROTO_UDPLITE:
    877	case IPPROTO_SCTP:
    878		port = uli->ports.dport;
    879		break;
    880	case IPPROTO_ICMP:
    881	case IPPROTO_ICMPV6:
    882		port = htons(uli->icmpt.code);
    883		break;
    884	case IPPROTO_GRE:
    885		port = htons(ntohl(uli->gre_key) & 0xffff);
    886		break;
    887	default:
    888		port = 0;	/*XXX*/
    889	}
    890	return port;
    891}
    892
    893bool xfrm_selector_match(const struct xfrm_selector *sel,
    894			 const struct flowi *fl, unsigned short family);
    895
    896#ifdef CONFIG_SECURITY_NETWORK_XFRM
    897/*	If neither has a context --> match
    898 * 	Otherwise, both must have a context and the sids, doi, alg must match
    899 */
    900static inline bool xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
    901{
    902	return ((!s1 && !s2) ||
    903		(s1 && s2 &&
    904		 (s1->ctx_sid == s2->ctx_sid) &&
    905		 (s1->ctx_doi == s2->ctx_doi) &&
    906		 (s1->ctx_alg == s2->ctx_alg)));
    907}
    908#else
    909static inline bool xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
    910{
    911	return true;
    912}
    913#endif
    914
    915/* A struct encoding bundle of transformations to apply to some set of flow.
    916 *
    917 * xdst->child points to the next element of bundle.
    918 * dst->xfrm  points to an instanse of transformer.
    919 *
    920 * Due to unfortunate limitations of current routing cache, which we
    921 * have no time to fix, it mirrors struct rtable and bound to the same
    922 * routing key, including saddr,daddr. However, we can have many of
    923 * bundles differing by session id. All the bundles grow from a parent
    924 * policy rule.
    925 */
    926struct xfrm_dst {
    927	union {
    928		struct dst_entry	dst;
    929		struct rtable		rt;
    930		struct rt6_info		rt6;
    931	} u;
    932	struct dst_entry *route;
    933	struct dst_entry *child;
    934	struct dst_entry *path;
    935	struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX];
    936	int num_pols, num_xfrms;
    937	u32 xfrm_genid;
    938	u32 policy_genid;
    939	u32 route_mtu_cached;
    940	u32 child_mtu_cached;
    941	u32 route_cookie;
    942	u32 path_cookie;
    943};
    944
    945static inline struct dst_entry *xfrm_dst_path(const struct dst_entry *dst)
    946{
    947#ifdef CONFIG_XFRM
    948	if (dst->xfrm || (dst->flags & DST_XFRM_QUEUE)) {
    949		const struct xfrm_dst *xdst = (const struct xfrm_dst *) dst;
    950
    951		return xdst->path;
    952	}
    953#endif
    954	return (struct dst_entry *) dst;
    955}
    956
    957static inline struct dst_entry *xfrm_dst_child(const struct dst_entry *dst)
    958{
    959#ifdef CONFIG_XFRM
    960	if (dst->xfrm || (dst->flags & DST_XFRM_QUEUE)) {
    961		struct xfrm_dst *xdst = (struct xfrm_dst *) dst;
    962		return xdst->child;
    963	}
    964#endif
    965	return NULL;
    966}
    967
    968#ifdef CONFIG_XFRM
    969static inline void xfrm_dst_set_child(struct xfrm_dst *xdst, struct dst_entry *child)
    970{
    971	xdst->child = child;
    972}
    973
    974static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
    975{
    976	xfrm_pols_put(xdst->pols, xdst->num_pols);
    977	dst_release(xdst->route);
    978	if (likely(xdst->u.dst.xfrm))
    979		xfrm_state_put(xdst->u.dst.xfrm);
    980}
    981#endif
    982
    983void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
    984
    985struct xfrm_if_parms {
    986	int link;		/* ifindex of underlying L2 interface */
    987	u32 if_id;		/* interface identifyer */
    988};
    989
    990struct xfrm_if {
    991	struct xfrm_if __rcu *next;	/* next interface in list */
    992	struct net_device *dev;		/* virtual device associated with interface */
    993	struct net *net;		/* netns for packet i/o */
    994	struct xfrm_if_parms p;		/* interface parms */
    995
    996	struct gro_cells gro_cells;
    997};
    998
    999struct xfrm_offload {
   1000	/* Output sequence number for replay protection on offloading. */
   1001	struct {
   1002		__u32 low;
   1003		__u32 hi;
   1004	} seq;
   1005
   1006	__u32			flags;
   1007#define	SA_DELETE_REQ		1
   1008#define	CRYPTO_DONE		2
   1009#define	CRYPTO_NEXT_DONE	4
   1010#define	CRYPTO_FALLBACK		8
   1011#define	XFRM_GSO_SEGMENT	16
   1012#define	XFRM_GRO		32
   1013/* 64 is free */
   1014#define	XFRM_DEV_RESUME		128
   1015#define	XFRM_XMIT		256
   1016
   1017	__u32			status;
   1018#define CRYPTO_SUCCESS				1
   1019#define CRYPTO_GENERIC_ERROR			2
   1020#define CRYPTO_TRANSPORT_AH_AUTH_FAILED		4
   1021#define CRYPTO_TRANSPORT_ESP_AUTH_FAILED	8
   1022#define CRYPTO_TUNNEL_AH_AUTH_FAILED		16
   1023#define CRYPTO_TUNNEL_ESP_AUTH_FAILED		32
   1024#define CRYPTO_INVALID_PACKET_SYNTAX		64
   1025#define CRYPTO_INVALID_PROTOCOL			128
   1026
   1027	__u8			proto;
   1028	__u8			inner_ipproto;
   1029};
   1030
   1031struct sec_path {
   1032	int			len;
   1033	int			olen;
   1034
   1035	struct xfrm_state	*xvec[XFRM_MAX_DEPTH];
   1036	struct xfrm_offload	ovec[XFRM_MAX_OFFLOAD_DEPTH];
   1037};
   1038
   1039struct sec_path *secpath_set(struct sk_buff *skb);
   1040
   1041static inline void
   1042secpath_reset(struct sk_buff *skb)
   1043{
   1044#ifdef CONFIG_XFRM
   1045	skb_ext_del(skb, SKB_EXT_SEC_PATH);
   1046#endif
   1047}
   1048
   1049static inline int
   1050xfrm_addr_any(const xfrm_address_t *addr, unsigned short family)
   1051{
   1052	switch (family) {
   1053	case AF_INET:
   1054		return addr->a4 == 0;
   1055	case AF_INET6:
   1056		return ipv6_addr_any(&addr->in6);
   1057	}
   1058	return 0;
   1059}
   1060
   1061static inline int
   1062__xfrm4_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
   1063{
   1064	return	(tmpl->saddr.a4 &&
   1065		 tmpl->saddr.a4 != x->props.saddr.a4);
   1066}
   1067
   1068static inline int
   1069__xfrm6_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
   1070{
   1071	return	(!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
   1072		 !ipv6_addr_equal((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
   1073}
   1074
   1075static inline int
   1076xfrm_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x, unsigned short family)
   1077{
   1078	switch (family) {
   1079	case AF_INET:
   1080		return __xfrm4_state_addr_cmp(tmpl, x);
   1081	case AF_INET6:
   1082		return __xfrm6_state_addr_cmp(tmpl, x);
   1083	}
   1084	return !0;
   1085}
   1086
   1087#ifdef CONFIG_XFRM
   1088int __xfrm_policy_check(struct sock *, int dir, struct sk_buff *skb,
   1089			unsigned short family);
   1090
   1091static inline bool __xfrm_check_nopolicy(struct net *net, struct sk_buff *skb,
   1092					 int dir)
   1093{
   1094	if (!net->xfrm.policy_count[dir] && !secpath_exists(skb))
   1095		return net->xfrm.policy_default[dir] == XFRM_USERPOLICY_ACCEPT;
   1096
   1097	return false;
   1098}
   1099
   1100static inline bool __xfrm_check_dev_nopolicy(struct sk_buff *skb,
   1101					     int dir, unsigned short family)
   1102{
   1103	if (dir != XFRM_POLICY_OUT && family == AF_INET) {
   1104		/* same dst may be used for traffic originating from
   1105		 * devices with different policy settings.
   1106		 */
   1107		return IPCB(skb)->flags & IPSKB_NOPOLICY;
   1108	}
   1109	return skb_dst(skb) && (skb_dst(skb)->flags & DST_NOPOLICY);
   1110}
   1111
   1112static inline int __xfrm_policy_check2(struct sock *sk, int dir,
   1113				       struct sk_buff *skb,
   1114				       unsigned int family, int reverse)
   1115{
   1116	struct net *net = dev_net(skb->dev);
   1117	int ndir = dir | (reverse ? XFRM_POLICY_MASK + 1 : 0);
   1118
   1119	if (sk && sk->sk_policy[XFRM_POLICY_IN])
   1120		return __xfrm_policy_check(sk, ndir, skb, family);
   1121
   1122	return __xfrm_check_nopolicy(net, skb, dir) ||
   1123	       __xfrm_check_dev_nopolicy(skb, dir, family) ||
   1124	       __xfrm_policy_check(sk, ndir, skb, family);
   1125}
   1126
   1127static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
   1128{
   1129	return __xfrm_policy_check2(sk, dir, skb, family, 0);
   1130}
   1131
   1132static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
   1133{
   1134	return xfrm_policy_check(sk, dir, skb, AF_INET);
   1135}
   1136
   1137static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
   1138{
   1139	return xfrm_policy_check(sk, dir, skb, AF_INET6);
   1140}
   1141
   1142static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
   1143					     struct sk_buff *skb)
   1144{
   1145	return __xfrm_policy_check2(sk, dir, skb, AF_INET, 1);
   1146}
   1147
   1148static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
   1149					     struct sk_buff *skb)
   1150{
   1151	return __xfrm_policy_check2(sk, dir, skb, AF_INET6, 1);
   1152}
   1153
   1154int __xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
   1155			  unsigned int family, int reverse);
   1156
   1157static inline int xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
   1158				      unsigned int family)
   1159{
   1160	return __xfrm_decode_session(skb, fl, family, 0);
   1161}
   1162
   1163static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
   1164					      struct flowi *fl,
   1165					      unsigned int family)
   1166{
   1167	return __xfrm_decode_session(skb, fl, family, 1);
   1168}
   1169
   1170int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
   1171
   1172static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
   1173{
   1174	struct net *net = dev_net(skb->dev);
   1175
   1176	if (!net->xfrm.policy_count[XFRM_POLICY_OUT] &&
   1177	    net->xfrm.policy_default[XFRM_POLICY_OUT] == XFRM_USERPOLICY_ACCEPT)
   1178		return true;
   1179
   1180	return (skb_dst(skb)->flags & DST_NOXFRM) ||
   1181	       __xfrm_route_forward(skb, family);
   1182}
   1183
   1184static inline int xfrm4_route_forward(struct sk_buff *skb)
   1185{
   1186	return xfrm_route_forward(skb, AF_INET);
   1187}
   1188
   1189static inline int xfrm6_route_forward(struct sk_buff *skb)
   1190{
   1191	return xfrm_route_forward(skb, AF_INET6);
   1192}
   1193
   1194int __xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk);
   1195
   1196static inline int xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk)
   1197{
   1198	sk->sk_policy[0] = NULL;
   1199	sk->sk_policy[1] = NULL;
   1200	if (unlikely(osk->sk_policy[0] || osk->sk_policy[1]))
   1201		return __xfrm_sk_clone_policy(sk, osk);
   1202	return 0;
   1203}
   1204
   1205int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
   1206
   1207static inline void xfrm_sk_free_policy(struct sock *sk)
   1208{
   1209	struct xfrm_policy *pol;
   1210
   1211	pol = rcu_dereference_protected(sk->sk_policy[0], 1);
   1212	if (unlikely(pol != NULL)) {
   1213		xfrm_policy_delete(pol, XFRM_POLICY_MAX);
   1214		sk->sk_policy[0] = NULL;
   1215	}
   1216	pol = rcu_dereference_protected(sk->sk_policy[1], 1);
   1217	if (unlikely(pol != NULL)) {
   1218		xfrm_policy_delete(pol, XFRM_POLICY_MAX+1);
   1219		sk->sk_policy[1] = NULL;
   1220	}
   1221}
   1222
   1223#else
   1224
   1225static inline void xfrm_sk_free_policy(struct sock *sk) {}
   1226static inline int xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk) { return 0; }
   1227static inline int xfrm6_route_forward(struct sk_buff *skb) { return 1; }
   1228static inline int xfrm4_route_forward(struct sk_buff *skb) { return 1; }
   1229static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
   1230{
   1231	return 1;
   1232}
   1233static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
   1234{
   1235	return 1;
   1236}
   1237static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
   1238{
   1239	return 1;
   1240}
   1241static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
   1242					      struct flowi *fl,
   1243					      unsigned int family)
   1244{
   1245	return -ENOSYS;
   1246}
   1247static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
   1248					     struct sk_buff *skb)
   1249{
   1250	return 1;
   1251}
   1252static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
   1253					     struct sk_buff *skb)
   1254{
   1255	return 1;
   1256}
   1257#endif
   1258
   1259static __inline__
   1260xfrm_address_t *xfrm_flowi_daddr(const struct flowi *fl, unsigned short family)
   1261{
   1262	switch (family){
   1263	case AF_INET:
   1264		return (xfrm_address_t *)&fl->u.ip4.daddr;
   1265	case AF_INET6:
   1266		return (xfrm_address_t *)&fl->u.ip6.daddr;
   1267	}
   1268	return NULL;
   1269}
   1270
   1271static __inline__
   1272xfrm_address_t *xfrm_flowi_saddr(const struct flowi *fl, unsigned short family)
   1273{
   1274	switch (family){
   1275	case AF_INET:
   1276		return (xfrm_address_t *)&fl->u.ip4.saddr;
   1277	case AF_INET6:
   1278		return (xfrm_address_t *)&fl->u.ip6.saddr;
   1279	}
   1280	return NULL;
   1281}
   1282
   1283static __inline__
   1284void xfrm_flowi_addr_get(const struct flowi *fl,
   1285			 xfrm_address_t *saddr, xfrm_address_t *daddr,
   1286			 unsigned short family)
   1287{
   1288	switch(family) {
   1289	case AF_INET:
   1290		memcpy(&saddr->a4, &fl->u.ip4.saddr, sizeof(saddr->a4));
   1291		memcpy(&daddr->a4, &fl->u.ip4.daddr, sizeof(daddr->a4));
   1292		break;
   1293	case AF_INET6:
   1294		saddr->in6 = fl->u.ip6.saddr;
   1295		daddr->in6 = fl->u.ip6.daddr;
   1296		break;
   1297	}
   1298}
   1299
   1300static __inline__ int
   1301__xfrm4_state_addr_check(const struct xfrm_state *x,
   1302			 const xfrm_address_t *daddr, const xfrm_address_t *saddr)
   1303{
   1304	if (daddr->a4 == x->id.daddr.a4 &&
   1305	    (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
   1306		return 1;
   1307	return 0;
   1308}
   1309
   1310static __inline__ int
   1311__xfrm6_state_addr_check(const struct xfrm_state *x,
   1312			 const xfrm_address_t *daddr, const xfrm_address_t *saddr)
   1313{
   1314	if (ipv6_addr_equal((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
   1315	    (ipv6_addr_equal((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr) ||
   1316	     ipv6_addr_any((struct in6_addr *)saddr) ||
   1317	     ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
   1318		return 1;
   1319	return 0;
   1320}
   1321
   1322static __inline__ int
   1323xfrm_state_addr_check(const struct xfrm_state *x,
   1324		      const xfrm_address_t *daddr, const xfrm_address_t *saddr,
   1325		      unsigned short family)
   1326{
   1327	switch (family) {
   1328	case AF_INET:
   1329		return __xfrm4_state_addr_check(x, daddr, saddr);
   1330	case AF_INET6:
   1331		return __xfrm6_state_addr_check(x, daddr, saddr);
   1332	}
   1333	return 0;
   1334}
   1335
   1336static __inline__ int
   1337xfrm_state_addr_flow_check(const struct xfrm_state *x, const struct flowi *fl,
   1338			   unsigned short family)
   1339{
   1340	switch (family) {
   1341	case AF_INET:
   1342		return __xfrm4_state_addr_check(x,
   1343						(const xfrm_address_t *)&fl->u.ip4.daddr,
   1344						(const xfrm_address_t *)&fl->u.ip4.saddr);
   1345	case AF_INET6:
   1346		return __xfrm6_state_addr_check(x,
   1347						(const xfrm_address_t *)&fl->u.ip6.daddr,
   1348						(const xfrm_address_t *)&fl->u.ip6.saddr);
   1349	}
   1350	return 0;
   1351}
   1352
   1353static inline int xfrm_state_kern(const struct xfrm_state *x)
   1354{
   1355	return atomic_read(&x->tunnel_users);
   1356}
   1357
   1358static inline bool xfrm_id_proto_valid(u8 proto)
   1359{
   1360	switch (proto) {
   1361	case IPPROTO_AH:
   1362	case IPPROTO_ESP:
   1363	case IPPROTO_COMP:
   1364#if IS_ENABLED(CONFIG_IPV6)
   1365	case IPPROTO_ROUTING:
   1366	case IPPROTO_DSTOPTS:
   1367#endif
   1368		return true;
   1369	default:
   1370		return false;
   1371	}
   1372}
   1373
   1374/* IPSEC_PROTO_ANY only matches 3 IPsec protocols, 0 could match all. */
   1375static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
   1376{
   1377	return (!userproto || proto == userproto ||
   1378		(userproto == IPSEC_PROTO_ANY && (proto == IPPROTO_AH ||
   1379						  proto == IPPROTO_ESP ||
   1380						  proto == IPPROTO_COMP)));
   1381}
   1382
   1383/*
   1384 * xfrm algorithm information
   1385 */
   1386struct xfrm_algo_aead_info {
   1387	char *geniv;
   1388	u16 icv_truncbits;
   1389};
   1390
   1391struct xfrm_algo_auth_info {
   1392	u16 icv_truncbits;
   1393	u16 icv_fullbits;
   1394};
   1395
   1396struct xfrm_algo_encr_info {
   1397	char *geniv;
   1398	u16 blockbits;
   1399	u16 defkeybits;
   1400};
   1401
   1402struct xfrm_algo_comp_info {
   1403	u16 threshold;
   1404};
   1405
   1406struct xfrm_algo_desc {
   1407	char *name;
   1408	char *compat;
   1409	u8 available:1;
   1410	u8 pfkey_supported:1;
   1411	union {
   1412		struct xfrm_algo_aead_info aead;
   1413		struct xfrm_algo_auth_info auth;
   1414		struct xfrm_algo_encr_info encr;
   1415		struct xfrm_algo_comp_info comp;
   1416	} uinfo;
   1417	struct sadb_alg desc;
   1418};
   1419
   1420/* XFRM protocol handlers.  */
   1421struct xfrm4_protocol {
   1422	int (*handler)(struct sk_buff *skb);
   1423	int (*input_handler)(struct sk_buff *skb, int nexthdr, __be32 spi,
   1424			     int encap_type);
   1425	int (*cb_handler)(struct sk_buff *skb, int err);
   1426	int (*err_handler)(struct sk_buff *skb, u32 info);
   1427
   1428	struct xfrm4_protocol __rcu *next;
   1429	int priority;
   1430};
   1431
   1432struct xfrm6_protocol {
   1433	int (*handler)(struct sk_buff *skb);
   1434	int (*input_handler)(struct sk_buff *skb, int nexthdr, __be32 spi,
   1435			     int encap_type);
   1436	int (*cb_handler)(struct sk_buff *skb, int err);
   1437	int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
   1438			   u8 type, u8 code, int offset, __be32 info);
   1439
   1440	struct xfrm6_protocol __rcu *next;
   1441	int priority;
   1442};
   1443
   1444/* XFRM tunnel handlers.  */
   1445struct xfrm_tunnel {
   1446	int (*handler)(struct sk_buff *skb);
   1447	int (*cb_handler)(struct sk_buff *skb, int err);
   1448	int (*err_handler)(struct sk_buff *skb, u32 info);
   1449
   1450	struct xfrm_tunnel __rcu *next;
   1451	int priority;
   1452};
   1453
   1454struct xfrm6_tunnel {
   1455	int (*handler)(struct sk_buff *skb);
   1456	int (*cb_handler)(struct sk_buff *skb, int err);
   1457	int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
   1458			   u8 type, u8 code, int offset, __be32 info);
   1459	struct xfrm6_tunnel __rcu *next;
   1460	int priority;
   1461};
   1462
   1463void xfrm_init(void);
   1464void xfrm4_init(void);
   1465int xfrm_state_init(struct net *net);
   1466void xfrm_state_fini(struct net *net);
   1467void xfrm4_state_init(void);
   1468void xfrm4_protocol_init(void);
   1469#ifdef CONFIG_XFRM
   1470int xfrm6_init(void);
   1471void xfrm6_fini(void);
   1472int xfrm6_state_init(void);
   1473void xfrm6_state_fini(void);
   1474int xfrm6_protocol_init(void);
   1475void xfrm6_protocol_fini(void);
   1476#else
   1477static inline int xfrm6_init(void)
   1478{
   1479	return 0;
   1480}
   1481static inline void xfrm6_fini(void)
   1482{
   1483	;
   1484}
   1485#endif
   1486
   1487#ifdef CONFIG_XFRM_STATISTICS
   1488int xfrm_proc_init(struct net *net);
   1489void xfrm_proc_fini(struct net *net);
   1490#endif
   1491
   1492int xfrm_sysctl_init(struct net *net);
   1493#ifdef CONFIG_SYSCTL
   1494void xfrm_sysctl_fini(struct net *net);
   1495#else
   1496static inline void xfrm_sysctl_fini(struct net *net)
   1497{
   1498}
   1499#endif
   1500
   1501void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto,
   1502			  struct xfrm_address_filter *filter);
   1503int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
   1504		    int (*func)(struct xfrm_state *, int, void*), void *);
   1505void xfrm_state_walk_done(struct xfrm_state_walk *walk, struct net *net);
   1506struct xfrm_state *xfrm_state_alloc(struct net *net);
   1507void xfrm_state_free(struct xfrm_state *x);
   1508struct xfrm_state *xfrm_state_find(const xfrm_address_t *daddr,
   1509				   const xfrm_address_t *saddr,
   1510				   const struct flowi *fl,
   1511				   struct xfrm_tmpl *tmpl,
   1512				   struct xfrm_policy *pol, int *err,
   1513				   unsigned short family, u32 if_id);
   1514struct xfrm_state *xfrm_stateonly_find(struct net *net, u32 mark, u32 if_id,
   1515				       xfrm_address_t *daddr,
   1516				       xfrm_address_t *saddr,
   1517				       unsigned short family,
   1518				       u8 mode, u8 proto, u32 reqid);
   1519struct xfrm_state *xfrm_state_lookup_byspi(struct net *net, __be32 spi,
   1520					      unsigned short family);
   1521int xfrm_state_check_expire(struct xfrm_state *x);
   1522void xfrm_state_insert(struct xfrm_state *x);
   1523int xfrm_state_add(struct xfrm_state *x);
   1524int xfrm_state_update(struct xfrm_state *x);
   1525struct xfrm_state *xfrm_state_lookup(struct net *net, u32 mark,
   1526				     const xfrm_address_t *daddr, __be32 spi,
   1527				     u8 proto, unsigned short family);
   1528struct xfrm_state *xfrm_state_lookup_byaddr(struct net *net, u32 mark,
   1529					    const xfrm_address_t *daddr,
   1530					    const xfrm_address_t *saddr,
   1531					    u8 proto,
   1532					    unsigned short family);
   1533#ifdef CONFIG_XFRM_SUB_POLICY
   1534void xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,
   1535		    unsigned short family);
   1536void xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src, int n,
   1537		     unsigned short family);
   1538#else
   1539static inline void xfrm_tmpl_sort(struct xfrm_tmpl **d, struct xfrm_tmpl **s,
   1540				  int n, unsigned short family)
   1541{
   1542}
   1543
   1544static inline void xfrm_state_sort(struct xfrm_state **d, struct xfrm_state **s,
   1545				   int n, unsigned short family)
   1546{
   1547}
   1548#endif
   1549
   1550struct xfrmk_sadinfo {
   1551	u32 sadhcnt; /* current hash bkts */
   1552	u32 sadhmcnt; /* max allowed hash bkts */
   1553	u32 sadcnt; /* current running count */
   1554};
   1555
   1556struct xfrmk_spdinfo {
   1557	u32 incnt;
   1558	u32 outcnt;
   1559	u32 fwdcnt;
   1560	u32 inscnt;
   1561	u32 outscnt;
   1562	u32 fwdscnt;
   1563	u32 spdhcnt;
   1564	u32 spdhmcnt;
   1565};
   1566
   1567struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq);
   1568int xfrm_state_delete(struct xfrm_state *x);
   1569int xfrm_state_flush(struct net *net, u8 proto, bool task_valid, bool sync);
   1570int xfrm_dev_state_flush(struct net *net, struct net_device *dev, bool task_valid);
   1571void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si);
   1572void xfrm_spd_getinfo(struct net *net, struct xfrmk_spdinfo *si);
   1573u32 xfrm_replay_seqhi(struct xfrm_state *x, __be32 net_seq);
   1574int xfrm_init_replay(struct xfrm_state *x);
   1575u32 xfrm_state_mtu(struct xfrm_state *x, int mtu);
   1576int __xfrm_init_state(struct xfrm_state *x, bool init_replay, bool offload);
   1577int xfrm_init_state(struct xfrm_state *x);
   1578int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type);
   1579int xfrm_input_resume(struct sk_buff *skb, int nexthdr);
   1580int xfrm_trans_queue_net(struct net *net, struct sk_buff *skb,
   1581			 int (*finish)(struct net *, struct sock *,
   1582				       struct sk_buff *));
   1583int xfrm_trans_queue(struct sk_buff *skb,
   1584		     int (*finish)(struct net *, struct sock *,
   1585				   struct sk_buff *));
   1586int xfrm_output_resume(struct sock *sk, struct sk_buff *skb, int err);
   1587int xfrm_output(struct sock *sk, struct sk_buff *skb);
   1588
   1589#if IS_ENABLED(CONFIG_NET_PKTGEN)
   1590int pktgen_xfrm_outer_mode_output(struct xfrm_state *x, struct sk_buff *skb);
   1591#endif
   1592
   1593void xfrm_local_error(struct sk_buff *skb, int mtu);
   1594int xfrm4_extract_input(struct xfrm_state *x, struct sk_buff *skb);
   1595int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
   1596		    int encap_type);
   1597int xfrm4_transport_finish(struct sk_buff *skb, int async);
   1598int xfrm4_rcv(struct sk_buff *skb);
   1599
   1600static inline int xfrm4_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi)
   1601{
   1602	XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL;
   1603	XFRM_SPI_SKB_CB(skb)->family = AF_INET;
   1604	XFRM_SPI_SKB_CB(skb)->daddroff = offsetof(struct iphdr, daddr);
   1605	return xfrm_input(skb, nexthdr, spi, 0);
   1606}
   1607
   1608int xfrm4_output(struct net *net, struct sock *sk, struct sk_buff *skb);
   1609int xfrm4_protocol_register(struct xfrm4_protocol *handler, unsigned char protocol);
   1610int xfrm4_protocol_deregister(struct xfrm4_protocol *handler, unsigned char protocol);
   1611int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family);
   1612int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family);
   1613void xfrm4_local_error(struct sk_buff *skb, u32 mtu);
   1614int xfrm6_extract_input(struct xfrm_state *x, struct sk_buff *skb);
   1615int xfrm6_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi,
   1616		  struct ip6_tnl *t);
   1617int xfrm6_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
   1618		    int encap_type);
   1619int xfrm6_transport_finish(struct sk_buff *skb, int async);
   1620int xfrm6_rcv_tnl(struct sk_buff *skb, struct ip6_tnl *t);
   1621int xfrm6_rcv(struct sk_buff *skb);
   1622int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
   1623		     xfrm_address_t *saddr, u8 proto);
   1624void xfrm6_local_error(struct sk_buff *skb, u32 mtu);
   1625int xfrm6_protocol_register(struct xfrm6_protocol *handler, unsigned char protocol);
   1626int xfrm6_protocol_deregister(struct xfrm6_protocol *handler, unsigned char protocol);
   1627int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family);
   1628int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family);
   1629__be32 xfrm6_tunnel_alloc_spi(struct net *net, xfrm_address_t *saddr);
   1630__be32 xfrm6_tunnel_spi_lookup(struct net *net, const xfrm_address_t *saddr);
   1631int xfrm6_output(struct net *net, struct sock *sk, struct sk_buff *skb);
   1632
   1633#ifdef CONFIG_XFRM
   1634void xfrm6_local_rxpmtu(struct sk_buff *skb, u32 mtu);
   1635int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
   1636int xfrm6_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
   1637int xfrm_user_policy(struct sock *sk, int optname, sockptr_t optval,
   1638		     int optlen);
   1639#else
   1640static inline int xfrm_user_policy(struct sock *sk, int optname,
   1641				   sockptr_t optval, int optlen)
   1642{
   1643 	return -ENOPROTOOPT;
   1644}
   1645#endif
   1646
   1647struct dst_entry *__xfrm_dst_lookup(struct net *net, int tos, int oif,
   1648				    const xfrm_address_t *saddr,
   1649				    const xfrm_address_t *daddr,
   1650				    int family, u32 mark);
   1651
   1652struct xfrm_policy *xfrm_policy_alloc(struct net *net, gfp_t gfp);
   1653
   1654void xfrm_policy_walk_init(struct xfrm_policy_walk *walk, u8 type);
   1655int xfrm_policy_walk(struct net *net, struct xfrm_policy_walk *walk,
   1656		     int (*func)(struct xfrm_policy *, int, int, void*),
   1657		     void *);
   1658void xfrm_policy_walk_done(struct xfrm_policy_walk *walk, struct net *net);
   1659int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
   1660struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net,
   1661					  const struct xfrm_mark *mark,
   1662					  u32 if_id, u8 type, int dir,
   1663					  struct xfrm_selector *sel,
   1664					  struct xfrm_sec_ctx *ctx, int delete,
   1665					  int *err);
   1666struct xfrm_policy *xfrm_policy_byid(struct net *net,
   1667				     const struct xfrm_mark *mark, u32 if_id,
   1668				     u8 type, int dir, u32 id, int delete,
   1669				     int *err);
   1670int xfrm_policy_flush(struct net *net, u8 type, bool task_valid);
   1671void xfrm_policy_hash_rebuild(struct net *net);
   1672u32 xfrm_get_acqseq(void);
   1673int verify_spi_info(u8 proto, u32 min, u32 max);
   1674int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
   1675struct xfrm_state *xfrm_find_acq(struct net *net, const struct xfrm_mark *mark,
   1676				 u8 mode, u32 reqid, u32 if_id, u8 proto,
   1677				 const xfrm_address_t *daddr,
   1678				 const xfrm_address_t *saddr, int create,
   1679				 unsigned short family);
   1680int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
   1681
   1682#ifdef CONFIG_XFRM_MIGRATE
   1683int km_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
   1684	       const struct xfrm_migrate *m, int num_bundles,
   1685	       const struct xfrm_kmaddress *k,
   1686	       const struct xfrm_encap_tmpl *encap);
   1687struct xfrm_state *xfrm_migrate_state_find(struct xfrm_migrate *m, struct net *net,
   1688						u32 if_id);
   1689struct xfrm_state *xfrm_state_migrate(struct xfrm_state *x,
   1690				      struct xfrm_migrate *m,
   1691				      struct xfrm_encap_tmpl *encap);
   1692int xfrm_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
   1693		 struct xfrm_migrate *m, int num_bundles,
   1694		 struct xfrm_kmaddress *k, struct net *net,
   1695		 struct xfrm_encap_tmpl *encap, u32 if_id);
   1696#endif
   1697
   1698int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
   1699void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 portid);
   1700int km_report(struct net *net, u8 proto, struct xfrm_selector *sel,
   1701	      xfrm_address_t *addr);
   1702
   1703void xfrm_input_init(void);
   1704int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
   1705
   1706void xfrm_probe_algs(void);
   1707int xfrm_count_pfkey_auth_supported(void);
   1708int xfrm_count_pfkey_enc_supported(void);
   1709struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
   1710struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
   1711struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
   1712struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
   1713struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
   1714struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe);
   1715struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe);
   1716struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe);
   1717struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len,
   1718					    int probe);
   1719
   1720static inline bool xfrm6_addr_equal(const xfrm_address_t *a,
   1721				    const xfrm_address_t *b)
   1722{
   1723	return ipv6_addr_equal((const struct in6_addr *)a,
   1724			       (const struct in6_addr *)b);
   1725}
   1726
   1727static inline bool xfrm_addr_equal(const xfrm_address_t *a,
   1728				   const xfrm_address_t *b,
   1729				   sa_family_t family)
   1730{
   1731	switch (family) {
   1732	default:
   1733	case AF_INET:
   1734		return ((__force u32)a->a4 ^ (__force u32)b->a4) == 0;
   1735	case AF_INET6:
   1736		return xfrm6_addr_equal(a, b);
   1737	}
   1738}
   1739
   1740static inline int xfrm_policy_id2dir(u32 index)
   1741{
   1742	return index & 7;
   1743}
   1744
   1745#ifdef CONFIG_XFRM
   1746void xfrm_replay_advance(struct xfrm_state *x, __be32 net_seq);
   1747int xfrm_replay_check(struct xfrm_state *x, struct sk_buff *skb, __be32 net_seq);
   1748void xfrm_replay_notify(struct xfrm_state *x, int event);
   1749int xfrm_replay_overflow(struct xfrm_state *x, struct sk_buff *skb);
   1750int xfrm_replay_recheck(struct xfrm_state *x, struct sk_buff *skb, __be32 net_seq);
   1751
   1752static inline int xfrm_aevent_is_on(struct net *net)
   1753{
   1754	struct sock *nlsk;
   1755	int ret = 0;
   1756
   1757	rcu_read_lock();
   1758	nlsk = rcu_dereference(net->xfrm.nlsk);
   1759	if (nlsk)
   1760		ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
   1761	rcu_read_unlock();
   1762	return ret;
   1763}
   1764
   1765static inline int xfrm_acquire_is_on(struct net *net)
   1766{
   1767	struct sock *nlsk;
   1768	int ret = 0;
   1769
   1770	rcu_read_lock();
   1771	nlsk = rcu_dereference(net->xfrm.nlsk);
   1772	if (nlsk)
   1773		ret = netlink_has_listeners(nlsk, XFRMNLGRP_ACQUIRE);
   1774	rcu_read_unlock();
   1775
   1776	return ret;
   1777}
   1778#endif
   1779
   1780static inline unsigned int aead_len(struct xfrm_algo_aead *alg)
   1781{
   1782	return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
   1783}
   1784
   1785static inline unsigned int xfrm_alg_len(const struct xfrm_algo *alg)
   1786{
   1787	return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
   1788}
   1789
   1790static inline unsigned int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg)
   1791{
   1792	return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
   1793}
   1794
   1795static inline unsigned int xfrm_replay_state_esn_len(struct xfrm_replay_state_esn *replay_esn)
   1796{
   1797	return sizeof(*replay_esn) + replay_esn->bmp_len * sizeof(__u32);
   1798}
   1799
   1800#ifdef CONFIG_XFRM_MIGRATE
   1801static inline int xfrm_replay_clone(struct xfrm_state *x,
   1802				     struct xfrm_state *orig)
   1803{
   1804
   1805	x->replay_esn = kmemdup(orig->replay_esn,
   1806				xfrm_replay_state_esn_len(orig->replay_esn),
   1807				GFP_KERNEL);
   1808	if (!x->replay_esn)
   1809		return -ENOMEM;
   1810	x->preplay_esn = kmemdup(orig->preplay_esn,
   1811				 xfrm_replay_state_esn_len(orig->preplay_esn),
   1812				 GFP_KERNEL);
   1813	if (!x->preplay_esn)
   1814		return -ENOMEM;
   1815
   1816	return 0;
   1817}
   1818
   1819static inline struct xfrm_algo_aead *xfrm_algo_aead_clone(struct xfrm_algo_aead *orig)
   1820{
   1821	return kmemdup(orig, aead_len(orig), GFP_KERNEL);
   1822}
   1823
   1824
   1825static inline struct xfrm_algo *xfrm_algo_clone(struct xfrm_algo *orig)
   1826{
   1827	return kmemdup(orig, xfrm_alg_len(orig), GFP_KERNEL);
   1828}
   1829
   1830static inline struct xfrm_algo_auth *xfrm_algo_auth_clone(struct xfrm_algo_auth *orig)
   1831{
   1832	return kmemdup(orig, xfrm_alg_auth_len(orig), GFP_KERNEL);
   1833}
   1834
   1835static inline void xfrm_states_put(struct xfrm_state **states, int n)
   1836{
   1837	int i;
   1838	for (i = 0; i < n; i++)
   1839		xfrm_state_put(*(states + i));
   1840}
   1841
   1842static inline void xfrm_states_delete(struct xfrm_state **states, int n)
   1843{
   1844	int i;
   1845	for (i = 0; i < n; i++)
   1846		xfrm_state_delete(*(states + i));
   1847}
   1848#endif
   1849
   1850#ifdef CONFIG_XFRM
   1851static inline struct xfrm_state *xfrm_input_state(struct sk_buff *skb)
   1852{
   1853	struct sec_path *sp = skb_sec_path(skb);
   1854
   1855	return sp->xvec[sp->len - 1];
   1856}
   1857#endif
   1858
   1859static inline struct xfrm_offload *xfrm_offload(struct sk_buff *skb)
   1860{
   1861#ifdef CONFIG_XFRM
   1862	struct sec_path *sp = skb_sec_path(skb);
   1863
   1864	if (!sp || !sp->olen || sp->len != sp->olen)
   1865		return NULL;
   1866
   1867	return &sp->ovec[sp->olen - 1];
   1868#else
   1869	return NULL;
   1870#endif
   1871}
   1872
   1873void __init xfrm_dev_init(void);
   1874
   1875#ifdef CONFIG_XFRM_OFFLOAD
   1876void xfrm_dev_resume(struct sk_buff *skb);
   1877void xfrm_dev_backlog(struct softnet_data *sd);
   1878struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again);
   1879int xfrm_dev_state_add(struct net *net, struct xfrm_state *x,
   1880		       struct xfrm_user_offload *xuo);
   1881bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x);
   1882
   1883static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
   1884{
   1885	struct xfrm_dev_offload *xso = &x->xso;
   1886
   1887	if (xso->dev && xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn)
   1888		xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn(x);
   1889}
   1890
   1891static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
   1892{
   1893	struct xfrm_state *x = dst->xfrm;
   1894	struct xfrm_dst *xdst;
   1895
   1896	if (!x || !x->type_offload)
   1897		return false;
   1898
   1899	xdst = (struct xfrm_dst *) dst;
   1900	if (!x->xso.offload_handle && !xdst->child->xfrm)
   1901		return true;
   1902	if (x->xso.offload_handle && (x->xso.dev == xfrm_dst_path(dst)->dev) &&
   1903	    !xdst->child->xfrm)
   1904		return true;
   1905
   1906	return false;
   1907}
   1908
   1909static inline void xfrm_dev_state_delete(struct xfrm_state *x)
   1910{
   1911	struct xfrm_dev_offload *xso = &x->xso;
   1912
   1913	if (xso->dev)
   1914		xso->dev->xfrmdev_ops->xdo_dev_state_delete(x);
   1915}
   1916
   1917static inline void xfrm_dev_state_free(struct xfrm_state *x)
   1918{
   1919	struct xfrm_dev_offload *xso = &x->xso;
   1920	struct net_device *dev = xso->dev;
   1921
   1922	if (dev && dev->xfrmdev_ops) {
   1923		if (dev->xfrmdev_ops->xdo_dev_state_free)
   1924			dev->xfrmdev_ops->xdo_dev_state_free(x);
   1925		xso->dev = NULL;
   1926		dev_put_track(dev, &xso->dev_tracker);
   1927	}
   1928}
   1929#else
   1930static inline void xfrm_dev_resume(struct sk_buff *skb)
   1931{
   1932}
   1933
   1934static inline void xfrm_dev_backlog(struct softnet_data *sd)
   1935{
   1936}
   1937
   1938static inline struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again)
   1939{
   1940	return skb;
   1941}
   1942
   1943static inline int xfrm_dev_state_add(struct net *net, struct xfrm_state *x, struct xfrm_user_offload *xuo)
   1944{
   1945	return 0;
   1946}
   1947
   1948static inline void xfrm_dev_state_delete(struct xfrm_state *x)
   1949{
   1950}
   1951
   1952static inline void xfrm_dev_state_free(struct xfrm_state *x)
   1953{
   1954}
   1955
   1956static inline bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x)
   1957{
   1958	return false;
   1959}
   1960
   1961static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
   1962{
   1963}
   1964
   1965static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
   1966{
   1967	return false;
   1968}
   1969#endif
   1970
   1971static inline int xfrm_mark_get(struct nlattr **attrs, struct xfrm_mark *m)
   1972{
   1973	if (attrs[XFRMA_MARK])
   1974		memcpy(m, nla_data(attrs[XFRMA_MARK]), sizeof(struct xfrm_mark));
   1975	else
   1976		m->v = m->m = 0;
   1977
   1978	return m->v & m->m;
   1979}
   1980
   1981static inline int xfrm_mark_put(struct sk_buff *skb, const struct xfrm_mark *m)
   1982{
   1983	int ret = 0;
   1984
   1985	if (m->m | m->v)
   1986		ret = nla_put(skb, XFRMA_MARK, sizeof(struct xfrm_mark), m);
   1987	return ret;
   1988}
   1989
   1990static inline __u32 xfrm_smark_get(__u32 mark, struct xfrm_state *x)
   1991{
   1992	struct xfrm_mark *m = &x->props.smark;
   1993
   1994	return (m->v & m->m) | (mark & ~m->m);
   1995}
   1996
   1997static inline int xfrm_if_id_put(struct sk_buff *skb, __u32 if_id)
   1998{
   1999	int ret = 0;
   2000
   2001	if (if_id)
   2002		ret = nla_put_u32(skb, XFRMA_IF_ID, if_id);
   2003	return ret;
   2004}
   2005
   2006static inline int xfrm_tunnel_check(struct sk_buff *skb, struct xfrm_state *x,
   2007				    unsigned int family)
   2008{
   2009	bool tunnel = false;
   2010
   2011	switch(family) {
   2012	case AF_INET:
   2013		if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4)
   2014			tunnel = true;
   2015		break;
   2016	case AF_INET6:
   2017		if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6)
   2018			tunnel = true;
   2019		break;
   2020	}
   2021	if (tunnel && !(x->outer_mode.flags & XFRM_MODE_FLAG_TUNNEL))
   2022		return -EINVAL;
   2023
   2024	return 0;
   2025}
   2026
   2027extern const int xfrm_msg_min[XFRM_NR_MSGTYPES];
   2028extern const struct nla_policy xfrma_policy[XFRMA_MAX+1];
   2029
   2030struct xfrm_translator {
   2031	/* Allocate frag_list and put compat translation there */
   2032	int (*alloc_compat)(struct sk_buff *skb, const struct nlmsghdr *src);
   2033
   2034	/* Allocate nlmsg with 64-bit translaton of received 32-bit message */
   2035	struct nlmsghdr *(*rcv_msg_compat)(const struct nlmsghdr *nlh,
   2036			int maxtype, const struct nla_policy *policy,
   2037			struct netlink_ext_ack *extack);
   2038
   2039	/* Translate 32-bit user_policy from sockptr */
   2040	int (*xlate_user_policy_sockptr)(u8 **pdata32, int optlen);
   2041
   2042	struct module *owner;
   2043};
   2044
   2045#if IS_ENABLED(CONFIG_XFRM_USER_COMPAT)
   2046extern int xfrm_register_translator(struct xfrm_translator *xtr);
   2047extern int xfrm_unregister_translator(struct xfrm_translator *xtr);
   2048extern struct xfrm_translator *xfrm_get_translator(void);
   2049extern void xfrm_put_translator(struct xfrm_translator *xtr);
   2050#else
   2051static inline struct xfrm_translator *xfrm_get_translator(void)
   2052{
   2053	return NULL;
   2054}
   2055static inline void xfrm_put_translator(struct xfrm_translator *xtr)
   2056{
   2057}
   2058#endif
   2059
   2060#if IS_ENABLED(CONFIG_IPV6)
   2061static inline bool xfrm6_local_dontfrag(const struct sock *sk)
   2062{
   2063	int proto;
   2064
   2065	if (!sk || sk->sk_family != AF_INET6)
   2066		return false;
   2067
   2068	proto = sk->sk_protocol;
   2069	if (proto == IPPROTO_UDP || proto == IPPROTO_RAW)
   2070		return inet6_sk(sk)->dontfrag;
   2071
   2072	return false;
   2073}
   2074#endif
   2075#endif	/* _NET_XFRM_H */