Branch data Line data Source code
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 : :
19 : : #include <net/sock.h>
20 : : #include <net/dst.h>
21 : : #include <net/ip.h>
22 : : #include <net/route.h>
23 : : #include <net/ipv6.h>
24 : : #include <net/ip6_fib.h>
25 : : #include <net/flow.h>
26 : : #include <net/gro_cells.h>
27 : :
28 : : #include <linux/interrupt.h>
29 : :
30 : : #ifdef CONFIG_XFRM_STATISTICS
31 : : #include <net/snmp.h>
32 : : #endif
33 : :
34 : : #define XFRM_PROTO_ESP 50
35 : : #define XFRM_PROTO_AH 51
36 : : #define XFRM_PROTO_COMP 108
37 : : #define XFRM_PROTO_IPIP 4
38 : : #define XFRM_PROTO_IPV6 41
39 : : #define XFRM_PROTO_ROUTING IPPROTO_ROUTING
40 : : #define XFRM_PROTO_DSTOPTS IPPROTO_DSTOPTS
41 : :
42 : : #define XFRM_ALIGN4(len) (((len) + 3) & ~3)
43 : : #define XFRM_ALIGN8(len) (((len) + 7) & ~7)
44 : : #define MODULE_ALIAS_XFRM_MODE(family, encap) \
45 : : MODULE_ALIAS("xfrm-mode-" __stringify(family) "-" __stringify(encap))
46 : : #define MODULE_ALIAS_XFRM_TYPE(family, proto) \
47 : : MODULE_ALIAS("xfrm-type-" __stringify(family) "-" __stringify(proto))
48 : : #define MODULE_ALIAS_XFRM_OFFLOAD_TYPE(family, proto) \
49 : : MODULE_ALIAS("xfrm-offload-" __stringify(family) "-" __stringify(proto))
50 : :
51 : : #ifdef CONFIG_XFRM_STATISTICS
52 : : #define XFRM_INC_STATS(net, field) SNMP_INC_STATS((net)->mib.xfrm_statistics, field)
53 : : #else
54 : : #define XFRM_INC_STATS(net, field) ((void)(net))
55 : : #endif
56 : :
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 : :
119 : : struct xfrm_state_walk {
120 : : struct list_head all;
121 : : u8 state;
122 : : u8 dying;
123 : : u8 proto;
124 : : u32 seq;
125 : : struct xfrm_address_filter *filter;
126 : : };
127 : :
128 : : struct xfrm_state_offload {
129 : : struct net_device *dev;
130 : : unsigned long offload_handle;
131 : : unsigned int num_exthdrs;
132 : : u8 flags;
133 : : };
134 : :
135 : : struct xfrm_mode {
136 : : u8 encap;
137 : : u8 family;
138 : : u8 flags;
139 : : };
140 : :
141 : : /* Flags for xfrm_mode. */
142 : : enum {
143 : : XFRM_MODE_FLAG_TUNNEL = 1,
144 : : };
145 : :
146 : : /* Full description of state of transformer. */
147 : : struct xfrm_state {
148 : : possible_net_t xs_net;
149 : : union {
150 : : struct hlist_node gclist;
151 : : struct hlist_node bydst;
152 : : };
153 : : struct hlist_node bysrc;
154 : : struct hlist_node byspi;
155 : :
156 : : refcount_t refcnt;
157 : : spinlock_t lock;
158 : :
159 : : struct xfrm_id id;
160 : : struct xfrm_selector sel;
161 : : struct xfrm_mark mark;
162 : : u32 if_id;
163 : : u32 tfcpad;
164 : :
165 : : u32 genid;
166 : :
167 : : /* Key manager bits */
168 : : struct xfrm_state_walk km;
169 : :
170 : : /* Parameters of this state. */
171 : : struct {
172 : : u32 reqid;
173 : : u8 mode;
174 : : u8 replay_window;
175 : : u8 aalgo, ealgo, calgo;
176 : : u8 flags;
177 : : u16 family;
178 : : xfrm_address_t saddr;
179 : : int header_len;
180 : : int trailer_len;
181 : : u32 extra_flags;
182 : : struct xfrm_mark smark;
183 : : } props;
184 : :
185 : : struct xfrm_lifetime_cfg lft;
186 : :
187 : : /* Data for transformer */
188 : : struct xfrm_algo_auth *aalg;
189 : : struct xfrm_algo *ealg;
190 : : struct xfrm_algo *calg;
191 : : struct xfrm_algo_aead *aead;
192 : : const char *geniv;
193 : :
194 : : /* Data for encapsulator */
195 : : struct xfrm_encap_tmpl *encap;
196 : :
197 : : /* Data for care-of address */
198 : : xfrm_address_t *coaddr;
199 : :
200 : : /* IPComp needs an IPIP tunnel for handling uncompressed packets */
201 : : struct xfrm_state *tunnel;
202 : :
203 : : /* If a tunnel, number of users + 1 */
204 : : atomic_t tunnel_users;
205 : :
206 : : /* State for replay detection */
207 : : struct xfrm_replay_state replay;
208 : : struct xfrm_replay_state_esn *replay_esn;
209 : :
210 : : /* Replay detection state at the time we sent the last notification */
211 : : struct xfrm_replay_state preplay;
212 : : struct xfrm_replay_state_esn *preplay_esn;
213 : :
214 : : /* The functions for replay detection. */
215 : : const struct xfrm_replay *repl;
216 : :
217 : : /* internal flag that only holds state for delayed aevent at the
218 : : * moment
219 : : */
220 : : u32 xflags;
221 : :
222 : : /* Replay detection notification settings */
223 : : u32 replay_maxage;
224 : : u32 replay_maxdiff;
225 : :
226 : : /* Replay detection notification timer */
227 : : struct timer_list rtimer;
228 : :
229 : : /* Statistics */
230 : : struct xfrm_stats stats;
231 : :
232 : : struct xfrm_lifetime_cur curlft;
233 : : struct hrtimer mtimer;
234 : :
235 : : struct xfrm_state_offload xso;
236 : :
237 : : /* used to fix curlft->add_time when changing date */
238 : : long saved_tmo;
239 : :
240 : : /* Last used time */
241 : : time64_t lastused;
242 : :
243 : : struct page_frag xfrag;
244 : :
245 : : /* Reference to data common to all the instances of this
246 : : * transformer. */
247 : : const struct xfrm_type *type;
248 : : struct xfrm_mode inner_mode;
249 : : struct xfrm_mode inner_mode_iaf;
250 : : struct xfrm_mode outer_mode;
251 : :
252 : : const struct xfrm_type_offload *type_offload;
253 : :
254 : : /* Security context */
255 : : struct xfrm_sec_ctx *security;
256 : :
257 : : /* Private data of this transformer, format is opaque,
258 : : * interpreted by xfrm_type methods. */
259 : : void *data;
260 : : };
261 : :
262 : : static inline struct net *xs_net(struct xfrm_state *x)
263 : : {
264 : : return read_pnet(&x->xs_net);
265 : : }
266 : :
267 : : /* xflags - make enum if more show up */
268 : : #define XFRM_TIME_DEFER 1
269 : : #define XFRM_SOFT_EXPIRE 2
270 : :
271 : : enum {
272 : : XFRM_STATE_VOID,
273 : : XFRM_STATE_ACQ,
274 : : XFRM_STATE_VALID,
275 : : XFRM_STATE_ERROR,
276 : : XFRM_STATE_EXPIRED,
277 : : XFRM_STATE_DEAD
278 : : };
279 : :
280 : : /* callback structure passed from either netlink or pfkey */
281 : : struct km_event {
282 : : union {
283 : : u32 hard;
284 : : u32 proto;
285 : : u32 byid;
286 : : u32 aevent;
287 : : u32 type;
288 : : } data;
289 : :
290 : : u32 seq;
291 : : u32 portid;
292 : : u32 event;
293 : : struct net *net;
294 : : };
295 : :
296 : : struct xfrm_replay {
297 : : void (*advance)(struct xfrm_state *x, __be32 net_seq);
298 : : int (*check)(struct xfrm_state *x,
299 : : struct sk_buff *skb,
300 : : __be32 net_seq);
301 : : int (*recheck)(struct xfrm_state *x,
302 : : struct sk_buff *skb,
303 : : __be32 net_seq);
304 : : void (*notify)(struct xfrm_state *x, int event);
305 : : int (*overflow)(struct xfrm_state *x, struct sk_buff *skb);
306 : : };
307 : :
308 : : struct xfrm_if_cb {
309 : : struct xfrm_if *(*decode_session)(struct sk_buff *skb,
310 : : unsigned short family);
311 : : };
312 : :
313 : : void xfrm_if_register_cb(const struct xfrm_if_cb *ifcb);
314 : : void xfrm_if_unregister_cb(void);
315 : :
316 : : struct net_device;
317 : : struct xfrm_type;
318 : : struct xfrm_dst;
319 : : struct xfrm_policy_afinfo {
320 : : struct dst_ops *dst_ops;
321 : : struct dst_entry *(*dst_lookup)(struct net *net,
322 : : int tos, int oif,
323 : : const xfrm_address_t *saddr,
324 : : const xfrm_address_t *daddr,
325 : : u32 mark);
326 : : int (*get_saddr)(struct net *net, int oif,
327 : : xfrm_address_t *saddr,
328 : : xfrm_address_t *daddr,
329 : : u32 mark);
330 : : int (*fill_dst)(struct xfrm_dst *xdst,
331 : : struct net_device *dev,
332 : : const struct flowi *fl);
333 : : struct dst_entry *(*blackhole_route)(struct net *net, struct dst_entry *orig);
334 : : };
335 : :
336 : : int xfrm_policy_register_afinfo(const struct xfrm_policy_afinfo *afinfo, int family);
337 : : void xfrm_policy_unregister_afinfo(const struct xfrm_policy_afinfo *afinfo);
338 : : void km_policy_notify(struct xfrm_policy *xp, int dir,
339 : : const struct km_event *c);
340 : : void km_state_notify(struct xfrm_state *x, const struct km_event *c);
341 : :
342 : : struct xfrm_tmpl;
343 : : int km_query(struct xfrm_state *x, struct xfrm_tmpl *t,
344 : : struct xfrm_policy *pol);
345 : : void km_state_expired(struct xfrm_state *x, int hard, u32 portid);
346 : : int __xfrm_state_delete(struct xfrm_state *x);
347 : :
348 : : struct xfrm_state_afinfo {
349 : : u8 family;
350 : : u8 proto;
351 : :
352 : : const struct xfrm_type_offload *type_offload_esp;
353 : :
354 : : const struct xfrm_type *type_esp;
355 : : const struct xfrm_type *type_ipip;
356 : : const struct xfrm_type *type_ipip6;
357 : : const struct xfrm_type *type_comp;
358 : : const struct xfrm_type *type_ah;
359 : : const struct xfrm_type *type_routing;
360 : : const struct xfrm_type *type_dstopts;
361 : :
362 : : int (*output)(struct net *net, struct sock *sk, struct sk_buff *skb);
363 : : int (*output_finish)(struct sock *sk, struct sk_buff *skb);
364 : : int (*extract_input)(struct xfrm_state *x,
365 : : struct sk_buff *skb);
366 : : int (*extract_output)(struct xfrm_state *x,
367 : : struct sk_buff *skb);
368 : : int (*transport_finish)(struct sk_buff *skb,
369 : : int async);
370 : : void (*local_error)(struct sk_buff *skb, u32 mtu);
371 : : };
372 : :
373 : : int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo);
374 : : int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo);
375 : : struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned int family);
376 : : struct xfrm_state_afinfo *xfrm_state_afinfo_get_rcu(unsigned int family);
377 : :
378 : : struct xfrm_input_afinfo {
379 : : unsigned int family;
380 : : int (*callback)(struct sk_buff *skb, u8 protocol,
381 : : int err);
382 : : };
383 : :
384 : : int xfrm_input_register_afinfo(const struct xfrm_input_afinfo *afinfo);
385 : : int xfrm_input_unregister_afinfo(const struct xfrm_input_afinfo *afinfo);
386 : :
387 : : void xfrm_flush_gc(void);
388 : : void xfrm_state_delete_tunnel(struct xfrm_state *x);
389 : :
390 : : struct xfrm_type {
391 : : char *description;
392 : : struct module *owner;
393 : : u8 proto;
394 : : u8 flags;
395 : : #define XFRM_TYPE_NON_FRAGMENT 1
396 : : #define XFRM_TYPE_REPLAY_PROT 2
397 : : #define XFRM_TYPE_LOCAL_COADDR 4
398 : : #define XFRM_TYPE_REMOTE_COADDR 8
399 : :
400 : : int (*init_state)(struct xfrm_state *x);
401 : : void (*destructor)(struct xfrm_state *);
402 : : int (*input)(struct xfrm_state *, struct sk_buff *skb);
403 : : int (*output)(struct xfrm_state *, struct sk_buff *pskb);
404 : : int (*reject)(struct xfrm_state *, struct sk_buff *,
405 : : const struct flowi *);
406 : : int (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);
407 : : };
408 : :
409 : : int xfrm_register_type(const struct xfrm_type *type, unsigned short family);
410 : : void xfrm_unregister_type(const struct xfrm_type *type, unsigned short family);
411 : :
412 : : struct xfrm_type_offload {
413 : : char *description;
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 : :
421 : : int xfrm_register_type_offload(const struct xfrm_type_offload *type, unsigned short family);
422 : : void xfrm_unregister_type_offload(const struct xfrm_type_offload *type, unsigned short family);
423 : :
424 : : static inline int xfrm_af2proto(unsigned int family)
425 : : {
426 : 0 : 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 : :
436 : : static inline const struct xfrm_mode *xfrm_ip2inner_mode(struct xfrm_state *x, int ipproto)
437 : : {
438 : 0 : if ((ipproto == IPPROTO_IPIP && x->props.family == AF_INET) ||
439 : 0 : (ipproto == IPPROTO_IPV6 && x->props.family == AF_INET6))
440 : 0 : return &x->inner_mode;
441 : : else
442 : 0 : return &x->inner_mode_iaf;
443 : : }
444 : :
445 : : struct 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 : :
482 : : struct xfrm_policy_walk_entry {
483 : : struct list_head all;
484 : : u8 dead;
485 : : };
486 : :
487 : : struct xfrm_policy_walk {
488 : : struct xfrm_policy_walk_entry walk;
489 : : u8 type;
490 : : u32 seq;
491 : : };
492 : :
493 : : struct xfrm_policy_queue {
494 : : struct sk_buff_head hold_queue;
495 : : struct timer_list hold_timer;
496 : : unsigned long timeout;
497 : : };
498 : :
499 : : struct 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 : :
532 : : static inline struct net *xp_net(const struct xfrm_policy *xp)
533 : : {
534 : : return read_pnet(&xp->xp_net);
535 : : }
536 : :
537 : : struct xfrm_kmaddress {
538 : : xfrm_address_t local;
539 : : xfrm_address_t remote;
540 : : u32 reserved;
541 : : u16 family;
542 : : };
543 : :
544 : : struct 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 : :
569 : : struct 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 : :
586 : : int xfrm_register_km(struct xfrm_mgr *km);
587 : : int xfrm_unregister_km(struct xfrm_mgr *km);
588 : :
589 : : struct 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 : : */
608 : : struct 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 : : */
630 : : struct 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 : : */
662 : : struct 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
673 : 0 : static inline struct audit_buffer *xfrm_audit_start(const char *op)
674 : : {
675 : : struct audit_buffer *audit_buf = NULL;
676 : :
677 : 0 : if (audit_enabled == AUDIT_OFF)
678 : : return NULL;
679 : 0 : audit_buf = audit_log_start(audit_context(), GFP_ATOMIC,
680 : : AUDIT_MAC_IPSEC_EVENT);
681 : 0 : if (audit_buf == NULL)
682 : : return NULL;
683 : 0 : audit_log_format(audit_buf, "op=%s", op);
684 : 0 : return audit_buf;
685 : : }
686 : :
687 : 0 : static inline void xfrm_audit_helper_usrinfo(bool task_valid,
688 : : struct audit_buffer *audit_buf)
689 : : {
690 : 0 : const unsigned int auid = from_kuid(&init_user_ns, task_valid ?
691 : 0 : audit_get_loginuid(current) :
692 : : INVALID_UID);
693 : 0 : const unsigned int ses = task_valid ? audit_get_sessionid(current) :
694 : : AUDIT_SID_UNSET;
695 : :
696 : 0 : audit_log_format(audit_buf, " auid=%u ses=%u", auid, ses);
697 : 0 : audit_log_task_context(audit_buf);
698 : 0 : }
699 : :
700 : : void xfrm_audit_policy_add(struct xfrm_policy *xp, int result, bool task_valid);
701 : : void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
702 : : bool task_valid);
703 : : void xfrm_audit_state_add(struct xfrm_state *x, int result, bool task_valid);
704 : : void xfrm_audit_state_delete(struct xfrm_state *x, int result, bool task_valid);
705 : : void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
706 : : struct sk_buff *skb);
707 : : void xfrm_audit_state_replay(struct xfrm_state *x, struct sk_buff *skb,
708 : : __be32 net_seq);
709 : : void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family);
710 : : void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family, __be32 net_spi,
711 : : __be32 net_seq);
712 : : void xfrm_audit_state_icvfail(struct xfrm_state *x, struct sk_buff *skb,
713 : : u8 proto);
714 : : #else
715 : :
716 : : static inline void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
717 : : bool task_valid)
718 : : {
719 : : }
720 : :
721 : : static inline void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
722 : : bool task_valid)
723 : : {
724 : : }
725 : :
726 : : static inline void xfrm_audit_state_add(struct xfrm_state *x, int result,
727 : : bool task_valid)
728 : : {
729 : : }
730 : :
731 : : static inline void xfrm_audit_state_delete(struct xfrm_state *x, int result,
732 : : bool task_valid)
733 : : {
734 : : }
735 : :
736 : : static inline void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
737 : : struct sk_buff *skb)
738 : : {
739 : : }
740 : :
741 : : static inline void xfrm_audit_state_replay(struct xfrm_state *x,
742 : : struct sk_buff *skb, __be32 net_seq)
743 : : {
744 : : }
745 : :
746 : : static inline void xfrm_audit_state_notfound_simple(struct sk_buff *skb,
747 : : u16 family)
748 : : {
749 : : }
750 : :
751 : : static inline void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
752 : : __be32 net_spi, __be32 net_seq)
753 : : {
754 : : }
755 : :
756 : : static inline void xfrm_audit_state_icvfail(struct xfrm_state *x,
757 : : struct sk_buff *skb, u8 proto)
758 : : {
759 : : }
760 : : #endif /* CONFIG_AUDITSYSCALL */
761 : :
762 : : static inline void xfrm_pol_hold(struct xfrm_policy *policy)
763 : : {
764 : 0 : if (likely(policy != NULL))
765 : 0 : refcount_inc(&policy->refcnt);
766 : : }
767 : :
768 : : void xfrm_policy_destroy(struct xfrm_policy *policy);
769 : :
770 : 0 : static inline void xfrm_pol_put(struct xfrm_policy *policy)
771 : : {
772 : 0 : if (refcount_dec_and_test(&policy->refcnt))
773 : 0 : xfrm_policy_destroy(policy);
774 : 0 : }
775 : :
776 : 3 : static inline void xfrm_pols_put(struct xfrm_policy **pols, int npols)
777 : : {
778 : : int i;
779 : 3 : for (i = npols - 1; i >= 0; --i)
780 : 0 : xfrm_pol_put(pols[i]);
781 : 3 : }
782 : :
783 : : void __xfrm_state_destroy(struct xfrm_state *, bool);
784 : :
785 : : static inline void __xfrm_state_put(struct xfrm_state *x)
786 : : {
787 : 0 : refcount_dec(&x->refcnt);
788 : : }
789 : :
790 : 0 : static inline void xfrm_state_put(struct xfrm_state *x)
791 : : {
792 : 0 : if (refcount_dec_and_test(&x->refcnt))
793 : 0 : __xfrm_state_destroy(x, false);
794 : 0 : }
795 : :
796 : 0 : static inline void xfrm_state_put_sync(struct xfrm_state *x)
797 : : {
798 : 0 : if (refcount_dec_and_test(&x->refcnt))
799 : 0 : __xfrm_state_destroy(x, true);
800 : 0 : }
801 : :
802 : : static inline void xfrm_state_hold(struct xfrm_state *x)
803 : : {
804 : 0 : refcount_inc(&x->refcnt);
805 : : }
806 : :
807 : 0 : static 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 : 0 : pdw = prefixlen >> 5; /* num of whole u32 in prefix */
816 : 0 : pbi = prefixlen & 0x1f; /* num of bits in incomplete u32 in prefix */
817 : :
818 : 0 : if (pdw)
819 : 0 : if (memcmp(a1, a2, pdw << 2))
820 : : return false;
821 : :
822 : 0 : if (pbi) {
823 : : __be32 mask;
824 : :
825 : 0 : mask = htonl((0xffffffff) << (32 - pbi));
826 : :
827 : 0 : if ((a1[pdw] ^ a2[pdw]) & mask)
828 : : return false;
829 : : }
830 : :
831 : 0 : return true;
832 : : }
833 : :
834 : : static inline bool addr4_match(__be32 a1, __be32 a2, u8 prefixlen)
835 : : {
836 : : /* C99 6.5.7 (3): u32 << 32 is undefined behaviour */
837 : 0 : if (sizeof(long) == 4 && prefixlen == 0)
838 : : return true;
839 : 0 : return !((a1 ^ a2) & htonl(~0UL << (32 - prefixlen)));
840 : : }
841 : :
842 : : static __inline__
843 : 0 : __be16 xfrm_flowi_sport(const struct flowi *fl, const union flowi_uli *uli)
844 : : {
845 : : __be16 port;
846 : 0 : switch(fl->flowi_proto) {
847 : : case IPPROTO_TCP:
848 : : case IPPROTO_UDP:
849 : : case IPPROTO_UDPLITE:
850 : : case IPPROTO_SCTP:
851 : 0 : port = uli->ports.sport;
852 : 0 : break;
853 : : case IPPROTO_ICMP:
854 : : case IPPROTO_ICMPV6:
855 : 0 : port = htons(uli->icmpt.type);
856 : 0 : break;
857 : : case IPPROTO_MH:
858 : 0 : port = htons(uli->mht.type);
859 : 0 : break;
860 : : case IPPROTO_GRE:
861 : 0 : port = htons(ntohl(uli->gre_key) >> 16);
862 : 0 : break;
863 : : default:
864 : : port = 0; /*XXX*/
865 : : }
866 : 0 : return port;
867 : : }
868 : :
869 : : static __inline__
870 : 0 : __be16 xfrm_flowi_dport(const struct flowi *fl, const union flowi_uli *uli)
871 : : {
872 : : __be16 port;
873 : 0 : switch(fl->flowi_proto) {
874 : : case IPPROTO_TCP:
875 : : case IPPROTO_UDP:
876 : : case IPPROTO_UDPLITE:
877 : : case IPPROTO_SCTP:
878 : 0 : port = uli->ports.dport;
879 : 0 : break;
880 : : case IPPROTO_ICMP:
881 : : case IPPROTO_ICMPV6:
882 : 0 : port = htons(uli->icmpt.code);
883 : 0 : break;
884 : : case IPPROTO_GRE:
885 : 0 : port = htons(ntohl(uli->gre_key) & 0xffff);
886 : 0 : break;
887 : : default:
888 : : port = 0; /*XXX*/
889 : : }
890 : 0 : return port;
891 : : }
892 : :
893 : : bool 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 : : */
900 : : static 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
909 : : static 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 : : */
926 : : struct 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 : :
945 : : static inline struct dst_entry *xfrm_dst_path(const struct dst_entry *dst)
946 : : {
947 : : #ifdef CONFIG_XFRM
948 : 3 : if (dst->xfrm || (dst->flags & DST_XFRM_QUEUE)) {
949 : : const struct xfrm_dst *xdst = (const struct xfrm_dst *) dst;
950 : :
951 : 0 : return xdst->path;
952 : : }
953 : : #endif
954 : : return (struct dst_entry *) dst;
955 : : }
956 : :
957 : : static inline struct dst_entry *xfrm_dst_child(const struct dst_entry *dst)
958 : : {
959 : : #ifdef CONFIG_XFRM
960 : 0 : if (dst->xfrm || (dst->flags & DST_XFRM_QUEUE)) {
961 : : struct xfrm_dst *xdst = (struct xfrm_dst *) dst;
962 : 0 : return xdst->child;
963 : : }
964 : : #endif
965 : : return NULL;
966 : : }
967 : :
968 : : #ifdef CONFIG_XFRM
969 : : static inline void xfrm_dst_set_child(struct xfrm_dst *xdst, struct dst_entry *child)
970 : : {
971 : 0 : xdst->child = child;
972 : : }
973 : :
974 : 0 : static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
975 : : {
976 : 0 : xfrm_pols_put(xdst->pols, xdst->num_pols);
977 : 0 : dst_release(xdst->route);
978 : 0 : if (likely(xdst->u.dst.xfrm))
979 : 0 : xfrm_state_put(xdst->u.dst.xfrm);
980 : 0 : }
981 : : #endif
982 : :
983 : : void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
984 : :
985 : : struct xfrm_if_parms {
986 : : int link; /* ifindex of underlying L2 interface */
987 : : u32 if_id; /* interface identifyer */
988 : : };
989 : :
990 : : struct 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 : :
999 : : struct 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 : : #define XFRM_ESP_NO_TRAILER 64
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 : : };
1029 : :
1030 : : struct sec_path {
1031 : : int len;
1032 : : int olen;
1033 : :
1034 : : struct xfrm_state *xvec[XFRM_MAX_DEPTH];
1035 : : struct xfrm_offload ovec[XFRM_MAX_OFFLOAD_DEPTH];
1036 : : };
1037 : :
1038 : : struct sec_path *secpath_set(struct sk_buff *skb);
1039 : :
1040 : : static inline void
1041 : : secpath_reset(struct sk_buff *skb)
1042 : : {
1043 : : #ifdef CONFIG_XFRM
1044 : : skb_ext_del(skb, SKB_EXT_SEC_PATH);
1045 : : #endif
1046 : : }
1047 : :
1048 : : static inline int
1049 : : xfrm_addr_any(const xfrm_address_t *addr, unsigned short family)
1050 : : {
1051 : 0 : switch (family) {
1052 : : case AF_INET:
1053 : 0 : return addr->a4 == 0;
1054 : : case AF_INET6:
1055 : 0 : return ipv6_addr_any(&addr->in6);
1056 : : }
1057 : : return 0;
1058 : : }
1059 : :
1060 : : static inline int
1061 : : __xfrm4_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
1062 : : {
1063 : 0 : return (tmpl->saddr.a4 &&
1064 : 0 : tmpl->saddr.a4 != x->props.saddr.a4);
1065 : : }
1066 : :
1067 : : static inline int
1068 : 0 : __xfrm6_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
1069 : : {
1070 : 0 : return (!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
1071 : : !ipv6_addr_equal((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
1072 : : }
1073 : :
1074 : : static inline int
1075 : 0 : xfrm_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x, unsigned short family)
1076 : : {
1077 : 0 : switch (family) {
1078 : : case AF_INET:
1079 : 0 : return __xfrm4_state_addr_cmp(tmpl, x);
1080 : : case AF_INET6:
1081 : 0 : return __xfrm6_state_addr_cmp(tmpl, x);
1082 : : }
1083 : : return !0;
1084 : : }
1085 : :
1086 : : #ifdef CONFIG_XFRM
1087 : : int __xfrm_policy_check(struct sock *, int dir, struct sk_buff *skb,
1088 : : unsigned short family);
1089 : :
1090 : 3 : static inline int __xfrm_policy_check2(struct sock *sk, int dir,
1091 : : struct sk_buff *skb,
1092 : : unsigned int family, int reverse)
1093 : : {
1094 : 3 : struct net *net = dev_net(skb->dev);
1095 : 3 : int ndir = dir | (reverse ? XFRM_POLICY_MASK + 1 : 0);
1096 : :
1097 : 3 : if (sk && sk->sk_policy[XFRM_POLICY_IN])
1098 : 0 : return __xfrm_policy_check(sk, ndir, skb, family);
1099 : :
1100 : 3 : return (!net->xfrm.policy_count[dir] && !secpath_exists(skb)) ||
1101 : 3 : (skb_dst(skb)->flags & DST_NOPOLICY) ||
1102 : 0 : __xfrm_policy_check(sk, ndir, skb, family);
1103 : : }
1104 : :
1105 : : static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
1106 : : {
1107 : 3 : return __xfrm_policy_check2(sk, dir, skb, family, 0);
1108 : : }
1109 : :
1110 : : static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1111 : : {
1112 : : return xfrm_policy_check(sk, dir, skb, AF_INET);
1113 : : }
1114 : :
1115 : : static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1116 : : {
1117 : : return xfrm_policy_check(sk, dir, skb, AF_INET6);
1118 : : }
1119 : :
1120 : : static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
1121 : : struct sk_buff *skb)
1122 : : {
1123 : 0 : return __xfrm_policy_check2(sk, dir, skb, AF_INET, 1);
1124 : : }
1125 : :
1126 : : static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
1127 : : struct sk_buff *skb)
1128 : : {
1129 : 0 : return __xfrm_policy_check2(sk, dir, skb, AF_INET6, 1);
1130 : : }
1131 : :
1132 : : int __xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
1133 : : unsigned int family, int reverse);
1134 : :
1135 : : static inline int xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
1136 : : unsigned int family)
1137 : : {
1138 : 0 : return __xfrm_decode_session(skb, fl, family, 0);
1139 : : }
1140 : :
1141 : : static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
1142 : : struct flowi *fl,
1143 : : unsigned int family)
1144 : : {
1145 : 3 : return __xfrm_decode_session(skb, fl, family, 1);
1146 : : }
1147 : :
1148 : : int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
1149 : :
1150 : 0 : static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
1151 : : {
1152 : 0 : struct net *net = dev_net(skb->dev);
1153 : :
1154 : 0 : return !net->xfrm.policy_count[XFRM_POLICY_OUT] ||
1155 : 0 : (skb_dst(skb)->flags & DST_NOXFRM) ||
1156 : 0 : __xfrm_route_forward(skb, family);
1157 : : }
1158 : :
1159 : : static inline int xfrm4_route_forward(struct sk_buff *skb)
1160 : : {
1161 : 0 : return xfrm_route_forward(skb, AF_INET);
1162 : : }
1163 : :
1164 : : static inline int xfrm6_route_forward(struct sk_buff *skb)
1165 : : {
1166 : 0 : return xfrm_route_forward(skb, AF_INET6);
1167 : : }
1168 : :
1169 : : int __xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk);
1170 : :
1171 : 0 : static inline int xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk)
1172 : : {
1173 : 0 : sk->sk_policy[0] = NULL;
1174 : 0 : sk->sk_policy[1] = NULL;
1175 : 0 : if (unlikely(osk->sk_policy[0] || osk->sk_policy[1]))
1176 : 0 : return __xfrm_sk_clone_policy(sk, osk);
1177 : : return 0;
1178 : : }
1179 : :
1180 : : int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
1181 : :
1182 : 3 : static inline void xfrm_sk_free_policy(struct sock *sk)
1183 : : {
1184 : : struct xfrm_policy *pol;
1185 : :
1186 : 3 : pol = rcu_dereference_protected(sk->sk_policy[0], 1);
1187 : 3 : if (unlikely(pol != NULL)) {
1188 : 0 : xfrm_policy_delete(pol, XFRM_POLICY_MAX);
1189 : 0 : sk->sk_policy[0] = NULL;
1190 : : }
1191 : 3 : pol = rcu_dereference_protected(sk->sk_policy[1], 1);
1192 : 3 : if (unlikely(pol != NULL)) {
1193 : 0 : xfrm_policy_delete(pol, XFRM_POLICY_MAX+1);
1194 : 0 : sk->sk_policy[1] = NULL;
1195 : : }
1196 : 3 : }
1197 : :
1198 : : #else
1199 : :
1200 : : static inline void xfrm_sk_free_policy(struct sock *sk) {}
1201 : : static inline int xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk) { return 0; }
1202 : : static inline int xfrm6_route_forward(struct sk_buff *skb) { return 1; }
1203 : : static inline int xfrm4_route_forward(struct sk_buff *skb) { return 1; }
1204 : : static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1205 : : {
1206 : : return 1;
1207 : : }
1208 : : static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1209 : : {
1210 : : return 1;
1211 : : }
1212 : : static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
1213 : : {
1214 : : return 1;
1215 : : }
1216 : : static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
1217 : : struct flowi *fl,
1218 : : unsigned int family)
1219 : : {
1220 : : return -ENOSYS;
1221 : : }
1222 : : static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
1223 : : struct sk_buff *skb)
1224 : : {
1225 : : return 1;
1226 : : }
1227 : : static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
1228 : : struct sk_buff *skb)
1229 : : {
1230 : : return 1;
1231 : : }
1232 : : #endif
1233 : :
1234 : : static __inline__
1235 : : xfrm_address_t *xfrm_flowi_daddr(const struct flowi *fl, unsigned short family)
1236 : : {
1237 : 0 : switch (family){
1238 : : case AF_INET:
1239 : 0 : return (xfrm_address_t *)&fl->u.ip4.daddr;
1240 : : case AF_INET6:
1241 : 0 : return (xfrm_address_t *)&fl->u.ip6.daddr;
1242 : : }
1243 : : return NULL;
1244 : : }
1245 : :
1246 : : static __inline__
1247 : : xfrm_address_t *xfrm_flowi_saddr(const struct flowi *fl, unsigned short family)
1248 : : {
1249 : 0 : switch (family){
1250 : : case AF_INET:
1251 : 0 : return (xfrm_address_t *)&fl->u.ip4.saddr;
1252 : : case AF_INET6:
1253 : 0 : return (xfrm_address_t *)&fl->u.ip6.saddr;
1254 : : }
1255 : : return NULL;
1256 : : }
1257 : :
1258 : : static __inline__
1259 : 0 : void xfrm_flowi_addr_get(const struct flowi *fl,
1260 : : xfrm_address_t *saddr, xfrm_address_t *daddr,
1261 : : unsigned short family)
1262 : : {
1263 : 0 : switch(family) {
1264 : : case AF_INET:
1265 : 0 : memcpy(&saddr->a4, &fl->u.ip4.saddr, sizeof(saddr->a4));
1266 : 0 : memcpy(&daddr->a4, &fl->u.ip4.daddr, sizeof(daddr->a4));
1267 : 0 : break;
1268 : : case AF_INET6:
1269 : 0 : saddr->in6 = fl->u.ip6.saddr;
1270 : 0 : daddr->in6 = fl->u.ip6.daddr;
1271 : 0 : break;
1272 : : }
1273 : 0 : }
1274 : :
1275 : : static __inline__ int
1276 : : __xfrm4_state_addr_check(const struct xfrm_state *x,
1277 : : const xfrm_address_t *daddr, const xfrm_address_t *saddr)
1278 : : {
1279 : 0 : if (daddr->a4 == x->id.daddr.a4 &&
1280 : 0 : (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
1281 : : return 1;
1282 : : return 0;
1283 : : }
1284 : :
1285 : : static __inline__ int
1286 : 0 : __xfrm6_state_addr_check(const struct xfrm_state *x,
1287 : : const xfrm_address_t *daddr, const xfrm_address_t *saddr)
1288 : : {
1289 : 0 : if (ipv6_addr_equal((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
1290 : 0 : (ipv6_addr_equal((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr) ||
1291 : 0 : ipv6_addr_any((struct in6_addr *)saddr) ||
1292 : : ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
1293 : : return 1;
1294 : 0 : return 0;
1295 : : }
1296 : :
1297 : : static __inline__ int
1298 : 0 : xfrm_state_addr_check(const struct xfrm_state *x,
1299 : : const xfrm_address_t *daddr, const xfrm_address_t *saddr,
1300 : : unsigned short family)
1301 : : {
1302 : 0 : switch (family) {
1303 : : case AF_INET:
1304 : 0 : return __xfrm4_state_addr_check(x, daddr, saddr);
1305 : : case AF_INET6:
1306 : 0 : return __xfrm6_state_addr_check(x, daddr, saddr);
1307 : : }
1308 : : return 0;
1309 : : }
1310 : :
1311 : : static __inline__ int
1312 : : xfrm_state_addr_flow_check(const struct xfrm_state *x, const struct flowi *fl,
1313 : : unsigned short family)
1314 : : {
1315 : : switch (family) {
1316 : : case AF_INET:
1317 : : return __xfrm4_state_addr_check(x,
1318 : : (const xfrm_address_t *)&fl->u.ip4.daddr,
1319 : : (const xfrm_address_t *)&fl->u.ip4.saddr);
1320 : : case AF_INET6:
1321 : : return __xfrm6_state_addr_check(x,
1322 : : (const xfrm_address_t *)&fl->u.ip6.daddr,
1323 : : (const xfrm_address_t *)&fl->u.ip6.saddr);
1324 : : }
1325 : : return 0;
1326 : : }
1327 : :
1328 : : static inline int xfrm_state_kern(const struct xfrm_state *x)
1329 : : {
1330 : : return atomic_read(&x->tunnel_users);
1331 : : }
1332 : :
1333 : : static inline bool xfrm_id_proto_valid(u8 proto)
1334 : : {
1335 : 0 : switch (proto) {
1336 : : case IPPROTO_AH:
1337 : : case IPPROTO_ESP:
1338 : : case IPPROTO_COMP:
1339 : : #if IS_ENABLED(CONFIG_IPV6)
1340 : : case IPPROTO_ROUTING:
1341 : : case IPPROTO_DSTOPTS:
1342 : : #endif
1343 : : return true;
1344 : : default:
1345 : : return false;
1346 : : }
1347 : : }
1348 : :
1349 : : /* IPSEC_PROTO_ANY only matches 3 IPsec protocols, 0 could match all. */
1350 : : static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
1351 : : {
1352 : 0 : return (!userproto || proto == userproto ||
1353 : 0 : (userproto == IPSEC_PROTO_ANY && (proto == IPPROTO_AH ||
1354 : 0 : proto == IPPROTO_ESP ||
1355 : 0 : proto == IPPROTO_COMP)));
1356 : : }
1357 : :
1358 : : /*
1359 : : * xfrm algorithm information
1360 : : */
1361 : : struct xfrm_algo_aead_info {
1362 : : char *geniv;
1363 : : u16 icv_truncbits;
1364 : : };
1365 : :
1366 : : struct xfrm_algo_auth_info {
1367 : : u16 icv_truncbits;
1368 : : u16 icv_fullbits;
1369 : : };
1370 : :
1371 : : struct xfrm_algo_encr_info {
1372 : : char *geniv;
1373 : : u16 blockbits;
1374 : : u16 defkeybits;
1375 : : };
1376 : :
1377 : : struct xfrm_algo_comp_info {
1378 : : u16 threshold;
1379 : : };
1380 : :
1381 : : struct xfrm_algo_desc {
1382 : : char *name;
1383 : : char *compat;
1384 : : u8 available:1;
1385 : : u8 pfkey_supported:1;
1386 : : union {
1387 : : struct xfrm_algo_aead_info aead;
1388 : : struct xfrm_algo_auth_info auth;
1389 : : struct xfrm_algo_encr_info encr;
1390 : : struct xfrm_algo_comp_info comp;
1391 : : } uinfo;
1392 : : struct sadb_alg desc;
1393 : : };
1394 : :
1395 : : /* XFRM protocol handlers. */
1396 : : struct xfrm4_protocol {
1397 : : int (*handler)(struct sk_buff *skb);
1398 : : int (*input_handler)(struct sk_buff *skb, int nexthdr, __be32 spi,
1399 : : int encap_type);
1400 : : int (*cb_handler)(struct sk_buff *skb, int err);
1401 : : int (*err_handler)(struct sk_buff *skb, u32 info);
1402 : :
1403 : : struct xfrm4_protocol __rcu *next;
1404 : : int priority;
1405 : : };
1406 : :
1407 : : struct xfrm6_protocol {
1408 : : int (*handler)(struct sk_buff *skb);
1409 : : int (*cb_handler)(struct sk_buff *skb, int err);
1410 : : int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
1411 : : u8 type, u8 code, int offset, __be32 info);
1412 : :
1413 : : struct xfrm6_protocol __rcu *next;
1414 : : int priority;
1415 : : };
1416 : :
1417 : : /* XFRM tunnel handlers. */
1418 : : struct xfrm_tunnel {
1419 : : int (*handler)(struct sk_buff *skb);
1420 : : int (*err_handler)(struct sk_buff *skb, u32 info);
1421 : :
1422 : : struct xfrm_tunnel __rcu *next;
1423 : : int priority;
1424 : : };
1425 : :
1426 : : struct xfrm6_tunnel {
1427 : : int (*handler)(struct sk_buff *skb);
1428 : : int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
1429 : : u8 type, u8 code, int offset, __be32 info);
1430 : : struct xfrm6_tunnel __rcu *next;
1431 : : int priority;
1432 : : };
1433 : :
1434 : : void xfrm_init(void);
1435 : : void xfrm4_init(void);
1436 : : int xfrm_state_init(struct net *net);
1437 : : void xfrm_state_fini(struct net *net);
1438 : : void xfrm4_state_init(void);
1439 : : void xfrm4_protocol_init(void);
1440 : : #ifdef CONFIG_XFRM
1441 : : int xfrm6_init(void);
1442 : : void xfrm6_fini(void);
1443 : : int xfrm6_state_init(void);
1444 : : void xfrm6_state_fini(void);
1445 : : int xfrm6_protocol_init(void);
1446 : : void xfrm6_protocol_fini(void);
1447 : : #else
1448 : : static inline int xfrm6_init(void)
1449 : : {
1450 : : return 0;
1451 : : }
1452 : : static inline void xfrm6_fini(void)
1453 : : {
1454 : : ;
1455 : : }
1456 : : #endif
1457 : :
1458 : : #ifdef CONFIG_XFRM_STATISTICS
1459 : : int xfrm_proc_init(struct net *net);
1460 : : void xfrm_proc_fini(struct net *net);
1461 : : #endif
1462 : :
1463 : : int xfrm_sysctl_init(struct net *net);
1464 : : #ifdef CONFIG_SYSCTL
1465 : : void xfrm_sysctl_fini(struct net *net);
1466 : : #else
1467 : : static inline void xfrm_sysctl_fini(struct net *net)
1468 : : {
1469 : : }
1470 : : #endif
1471 : :
1472 : : void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto,
1473 : : struct xfrm_address_filter *filter);
1474 : : int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
1475 : : int (*func)(struct xfrm_state *, int, void*), void *);
1476 : : void xfrm_state_walk_done(struct xfrm_state_walk *walk, struct net *net);
1477 : : struct xfrm_state *xfrm_state_alloc(struct net *net);
1478 : : void xfrm_state_free(struct xfrm_state *x);
1479 : : struct xfrm_state *xfrm_state_find(const xfrm_address_t *daddr,
1480 : : const xfrm_address_t *saddr,
1481 : : const struct flowi *fl,
1482 : : struct xfrm_tmpl *tmpl,
1483 : : struct xfrm_policy *pol, int *err,
1484 : : unsigned short family, u32 if_id);
1485 : : struct xfrm_state *xfrm_stateonly_find(struct net *net, u32 mark, u32 if_id,
1486 : : xfrm_address_t *daddr,
1487 : : xfrm_address_t *saddr,
1488 : : unsigned short family,
1489 : : u8 mode, u8 proto, u32 reqid);
1490 : : struct xfrm_state *xfrm_state_lookup_byspi(struct net *net, __be32 spi,
1491 : : unsigned short family);
1492 : : int xfrm_state_check_expire(struct xfrm_state *x);
1493 : : void xfrm_state_insert(struct xfrm_state *x);
1494 : : int xfrm_state_add(struct xfrm_state *x);
1495 : : int xfrm_state_update(struct xfrm_state *x);
1496 : : struct xfrm_state *xfrm_state_lookup(struct net *net, u32 mark,
1497 : : const xfrm_address_t *daddr, __be32 spi,
1498 : : u8 proto, unsigned short family);
1499 : : struct xfrm_state *xfrm_state_lookup_byaddr(struct net *net, u32 mark,
1500 : : const xfrm_address_t *daddr,
1501 : : const xfrm_address_t *saddr,
1502 : : u8 proto,
1503 : : unsigned short family);
1504 : : #ifdef CONFIG_XFRM_SUB_POLICY
1505 : : void xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,
1506 : : unsigned short family);
1507 : : void xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src, int n,
1508 : : unsigned short family);
1509 : : #else
1510 : : static inline void xfrm_tmpl_sort(struct xfrm_tmpl **d, struct xfrm_tmpl **s,
1511 : : int n, unsigned short family)
1512 : : {
1513 : : }
1514 : :
1515 : : static inline void xfrm_state_sort(struct xfrm_state **d, struct xfrm_state **s,
1516 : : int n, unsigned short family)
1517 : : {
1518 : : }
1519 : : #endif
1520 : :
1521 : : struct xfrmk_sadinfo {
1522 : : u32 sadhcnt; /* current hash bkts */
1523 : : u32 sadhmcnt; /* max allowed hash bkts */
1524 : : u32 sadcnt; /* current running count */
1525 : : };
1526 : :
1527 : : struct xfrmk_spdinfo {
1528 : : u32 incnt;
1529 : : u32 outcnt;
1530 : : u32 fwdcnt;
1531 : : u32 inscnt;
1532 : : u32 outscnt;
1533 : : u32 fwdscnt;
1534 : : u32 spdhcnt;
1535 : : u32 spdhmcnt;
1536 : : };
1537 : :
1538 : : struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq);
1539 : : int xfrm_state_delete(struct xfrm_state *x);
1540 : : int xfrm_state_flush(struct net *net, u8 proto, bool task_valid, bool sync);
1541 : : int xfrm_dev_state_flush(struct net *net, struct net_device *dev, bool task_valid);
1542 : : void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si);
1543 : : void xfrm_spd_getinfo(struct net *net, struct xfrmk_spdinfo *si);
1544 : : u32 xfrm_replay_seqhi(struct xfrm_state *x, __be32 net_seq);
1545 : : int xfrm_init_replay(struct xfrm_state *x);
1546 : : u32 xfrm_state_mtu(struct xfrm_state *x, int mtu);
1547 : : int __xfrm_init_state(struct xfrm_state *x, bool init_replay, bool offload);
1548 : : int xfrm_init_state(struct xfrm_state *x);
1549 : : int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type);
1550 : : int xfrm_input_resume(struct sk_buff *skb, int nexthdr);
1551 : : int xfrm_trans_queue(struct sk_buff *skb,
1552 : : int (*finish)(struct net *, struct sock *,
1553 : : struct sk_buff *));
1554 : : int xfrm_output_resume(struct sk_buff *skb, int err);
1555 : : int xfrm_output(struct sock *sk, struct sk_buff *skb);
1556 : :
1557 : : #if IS_ENABLED(CONFIG_NET_PKTGEN)
1558 : : int pktgen_xfrm_outer_mode_output(struct xfrm_state *x, struct sk_buff *skb);
1559 : : #endif
1560 : :
1561 : : void xfrm_local_error(struct sk_buff *skb, int mtu);
1562 : : int xfrm4_extract_header(struct sk_buff *skb);
1563 : : int xfrm4_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1564 : : int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
1565 : : int encap_type);
1566 : : int xfrm4_transport_finish(struct sk_buff *skb, int async);
1567 : : int xfrm4_rcv(struct sk_buff *skb);
1568 : : int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
1569 : :
1570 : : static inline int xfrm4_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi)
1571 : : {
1572 : 0 : XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL;
1573 : 0 : XFRM_SPI_SKB_CB(skb)->family = AF_INET;
1574 : 0 : XFRM_SPI_SKB_CB(skb)->daddroff = offsetof(struct iphdr, daddr);
1575 : 0 : return xfrm_input(skb, nexthdr, spi, 0);
1576 : : }
1577 : :
1578 : : int xfrm4_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1579 : : int xfrm4_output(struct net *net, struct sock *sk, struct sk_buff *skb);
1580 : : int xfrm4_output_finish(struct sock *sk, struct sk_buff *skb);
1581 : : int xfrm4_protocol_register(struct xfrm4_protocol *handler, unsigned char protocol);
1582 : : int xfrm4_protocol_deregister(struct xfrm4_protocol *handler, unsigned char protocol);
1583 : : int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family);
1584 : : int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family);
1585 : : void xfrm4_local_error(struct sk_buff *skb, u32 mtu);
1586 : : int xfrm6_extract_header(struct sk_buff *skb);
1587 : : int xfrm6_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1588 : : int xfrm6_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi,
1589 : : struct ip6_tnl *t);
1590 : : int xfrm6_transport_finish(struct sk_buff *skb, int async);
1591 : : int xfrm6_rcv_tnl(struct sk_buff *skb, struct ip6_tnl *t);
1592 : : int xfrm6_rcv(struct sk_buff *skb);
1593 : : int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
1594 : : xfrm_address_t *saddr, u8 proto);
1595 : : void xfrm6_local_error(struct sk_buff *skb, u32 mtu);
1596 : : int xfrm6_protocol_register(struct xfrm6_protocol *handler, unsigned char protocol);
1597 : : int xfrm6_protocol_deregister(struct xfrm6_protocol *handler, unsigned char protocol);
1598 : : int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family);
1599 : : int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family);
1600 : : __be32 xfrm6_tunnel_alloc_spi(struct net *net, xfrm_address_t *saddr);
1601 : : __be32 xfrm6_tunnel_spi_lookup(struct net *net, const xfrm_address_t *saddr);
1602 : : int xfrm6_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1603 : : int xfrm6_output(struct net *net, struct sock *sk, struct sk_buff *skb);
1604 : : int xfrm6_output_finish(struct sock *sk, struct sk_buff *skb);
1605 : : int xfrm6_find_1stfragopt(struct xfrm_state *x, struct sk_buff *skb,
1606 : : u8 **prevhdr);
1607 : :
1608 : : #ifdef CONFIG_XFRM
1609 : : int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
1610 : : int xfrm_user_policy(struct sock *sk, int optname,
1611 : : u8 __user *optval, int optlen);
1612 : : #else
1613 : : static inline int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
1614 : : {
1615 : : return -ENOPROTOOPT;
1616 : : }
1617 : :
1618 : : static inline int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb)
1619 : : {
1620 : : /* should not happen */
1621 : : kfree_skb(skb);
1622 : : return 0;
1623 : : }
1624 : : #endif
1625 : :
1626 : : struct dst_entry *__xfrm_dst_lookup(struct net *net, int tos, int oif,
1627 : : const xfrm_address_t *saddr,
1628 : : const xfrm_address_t *daddr,
1629 : : int family, u32 mark);
1630 : :
1631 : : struct xfrm_policy *xfrm_policy_alloc(struct net *net, gfp_t gfp);
1632 : :
1633 : : void xfrm_policy_walk_init(struct xfrm_policy_walk *walk, u8 type);
1634 : : int xfrm_policy_walk(struct net *net, struct xfrm_policy_walk *walk,
1635 : : int (*func)(struct xfrm_policy *, int, int, void*),
1636 : : void *);
1637 : : void xfrm_policy_walk_done(struct xfrm_policy_walk *walk, struct net *net);
1638 : : int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
1639 : : struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net,
1640 : : const struct xfrm_mark *mark,
1641 : : u32 if_id, u8 type, int dir,
1642 : : struct xfrm_selector *sel,
1643 : : struct xfrm_sec_ctx *ctx, int delete,
1644 : : int *err);
1645 : : struct xfrm_policy *xfrm_policy_byid(struct net *net,
1646 : : const struct xfrm_mark *mark, u32 if_id,
1647 : : u8 type, int dir, u32 id, int delete,
1648 : : int *err);
1649 : : int xfrm_policy_flush(struct net *net, u8 type, bool task_valid);
1650 : : void xfrm_policy_hash_rebuild(struct net *net);
1651 : : u32 xfrm_get_acqseq(void);
1652 : : int verify_spi_info(u8 proto, u32 min, u32 max);
1653 : : int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
1654 : : struct xfrm_state *xfrm_find_acq(struct net *net, const struct xfrm_mark *mark,
1655 : : u8 mode, u32 reqid, u32 if_id, u8 proto,
1656 : : const xfrm_address_t *daddr,
1657 : : const xfrm_address_t *saddr, int create,
1658 : : unsigned short family);
1659 : : int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
1660 : :
1661 : : #ifdef CONFIG_XFRM_MIGRATE
1662 : : int km_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
1663 : : const struct xfrm_migrate *m, int num_bundles,
1664 : : const struct xfrm_kmaddress *k,
1665 : : const struct xfrm_encap_tmpl *encap);
1666 : : struct xfrm_state *xfrm_migrate_state_find(struct xfrm_migrate *m, struct net *net);
1667 : : struct xfrm_state *xfrm_state_migrate(struct xfrm_state *x,
1668 : : struct xfrm_migrate *m,
1669 : : struct xfrm_encap_tmpl *encap);
1670 : : int xfrm_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
1671 : : struct xfrm_migrate *m, int num_bundles,
1672 : : struct xfrm_kmaddress *k, struct net *net,
1673 : : struct xfrm_encap_tmpl *encap);
1674 : : #endif
1675 : :
1676 : : int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
1677 : : void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 portid);
1678 : : int km_report(struct net *net, u8 proto, struct xfrm_selector *sel,
1679 : : xfrm_address_t *addr);
1680 : :
1681 : : void xfrm_input_init(void);
1682 : : int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
1683 : :
1684 : : void xfrm_probe_algs(void);
1685 : : int xfrm_count_pfkey_auth_supported(void);
1686 : : int xfrm_count_pfkey_enc_supported(void);
1687 : : struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
1688 : : struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
1689 : : struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
1690 : : struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
1691 : : struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
1692 : : struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe);
1693 : : struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe);
1694 : : struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe);
1695 : : struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len,
1696 : : int probe);
1697 : :
1698 : : static inline bool xfrm6_addr_equal(const xfrm_address_t *a,
1699 : : const xfrm_address_t *b)
1700 : : {
1701 : : return ipv6_addr_equal((const struct in6_addr *)a,
1702 : : (const struct in6_addr *)b);
1703 : : }
1704 : :
1705 : 0 : static inline bool xfrm_addr_equal(const xfrm_address_t *a,
1706 : : const xfrm_address_t *b,
1707 : : sa_family_t family)
1708 : : {
1709 : 0 : switch (family) {
1710 : : default:
1711 : : case AF_INET:
1712 : 0 : return ((__force u32)a->a4 ^ (__force u32)b->a4) == 0;
1713 : : case AF_INET6:
1714 : 0 : return xfrm6_addr_equal(a, b);
1715 : : }
1716 : : }
1717 : :
1718 : : static inline int xfrm_policy_id2dir(u32 index)
1719 : : {
1720 : 0 : return index & 7;
1721 : : }
1722 : :
1723 : : #ifdef CONFIG_XFRM
1724 : 0 : static inline int xfrm_aevent_is_on(struct net *net)
1725 : : {
1726 : : struct sock *nlsk;
1727 : : int ret = 0;
1728 : :
1729 : : rcu_read_lock();
1730 : 0 : nlsk = rcu_dereference(net->xfrm.nlsk);
1731 : 0 : if (nlsk)
1732 : 0 : ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
1733 : : rcu_read_unlock();
1734 : 0 : return ret;
1735 : : }
1736 : :
1737 : 0 : static inline int xfrm_acquire_is_on(struct net *net)
1738 : : {
1739 : : struct sock *nlsk;
1740 : : int ret = 0;
1741 : :
1742 : : rcu_read_lock();
1743 : 0 : nlsk = rcu_dereference(net->xfrm.nlsk);
1744 : 0 : if (nlsk)
1745 : 0 : ret = netlink_has_listeners(nlsk, XFRMNLGRP_ACQUIRE);
1746 : : rcu_read_unlock();
1747 : :
1748 : 0 : return ret;
1749 : : }
1750 : : #endif
1751 : :
1752 : : static inline unsigned int aead_len(struct xfrm_algo_aead *alg)
1753 : : {
1754 : 0 : return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1755 : : }
1756 : :
1757 : : static inline unsigned int xfrm_alg_len(const struct xfrm_algo *alg)
1758 : : {
1759 : 0 : return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1760 : : }
1761 : :
1762 : : static inline unsigned int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg)
1763 : : {
1764 : 0 : return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1765 : : }
1766 : :
1767 : : static inline unsigned int xfrm_replay_state_esn_len(struct xfrm_replay_state_esn *replay_esn)
1768 : : {
1769 : 0 : return sizeof(*replay_esn) + replay_esn->bmp_len * sizeof(__u32);
1770 : : }
1771 : :
1772 : : #ifdef CONFIG_XFRM_MIGRATE
1773 : : static inline int xfrm_replay_clone(struct xfrm_state *x,
1774 : : struct xfrm_state *orig)
1775 : : {
1776 : : x->replay_esn = kzalloc(xfrm_replay_state_esn_len(orig->replay_esn),
1777 : : GFP_KERNEL);
1778 : : if (!x->replay_esn)
1779 : : return -ENOMEM;
1780 : :
1781 : : x->replay_esn->bmp_len = orig->replay_esn->bmp_len;
1782 : : x->replay_esn->replay_window = orig->replay_esn->replay_window;
1783 : :
1784 : : x->preplay_esn = kmemdup(x->replay_esn,
1785 : : xfrm_replay_state_esn_len(x->replay_esn),
1786 : : GFP_KERNEL);
1787 : : if (!x->preplay_esn) {
1788 : : kfree(x->replay_esn);
1789 : : return -ENOMEM;
1790 : : }
1791 : :
1792 : : return 0;
1793 : : }
1794 : :
1795 : : static inline struct xfrm_algo_aead *xfrm_algo_aead_clone(struct xfrm_algo_aead *orig)
1796 : : {
1797 : : return kmemdup(orig, aead_len(orig), GFP_KERNEL);
1798 : : }
1799 : :
1800 : :
1801 : : static inline struct xfrm_algo *xfrm_algo_clone(struct xfrm_algo *orig)
1802 : : {
1803 : : return kmemdup(orig, xfrm_alg_len(orig), GFP_KERNEL);
1804 : : }
1805 : :
1806 : : static inline struct xfrm_algo_auth *xfrm_algo_auth_clone(struct xfrm_algo_auth *orig)
1807 : : {
1808 : : return kmemdup(orig, xfrm_alg_auth_len(orig), GFP_KERNEL);
1809 : : }
1810 : :
1811 : : static inline void xfrm_states_put(struct xfrm_state **states, int n)
1812 : : {
1813 : : int i;
1814 : : for (i = 0; i < n; i++)
1815 : : xfrm_state_put(*(states + i));
1816 : : }
1817 : :
1818 : : static inline void xfrm_states_delete(struct xfrm_state **states, int n)
1819 : : {
1820 : : int i;
1821 : : for (i = 0; i < n; i++)
1822 : : xfrm_state_delete(*(states + i));
1823 : : }
1824 : : #endif
1825 : :
1826 : : #ifdef CONFIG_XFRM
1827 : : static inline struct xfrm_state *xfrm_input_state(struct sk_buff *skb)
1828 : : {
1829 : : struct sec_path *sp = skb_sec_path(skb);
1830 : :
1831 : 0 : return sp->xvec[sp->len - 1];
1832 : : }
1833 : : #endif
1834 : :
1835 : 1 : static inline struct xfrm_offload *xfrm_offload(struct sk_buff *skb)
1836 : : {
1837 : : #ifdef CONFIG_XFRM
1838 : : struct sec_path *sp = skb_sec_path(skb);
1839 : :
1840 : 1 : if (!sp || !sp->olen || sp->len != sp->olen)
1841 : : return NULL;
1842 : :
1843 : 0 : return &sp->ovec[sp->olen - 1];
1844 : : #else
1845 : : return NULL;
1846 : : #endif
1847 : : }
1848 : :
1849 : : void __init xfrm_dev_init(void);
1850 : :
1851 : : #ifdef CONFIG_XFRM_OFFLOAD
1852 : : void xfrm_dev_resume(struct sk_buff *skb);
1853 : : void xfrm_dev_backlog(struct softnet_data *sd);
1854 : : struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again);
1855 : : int xfrm_dev_state_add(struct net *net, struct xfrm_state *x,
1856 : : struct xfrm_user_offload *xuo);
1857 : : bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x);
1858 : :
1859 : : static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
1860 : : {
1861 : : struct xfrm_state_offload *xso = &x->xso;
1862 : :
1863 : : if (xso->dev && xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn)
1864 : : xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn(x);
1865 : : }
1866 : :
1867 : : static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
1868 : : {
1869 : : struct xfrm_state *x = dst->xfrm;
1870 : : struct xfrm_dst *xdst;
1871 : :
1872 : : if (!x || !x->type_offload)
1873 : : return false;
1874 : :
1875 : : xdst = (struct xfrm_dst *) dst;
1876 : : if (!x->xso.offload_handle && !xdst->child->xfrm)
1877 : : return true;
1878 : : if (x->xso.offload_handle && (x->xso.dev == xfrm_dst_path(dst)->dev) &&
1879 : : !xdst->child->xfrm)
1880 : : return true;
1881 : :
1882 : : return false;
1883 : : }
1884 : :
1885 : : static inline void xfrm_dev_state_delete(struct xfrm_state *x)
1886 : : {
1887 : : struct xfrm_state_offload *xso = &x->xso;
1888 : :
1889 : : if (xso->dev)
1890 : : xso->dev->xfrmdev_ops->xdo_dev_state_delete(x);
1891 : : }
1892 : :
1893 : : static inline void xfrm_dev_state_free(struct xfrm_state *x)
1894 : : {
1895 : : struct xfrm_state_offload *xso = &x->xso;
1896 : : struct net_device *dev = xso->dev;
1897 : :
1898 : : if (dev && dev->xfrmdev_ops) {
1899 : : if (dev->xfrmdev_ops->xdo_dev_state_free)
1900 : : dev->xfrmdev_ops->xdo_dev_state_free(x);
1901 : : xso->dev = NULL;
1902 : : dev_put(dev);
1903 : : }
1904 : : }
1905 : : #else
1906 : : static inline void xfrm_dev_resume(struct sk_buff *skb)
1907 : : {
1908 : : }
1909 : :
1910 : : static inline void xfrm_dev_backlog(struct softnet_data *sd)
1911 : : {
1912 : : }
1913 : :
1914 : : static inline struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again)
1915 : : {
1916 : : return skb;
1917 : : }
1918 : :
1919 : : static inline int xfrm_dev_state_add(struct net *net, struct xfrm_state *x, struct xfrm_user_offload *xuo)
1920 : : {
1921 : : return 0;
1922 : : }
1923 : :
1924 : : static inline void xfrm_dev_state_delete(struct xfrm_state *x)
1925 : : {
1926 : : }
1927 : :
1928 : : static inline void xfrm_dev_state_free(struct xfrm_state *x)
1929 : : {
1930 : : }
1931 : :
1932 : : static inline bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x)
1933 : : {
1934 : : return false;
1935 : : }
1936 : :
1937 : : static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
1938 : : {
1939 : : }
1940 : :
1941 : : static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
1942 : : {
1943 : : return false;
1944 : : }
1945 : : #endif
1946 : :
1947 : 0 : static inline int xfrm_mark_get(struct nlattr **attrs, struct xfrm_mark *m)
1948 : : {
1949 : 0 : if (attrs[XFRMA_MARK])
1950 : 0 : memcpy(m, nla_data(attrs[XFRMA_MARK]), sizeof(struct xfrm_mark));
1951 : : else
1952 : 0 : m->v = m->m = 0;
1953 : :
1954 : 0 : return m->v & m->m;
1955 : : }
1956 : :
1957 : 0 : static inline int xfrm_mark_put(struct sk_buff *skb, const struct xfrm_mark *m)
1958 : : {
1959 : : int ret = 0;
1960 : :
1961 : 0 : if (m->m | m->v)
1962 : 0 : ret = nla_put(skb, XFRMA_MARK, sizeof(struct xfrm_mark), m);
1963 : 0 : return ret;
1964 : : }
1965 : :
1966 : : static inline __u32 xfrm_smark_get(__u32 mark, struct xfrm_state *x)
1967 : : {
1968 : : struct xfrm_mark *m = &x->props.smark;
1969 : :
1970 : 0 : return (m->v & m->m) | (mark & ~m->m);
1971 : : }
1972 : :
1973 : : static inline int xfrm_if_id_put(struct sk_buff *skb, __u32 if_id)
1974 : : {
1975 : : int ret = 0;
1976 : :
1977 : 0 : if (if_id)
1978 : : ret = nla_put_u32(skb, XFRMA_IF_ID, if_id);
1979 : : return ret;
1980 : : }
1981 : :
1982 : 0 : static inline int xfrm_tunnel_check(struct sk_buff *skb, struct xfrm_state *x,
1983 : : unsigned int family)
1984 : : {
1985 : : bool tunnel = false;
1986 : :
1987 : 0 : switch(family) {
1988 : : case AF_INET:
1989 : 0 : if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4)
1990 : : tunnel = true;
1991 : : break;
1992 : : case AF_INET6:
1993 : 0 : if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6)
1994 : : tunnel = true;
1995 : : break;
1996 : : }
1997 : 0 : if (tunnel && !(x->outer_mode.flags & XFRM_MODE_FLAG_TUNNEL))
1998 : : return -EINVAL;
1999 : :
2000 : 0 : return 0;
2001 : : }
2002 : : #endif /* _NET_XFRM_H */
|
