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 : : struct sock __rcu *encap_sk;
197 : :
198 : : /* Data for care-of address */
199 : : xfrm_address_t *coaddr;
200 : :
201 : : /* IPComp needs an IPIP tunnel for handling uncompressed packets */
202 : : struct xfrm_state *tunnel;
203 : :
204 : : /* If a tunnel, number of users + 1 */
205 : : atomic_t tunnel_users;
206 : :
207 : : /* State for replay detection */
208 : : struct xfrm_replay_state replay;
209 : : struct xfrm_replay_state_esn *replay_esn;
210 : :
211 : : /* Replay detection state at the time we sent the last notification */
212 : : struct xfrm_replay_state preplay;
213 : : struct xfrm_replay_state_esn *preplay_esn;
214 : :
215 : : /* The functions for replay detection. */
216 : : const struct xfrm_replay *repl;
217 : :
218 : : /* internal flag that only holds state for delayed aevent at the
219 : : * moment
220 : : */
221 : : u32 xflags;
222 : :
223 : : /* Replay detection notification settings */
224 : : u32 replay_maxage;
225 : : u32 replay_maxdiff;
226 : :
227 : : /* Replay detection notification timer */
228 : : struct timer_list rtimer;
229 : :
230 : : /* Statistics */
231 : : struct xfrm_stats stats;
232 : :
233 : : struct xfrm_lifetime_cur curlft;
234 : : struct hrtimer mtimer;
235 : :
236 : : struct xfrm_state_offload xso;
237 : :
238 : : /* used to fix curlft->add_time when changing date */
239 : : long saved_tmo;
240 : :
241 : : /* Last used time */
242 : : time64_t lastused;
243 : :
244 : : struct page_frag xfrag;
245 : :
246 : : /* Reference to data common to all the instances of this
247 : : * transformer. */
248 : : const struct xfrm_type *type;
249 : : struct xfrm_mode inner_mode;
250 : : struct xfrm_mode inner_mode_iaf;
251 : : struct xfrm_mode outer_mode;
252 : :
253 : : const struct xfrm_type_offload *type_offload;
254 : :
255 : : /* Security context */
256 : : struct xfrm_sec_ctx *security;
257 : :
258 : : /* Private data of this transformer, format is opaque,
259 : : * interpreted by xfrm_type methods. */
260 : : void *data;
261 : : };
262 : :
263 : 0 : static inline struct net *xs_net(struct xfrm_state *x)
264 : : {
265 [ # # # # : 0 : return read_pnet(&x->xs_net);
# # # # ]
266 : : }
267 : :
268 : : /* xflags - make enum if more show up */
269 : : #define XFRM_TIME_DEFER 1
270 : : #define XFRM_SOFT_EXPIRE 2
271 : :
272 : : enum {
273 : : XFRM_STATE_VOID,
274 : : XFRM_STATE_ACQ,
275 : : XFRM_STATE_VALID,
276 : : XFRM_STATE_ERROR,
277 : : XFRM_STATE_EXPIRED,
278 : : XFRM_STATE_DEAD
279 : : };
280 : :
281 : : /* callback structure passed from either netlink or pfkey */
282 : : struct km_event {
283 : : union {
284 : : u32 hard;
285 : : u32 proto;
286 : : u32 byid;
287 : : u32 aevent;
288 : : u32 type;
289 : : } data;
290 : :
291 : : u32 seq;
292 : : u32 portid;
293 : : u32 event;
294 : : struct net *net;
295 : : };
296 : :
297 : : struct xfrm_replay {
298 : : void (*advance)(struct xfrm_state *x, __be32 net_seq);
299 : : int (*check)(struct xfrm_state *x,
300 : : struct sk_buff *skb,
301 : : __be32 net_seq);
302 : : int (*recheck)(struct xfrm_state *x,
303 : : struct sk_buff *skb,
304 : : __be32 net_seq);
305 : : void (*notify)(struct xfrm_state *x, int event);
306 : : int (*overflow)(struct xfrm_state *x, struct sk_buff *skb);
307 : : };
308 : :
309 : : struct xfrm_if_cb {
310 : : struct xfrm_if *(*decode_session)(struct sk_buff *skb,
311 : : unsigned short family);
312 : : };
313 : :
314 : : void xfrm_if_register_cb(const struct xfrm_if_cb *ifcb);
315 : : void xfrm_if_unregister_cb(void);
316 : :
317 : : struct net_device;
318 : : struct xfrm_type;
319 : : struct xfrm_dst;
320 : : struct xfrm_policy_afinfo {
321 : : struct dst_ops *dst_ops;
322 : : struct dst_entry *(*dst_lookup)(struct net *net,
323 : : int tos, int oif,
324 : : const xfrm_address_t *saddr,
325 : : const xfrm_address_t *daddr,
326 : : u32 mark);
327 : : int (*get_saddr)(struct net *net, int oif,
328 : : xfrm_address_t *saddr,
329 : : xfrm_address_t *daddr,
330 : : u32 mark);
331 : : int (*fill_dst)(struct xfrm_dst *xdst,
332 : : struct net_device *dev,
333 : : const struct flowi *fl);
334 : : struct dst_entry *(*blackhole_route)(struct net *net, struct dst_entry *orig);
335 : : };
336 : :
337 : : int xfrm_policy_register_afinfo(const struct xfrm_policy_afinfo *afinfo, int family);
338 : : void xfrm_policy_unregister_afinfo(const struct xfrm_policy_afinfo *afinfo);
339 : : void km_policy_notify(struct xfrm_policy *xp, int dir,
340 : : const struct km_event *c);
341 : : void km_state_notify(struct xfrm_state *x, const struct km_event *c);
342 : :
343 : : struct xfrm_tmpl;
344 : : int km_query(struct xfrm_state *x, struct xfrm_tmpl *t,
345 : : struct xfrm_policy *pol);
346 : : void km_state_expired(struct xfrm_state *x, int hard, u32 portid);
347 : : int __xfrm_state_delete(struct xfrm_state *x);
348 : :
349 : : struct xfrm_state_afinfo {
350 : : u8 family;
351 : : u8 proto;
352 : :
353 : : const struct xfrm_type_offload *type_offload_esp;
354 : :
355 : : const struct xfrm_type *type_esp;
356 : : const struct xfrm_type *type_ipip;
357 : : const struct xfrm_type *type_ipip6;
358 : : const struct xfrm_type *type_comp;
359 : : const struct xfrm_type *type_ah;
360 : : const struct xfrm_type *type_routing;
361 : : const struct xfrm_type *type_dstopts;
362 : :
363 : : int (*output)(struct net *net, struct sock *sk, struct sk_buff *skb);
364 : : int (*output_finish)(struct sock *sk, struct sk_buff *skb);
365 : : int (*extract_input)(struct xfrm_state *x,
366 : : struct sk_buff *skb);
367 : : int (*extract_output)(struct xfrm_state *x,
368 : : struct sk_buff *skb);
369 : : int (*transport_finish)(struct sk_buff *skb,
370 : : int async);
371 : : void (*local_error)(struct sk_buff *skb, u32 mtu);
372 : : };
373 : :
374 : : int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo);
375 : : int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo);
376 : : struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned int family);
377 : : struct xfrm_state_afinfo *xfrm_state_afinfo_get_rcu(unsigned int family);
378 : :
379 : : struct xfrm_input_afinfo {
380 : : unsigned int family;
381 : : int (*callback)(struct sk_buff *skb, u8 protocol,
382 : : int err);
383 : : };
384 : :
385 : : int xfrm_input_register_afinfo(const struct xfrm_input_afinfo *afinfo);
386 : : int xfrm_input_unregister_afinfo(const struct xfrm_input_afinfo *afinfo);
387 : :
388 : : void xfrm_flush_gc(void);
389 : : void xfrm_state_delete_tunnel(struct xfrm_state *x);
390 : :
391 : : struct xfrm_type {
392 : : char *description;
393 : : struct module *owner;
394 : : u8 proto;
395 : : u8 flags;
396 : : #define XFRM_TYPE_NON_FRAGMENT 1
397 : : #define XFRM_TYPE_REPLAY_PROT 2
398 : : #define XFRM_TYPE_LOCAL_COADDR 4
399 : : #define XFRM_TYPE_REMOTE_COADDR 8
400 : :
401 : : int (*init_state)(struct xfrm_state *x);
402 : : void (*destructor)(struct xfrm_state *);
403 : : int (*input)(struct xfrm_state *, struct sk_buff *skb);
404 : : int (*output)(struct xfrm_state *, struct sk_buff *pskb);
405 : : int (*reject)(struct xfrm_state *, struct sk_buff *,
406 : : const struct flowi *);
407 : : int (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);
408 : : };
409 : :
410 : : int xfrm_register_type(const struct xfrm_type *type, unsigned short family);
411 : : void xfrm_unregister_type(const struct xfrm_type *type, unsigned short family);
412 : :
413 : : struct xfrm_type_offload {
414 : : char *description;
415 : : struct module *owner;
416 : : u8 proto;
417 : : void (*encap)(struct xfrm_state *, struct sk_buff *pskb);
418 : : int (*input_tail)(struct xfrm_state *x, struct sk_buff *skb);
419 : : int (*xmit)(struct xfrm_state *, struct sk_buff *pskb, netdev_features_t features);
420 : : };
421 : :
422 : : int xfrm_register_type_offload(const struct xfrm_type_offload *type, unsigned short family);
423 : : void xfrm_unregister_type_offload(const struct xfrm_type_offload *type, unsigned short family);
424 : :
425 : 0 : static inline int xfrm_af2proto(unsigned int family)
426 : : {
427 [ # # # # : 0 : switch(family) {
# # # #
# ]
428 : : case AF_INET:
429 : : return IPPROTO_IPIP;
430 : 0 : case AF_INET6:
431 : 0 : return IPPROTO_IPV6;
432 : 0 : default:
433 : 0 : return 0;
434 : : }
435 : : }
436 : :
437 : 0 : static inline const struct xfrm_mode *xfrm_ip2inner_mode(struct xfrm_state *x, int ipproto)
438 : : {
439 [ # # # # : 0 : if ((ipproto == IPPROTO_IPIP && x->props.family == AF_INET) ||
# # # # #
# # # ]
440 [ # # # # ]: 0 : (ipproto == IPPROTO_IPV6 && x->props.family == AF_INET6))
441 : 0 : return &x->inner_mode;
442 : : else
443 : 0 : return &x->inner_mode_iaf;
444 : : }
445 : :
446 : : struct xfrm_tmpl {
447 : : /* id in template is interpreted as:
448 : : * daddr - destination of tunnel, may be zero for transport mode.
449 : : * spi - zero to acquire spi. Not zero if spi is static, then
450 : : * daddr must be fixed too.
451 : : * proto - AH/ESP/IPCOMP
452 : : */
453 : : struct xfrm_id id;
454 : :
455 : : /* Source address of tunnel. Ignored, if it is not a tunnel. */
456 : : xfrm_address_t saddr;
457 : :
458 : : unsigned short encap_family;
459 : :
460 : : u32 reqid;
461 : :
462 : : /* Mode: transport, tunnel etc. */
463 : : u8 mode;
464 : :
465 : : /* Sharing mode: unique, this session only, this user only etc. */
466 : : u8 share;
467 : :
468 : : /* May skip this transfomration if no SA is found */
469 : : u8 optional;
470 : :
471 : : /* Skip aalgos/ealgos/calgos checks. */
472 : : u8 allalgs;
473 : :
474 : : /* Bit mask of algos allowed for acquisition */
475 : : u32 aalgos;
476 : : u32 ealgos;
477 : : u32 calgos;
478 : : };
479 : :
480 : : #define XFRM_MAX_DEPTH 6
481 : : #define XFRM_MAX_OFFLOAD_DEPTH 1
482 : :
483 : : struct xfrm_policy_walk_entry {
484 : : struct list_head all;
485 : : u8 dead;
486 : : };
487 : :
488 : : struct xfrm_policy_walk {
489 : : struct xfrm_policy_walk_entry walk;
490 : : u8 type;
491 : : u32 seq;
492 : : };
493 : :
494 : : struct xfrm_policy_queue {
495 : : struct sk_buff_head hold_queue;
496 : : struct timer_list hold_timer;
497 : : unsigned long timeout;
498 : : };
499 : :
500 : : struct xfrm_policy {
501 : : possible_net_t xp_net;
502 : : struct hlist_node bydst;
503 : : struct hlist_node byidx;
504 : :
505 : : /* This lock only affects elements except for entry. */
506 : : rwlock_t lock;
507 : : refcount_t refcnt;
508 : : u32 pos;
509 : : struct timer_list timer;
510 : :
511 : : atomic_t genid;
512 : : u32 priority;
513 : : u32 index;
514 : : u32 if_id;
515 : : struct xfrm_mark mark;
516 : : struct xfrm_selector selector;
517 : : struct xfrm_lifetime_cfg lft;
518 : : struct xfrm_lifetime_cur curlft;
519 : : struct xfrm_policy_walk_entry walk;
520 : : struct xfrm_policy_queue polq;
521 : : bool bydst_reinsert;
522 : : u8 type;
523 : : u8 action;
524 : : u8 flags;
525 : : u8 xfrm_nr;
526 : : u16 family;
527 : : struct xfrm_sec_ctx *security;
528 : : struct xfrm_tmpl xfrm_vec[XFRM_MAX_DEPTH];
529 : : struct hlist_node bydst_inexact_list;
530 : : struct rcu_head rcu;
531 : : };
532 : :
533 : 0 : static inline struct net *xp_net(const struct xfrm_policy *xp)
534 : : {
535 [ # # # # : 0 : return read_pnet(&xp->xp_net);
# # # # #
# # # #
# ]
536 : : }
537 : :
538 : : struct xfrm_kmaddress {
539 : : xfrm_address_t local;
540 : : xfrm_address_t remote;
541 : : u32 reserved;
542 : : u16 family;
543 : : };
544 : :
545 : : struct xfrm_migrate {
546 : : xfrm_address_t old_daddr;
547 : : xfrm_address_t old_saddr;
548 : : xfrm_address_t new_daddr;
549 : : xfrm_address_t new_saddr;
550 : : u8 proto;
551 : : u8 mode;
552 : : u16 reserved;
553 : : u32 reqid;
554 : : u16 old_family;
555 : : u16 new_family;
556 : : };
557 : :
558 : : #define XFRM_KM_TIMEOUT 30
559 : : /* what happened */
560 : : #define XFRM_REPLAY_UPDATE XFRM_AE_CR
561 : : #define XFRM_REPLAY_TIMEOUT XFRM_AE_CE
562 : :
563 : : /* default aevent timeout in units of 100ms */
564 : : #define XFRM_AE_ETIME 10
565 : : /* Async Event timer multiplier */
566 : : #define XFRM_AE_ETH_M 10
567 : : /* default seq threshold size */
568 : : #define XFRM_AE_SEQT_SIZE 2
569 : :
570 : : struct xfrm_mgr {
571 : : struct list_head list;
572 : : int (*notify)(struct xfrm_state *x, const struct km_event *c);
573 : : int (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp);
574 : : struct xfrm_policy *(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
575 : : int (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
576 : : int (*notify_policy)(struct xfrm_policy *x, int dir, const struct km_event *c);
577 : : int (*report)(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
578 : : int (*migrate)(const struct xfrm_selector *sel,
579 : : u8 dir, u8 type,
580 : : const struct xfrm_migrate *m,
581 : : int num_bundles,
582 : : const struct xfrm_kmaddress *k,
583 : : const struct xfrm_encap_tmpl *encap);
584 : : bool (*is_alive)(const struct km_event *c);
585 : : };
586 : :
587 : : int xfrm_register_km(struct xfrm_mgr *km);
588 : : int xfrm_unregister_km(struct xfrm_mgr *km);
589 : :
590 : : struct xfrm_tunnel_skb_cb {
591 : : union {
592 : : struct inet_skb_parm h4;
593 : : struct inet6_skb_parm h6;
594 : : } header;
595 : :
596 : : union {
597 : : struct ip_tunnel *ip4;
598 : : struct ip6_tnl *ip6;
599 : : } tunnel;
600 : : };
601 : :
602 : : #define XFRM_TUNNEL_SKB_CB(__skb) ((struct xfrm_tunnel_skb_cb *)&((__skb)->cb[0]))
603 : :
604 : : /*
605 : : * This structure is used for the duration where packets are being
606 : : * transformed by IPsec. As soon as the packet leaves IPsec the
607 : : * area beyond the generic IP part may be overwritten.
608 : : */
609 : : struct xfrm_skb_cb {
610 : : struct xfrm_tunnel_skb_cb header;
611 : :
612 : : /* Sequence number for replay protection. */
613 : : union {
614 : : struct {
615 : : __u32 low;
616 : : __u32 hi;
617 : : } output;
618 : : struct {
619 : : __be32 low;
620 : : __be32 hi;
621 : : } input;
622 : : } seq;
623 : : };
624 : :
625 : : #define XFRM_SKB_CB(__skb) ((struct xfrm_skb_cb *)&((__skb)->cb[0]))
626 : :
627 : : /*
628 : : * This structure is used by the afinfo prepare_input/prepare_output functions
629 : : * to transmit header information to the mode input/output functions.
630 : : */
631 : : struct xfrm_mode_skb_cb {
632 : : struct xfrm_tunnel_skb_cb header;
633 : :
634 : : /* Copied from header for IPv4, always set to zero and DF for IPv6. */
635 : : __be16 id;
636 : : __be16 frag_off;
637 : :
638 : : /* IP header length (excluding options or extension headers). */
639 : : u8 ihl;
640 : :
641 : : /* TOS for IPv4, class for IPv6. */
642 : : u8 tos;
643 : :
644 : : /* TTL for IPv4, hop limitfor IPv6. */
645 : : u8 ttl;
646 : :
647 : : /* Protocol for IPv4, NH for IPv6. */
648 : : u8 protocol;
649 : :
650 : : /* Option length for IPv4, zero for IPv6. */
651 : : u8 optlen;
652 : :
653 : : /* Used by IPv6 only, zero for IPv4. */
654 : : u8 flow_lbl[3];
655 : : };
656 : :
657 : : #define XFRM_MODE_SKB_CB(__skb) ((struct xfrm_mode_skb_cb *)&((__skb)->cb[0]))
658 : :
659 : : /*
660 : : * This structure is used by the input processing to locate the SPI and
661 : : * related information.
662 : : */
663 : : struct xfrm_spi_skb_cb {
664 : : struct xfrm_tunnel_skb_cb header;
665 : :
666 : : unsigned int daddroff;
667 : : unsigned int family;
668 : : __be32 seq;
669 : : };
670 : :
671 : : #define XFRM_SPI_SKB_CB(__skb) ((struct xfrm_spi_skb_cb *)&((__skb)->cb[0]))
672 : :
673 : : #ifdef CONFIG_AUDITSYSCALL
674 : 0 : static inline struct audit_buffer *xfrm_audit_start(const char *op)
675 : : {
676 : 0 : struct audit_buffer *audit_buf = NULL;
677 : :
678 [ # # ]: 0 : if (audit_enabled == AUDIT_OFF)
679 : : return NULL;
680 : 0 : audit_buf = audit_log_start(audit_context(), GFP_ATOMIC,
681 : : AUDIT_MAC_IPSEC_EVENT);
682 [ # # ]: 0 : if (audit_buf == NULL)
683 : : return NULL;
684 : 0 : audit_log_format(audit_buf, "op=%s", op);
685 : 0 : return audit_buf;
686 : : }
687 : :
688 : 0 : static inline void xfrm_audit_helper_usrinfo(bool task_valid,
689 : : struct audit_buffer *audit_buf)
690 : : {
691 [ # # ]: 0 : const unsigned int auid = from_kuid(&init_user_ns, task_valid ?
692 : : audit_get_loginuid(current) :
693 : : INVALID_UID);
694 [ # # ]: 0 : const unsigned int ses = task_valid ? audit_get_sessionid(current) :
695 : : AUDIT_SID_UNSET;
696 : :
697 : 0 : audit_log_format(audit_buf, " auid=%u ses=%u", auid, ses);
698 : 0 : audit_log_task_context(audit_buf);
699 : 0 : }
700 : :
701 : : void xfrm_audit_policy_add(struct xfrm_policy *xp, int result, bool task_valid);
702 : : void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
703 : : bool task_valid);
704 : : void xfrm_audit_state_add(struct xfrm_state *x, int result, bool task_valid);
705 : : void xfrm_audit_state_delete(struct xfrm_state *x, int result, bool task_valid);
706 : : void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
707 : : struct sk_buff *skb);
708 : : void xfrm_audit_state_replay(struct xfrm_state *x, struct sk_buff *skb,
709 : : __be32 net_seq);
710 : : void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family);
711 : : void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family, __be32 net_spi,
712 : : __be32 net_seq);
713 : : void xfrm_audit_state_icvfail(struct xfrm_state *x, struct sk_buff *skb,
714 : : u8 proto);
715 : : #else
716 : :
717 : : static inline void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
718 : : bool task_valid)
719 : : {
720 : : }
721 : :
722 : : static inline void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
723 : : bool task_valid)
724 : : {
725 : : }
726 : :
727 : : static inline void xfrm_audit_state_add(struct xfrm_state *x, int result,
728 : : bool task_valid)
729 : : {
730 : : }
731 : :
732 : : static inline void xfrm_audit_state_delete(struct xfrm_state *x, int result,
733 : : bool task_valid)
734 : : {
735 : : }
736 : :
737 : : static inline void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
738 : : struct sk_buff *skb)
739 : : {
740 : : }
741 : :
742 : : static inline void xfrm_audit_state_replay(struct xfrm_state *x,
743 : : struct sk_buff *skb, __be32 net_seq)
744 : : {
745 : : }
746 : :
747 : : static inline void xfrm_audit_state_notfound_simple(struct sk_buff *skb,
748 : : u16 family)
749 : : {
750 : : }
751 : :
752 : : static inline void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
753 : : __be32 net_spi, __be32 net_seq)
754 : : {
755 : : }
756 : :
757 : : static inline void xfrm_audit_state_icvfail(struct xfrm_state *x,
758 : : struct sk_buff *skb, u8 proto)
759 : : {
760 : : }
761 : : #endif /* CONFIG_AUDITSYSCALL */
762 : :
763 : 0 : static inline void xfrm_pol_hold(struct xfrm_policy *policy)
764 : : {
765 [ # # # # : 0 : if (likely(policy != NULL))
# # # # #
# # # ]
766 : 0 : refcount_inc(&policy->refcnt);
767 : : }
768 : :
769 : : void xfrm_policy_destroy(struct xfrm_policy *policy);
770 : :
771 : 0 : static inline void xfrm_pol_put(struct xfrm_policy *policy)
772 : : {
773 [ # # ]: 0 : if (refcount_dec_and_test(&policy->refcnt))
774 : 0 : xfrm_policy_destroy(policy);
775 : 0 : }
776 : :
777 : 52 : static inline void xfrm_pols_put(struct xfrm_policy **pols, int npols)
778 : : {
779 : 52 : int i;
780 [ - - - - : 52 : for (i = npols - 1; i >= 0; --i)
- - - + -
- - - - -
- - ]
781 : 0 : xfrm_pol_put(pols[i]);
782 : : }
783 : :
784 : : void __xfrm_state_destroy(struct xfrm_state *, bool);
785 : :
786 : 0 : static inline void __xfrm_state_put(struct xfrm_state *x)
787 : : {
788 : 0 : refcount_dec(&x->refcnt);
789 : 0 : }
790 : :
791 : 0 : static inline void xfrm_state_put(struct xfrm_state *x)
792 : : {
793 [ # # ]: 0 : if (refcount_dec_and_test(&x->refcnt))
794 : 0 : __xfrm_state_destroy(x, false);
795 : 0 : }
796 : :
797 : 0 : static inline void xfrm_state_put_sync(struct xfrm_state *x)
798 : : {
799 [ # # ]: 0 : if (refcount_dec_and_test(&x->refcnt))
800 : 0 : __xfrm_state_destroy(x, true);
801 : 0 : }
802 : :
803 : 0 : static inline void xfrm_state_hold(struct xfrm_state *x)
804 : : {
805 : 0 : refcount_inc(&x->refcnt);
806 : 0 : }
807 : :
808 : 0 : static inline bool addr_match(const void *token1, const void *token2,
809 : : unsigned int prefixlen)
810 : : {
811 : 0 : const __be32 *a1 = token1;
812 : 0 : const __be32 *a2 = token2;
813 : 0 : unsigned int pdw;
814 : 0 : unsigned int pbi;
815 : :
816 : 0 : pdw = prefixlen >> 5; /* num of whole u32 in prefix */
817 : 0 : pbi = prefixlen & 0x1f; /* num of bits in incomplete u32 in prefix */
818 : :
819 [ # # ]: 0 : if (pdw)
820 [ # # ]: 0 : if (memcmp(a1, a2, pdw << 2))
821 : : return false;
822 : :
823 [ # # ]: 0 : if (pbi) {
824 : 0 : __be32 mask;
825 : :
826 : 0 : mask = htonl((0xffffffff) << (32 - pbi));
827 : :
828 [ # # ]: 0 : if ((a1[pdw] ^ a2[pdw]) & mask)
829 : 0 : return false;
830 : : }
831 : :
832 : : return true;
833 : : }
834 : :
835 : 0 : static inline bool addr4_match(__be32 a1, __be32 a2, u8 prefixlen)
836 : : {
837 : : /* C99 6.5.7 (3): u32 << 32 is undefined behaviour */
838 : 0 : if (sizeof(long) == 4 && prefixlen == 0)
839 : : return true;
840 [ # # # # ]: 0 : return !((a1 ^ a2) & htonl(~0UL << (32 - prefixlen)));
841 : : }
842 : :
843 : : static __inline__
844 : : __be16 xfrm_flowi_sport(const struct flowi *fl, const union flowi_uli *uli)
845 : : {
846 : : __be16 port;
847 : : switch(fl->flowi_proto) {
848 : : case IPPROTO_TCP:
849 : : case IPPROTO_UDP:
850 : : case IPPROTO_UDPLITE:
851 : : case IPPROTO_SCTP:
852 : : port = uli->ports.sport;
853 : : break;
854 : : case IPPROTO_ICMP:
855 : : case IPPROTO_ICMPV6:
856 : : port = htons(uli->icmpt.type);
857 : : break;
858 : : case IPPROTO_MH:
859 : : port = htons(uli->mht.type);
860 : : break;
861 : : case IPPROTO_GRE:
862 : : port = htons(ntohl(uli->gre_key) >> 16);
863 : : break;
864 : : default:
865 : : port = 0; /*XXX*/
866 : : }
867 : : return port;
868 : : }
869 : :
870 : : static __inline__
871 : : __be16 xfrm_flowi_dport(const struct flowi *fl, const union flowi_uli *uli)
872 : : {
873 : : __be16 port;
874 : : switch(fl->flowi_proto) {
875 : : case IPPROTO_TCP:
876 : : case IPPROTO_UDP:
877 : : case IPPROTO_UDPLITE:
878 : : case IPPROTO_SCTP:
879 : : port = uli->ports.dport;
880 : : break;
881 : : case IPPROTO_ICMP:
882 : : case IPPROTO_ICMPV6:
883 : : port = htons(uli->icmpt.code);
884 : : break;
885 : : case IPPROTO_GRE:
886 : : port = htons(ntohl(uli->gre_key) & 0xffff);
887 : : break;
888 : : default:
889 : : port = 0; /*XXX*/
890 : : }
891 : : return port;
892 : : }
893 : :
894 : : bool xfrm_selector_match(const struct xfrm_selector *sel,
895 : : const struct flowi *fl, unsigned short family);
896 : :
897 : : #ifdef CONFIG_SECURITY_NETWORK_XFRM
898 : : /* If neither has a context --> match
899 : : * Otherwise, both must have a context and the sids, doi, alg must match
900 : : */
901 : : static inline bool xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
902 : : {
903 : : return ((!s1 && !s2) ||
904 : : (s1 && s2 &&
905 : : (s1->ctx_sid == s2->ctx_sid) &&
906 : : (s1->ctx_doi == s2->ctx_doi) &&
907 : : (s1->ctx_alg == s2->ctx_alg)));
908 : : }
909 : : #else
910 : 0 : static inline bool xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
911 : : {
912 [ # # # # ]: 0 : return true;
913 : : }
914 : : #endif
915 : :
916 : : /* A struct encoding bundle of transformations to apply to some set of flow.
917 : : *
918 : : * xdst->child points to the next element of bundle.
919 : : * dst->xfrm points to an instanse of transformer.
920 : : *
921 : : * Due to unfortunate limitations of current routing cache, which we
922 : : * have no time to fix, it mirrors struct rtable and bound to the same
923 : : * routing key, including saddr,daddr. However, we can have many of
924 : : * bundles differing by session id. All the bundles grow from a parent
925 : : * policy rule.
926 : : */
927 : : struct xfrm_dst {
928 : : union {
929 : : struct dst_entry dst;
930 : : struct rtable rt;
931 : : struct rt6_info rt6;
932 : : } u;
933 : : struct dst_entry *route;
934 : : struct dst_entry *child;
935 : : struct dst_entry *path;
936 : : struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX];
937 : : int num_pols, num_xfrms;
938 : : u32 xfrm_genid;
939 : : u32 policy_genid;
940 : : u32 route_mtu_cached;
941 : : u32 child_mtu_cached;
942 : : u32 route_cookie;
943 : : u32 path_cookie;
944 : : };
945 : :
946 : 0 : static inline struct dst_entry *xfrm_dst_path(const struct dst_entry *dst)
947 : : {
948 : : #ifdef CONFIG_XFRM
949 [ # # # # : 0 : if (dst->xfrm) {
# # # # #
# # # # #
# # # # ]
950 : 0 : const struct xfrm_dst *xdst = (const struct xfrm_dst *) dst;
951 : :
952 : 0 : return xdst->path;
953 : : }
954 : : #endif
955 : : return (struct dst_entry *) dst;
956 : : }
957 : :
958 : 0 : static inline struct dst_entry *xfrm_dst_child(const struct dst_entry *dst)
959 : : {
960 : : #ifdef CONFIG_XFRM
961 [ # # # # : 0 : if (dst->xfrm) {
# # # # #
# ]
962 : 0 : struct xfrm_dst *xdst = (struct xfrm_dst *) dst;
963 [ # # # # : 0 : return xdst->child;
# # ]
964 : : }
965 : : #endif
966 : : return NULL;
967 : : }
968 : :
969 : : #ifdef CONFIG_XFRM
970 : 0 : static inline void xfrm_dst_set_child(struct xfrm_dst *xdst, struct dst_entry *child)
971 : : {
972 [ # # # # ]: 0 : xdst->child = child;
973 : 0 : }
974 : :
975 : 0 : static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
976 : : {
977 : 0 : xfrm_pols_put(xdst->pols, xdst->num_pols);
978 : 0 : dst_release(xdst->route);
979 [ # # ]: 0 : if (likely(xdst->u.dst.xfrm))
980 : 0 : xfrm_state_put(xdst->u.dst.xfrm);
981 : 0 : }
982 : : #endif
983 : :
984 : : void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
985 : :
986 : : struct xfrm_if_parms {
987 : : int link; /* ifindex of underlying L2 interface */
988 : : u32 if_id; /* interface identifyer */
989 : : };
990 : :
991 : : struct xfrm_if {
992 : : struct xfrm_if __rcu *next; /* next interface in list */
993 : : struct net_device *dev; /* virtual device associated with interface */
994 : : struct net *net; /* netns for packet i/o */
995 : : struct xfrm_if_parms p; /* interface parms */
996 : :
997 : : struct gro_cells gro_cells;
998 : : };
999 : :
1000 : : struct xfrm_offload {
1001 : : /* Output sequence number for replay protection on offloading. */
1002 : : struct {
1003 : : __u32 low;
1004 : : __u32 hi;
1005 : : } seq;
1006 : :
1007 : : __u32 flags;
1008 : : #define SA_DELETE_REQ 1
1009 : : #define CRYPTO_DONE 2
1010 : : #define CRYPTO_NEXT_DONE 4
1011 : : #define CRYPTO_FALLBACK 8
1012 : : #define XFRM_GSO_SEGMENT 16
1013 : : #define XFRM_GRO 32
1014 : : #define XFRM_ESP_NO_TRAILER 64
1015 : : #define XFRM_DEV_RESUME 128
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 : 0 : secpath_reset(struct sk_buff *skb)
1042 : : {
1043 : : #ifdef CONFIG_XFRM
1044 [ # # # # : 0 : skb_ext_del(skb, SKB_EXT_SEC_PATH);
# # ]
1045 : : #endif
1046 : : }
1047 : :
1048 : : static inline int
1049 : 0 : xfrm_addr_any(const xfrm_address_t *addr, unsigned short family)
1050 : : {
1051 [ # # # # : 0 : switch (family) {
# # ]
1052 : 0 : case AF_INET:
1053 : 0 : return addr->a4 == 0;
1054 : 0 : case AF_INET6:
1055 : 0 : return ipv6_addr_any(&addr->in6);
1056 : : }
1057 : : return 0;
1058 : : }
1059 : :
1060 : : static inline int
1061 : 0 : __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 : 0 : 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 : 0 : static inline int __xfrm_policy_check2(struct sock *sk, int dir,
1091 : : struct sk_buff *skb,
1092 : : unsigned int family, int reverse)
1093 : : {
1094 [ # # ]: 0 : struct net *net = dev_net(skb->dev);
1095 [ # # ]: 0 : int ndir = dir | (reverse ? XFRM_POLICY_MASK + 1 : 0);
1096 : :
1097 [ # # # # ]: 0 : if (sk && sk->sk_policy[XFRM_POLICY_IN])
1098 : 0 : return __xfrm_policy_check(sk, ndir, skb, family);
1099 : :
1100 [ # # # # ]: 0 : return (!net->xfrm.policy_count[dir] && !secpath_exists(skb)) ||
1101 [ # # # # : 0 : (skb_dst(skb)->flags & DST_NOPOLICY) ||
# # ]
1102 : 0 : __xfrm_policy_check(sk, ndir, skb, family);
1103 : : }
1104 : :
1105 : 0 : static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
1106 : : {
1107 : 0 : return __xfrm_policy_check2(sk, dir, skb, family, 0);
1108 : : }
1109 : :
1110 : 0 : static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1111 : : {
1112 : 0 : return xfrm_policy_check(sk, dir, skb, AF_INET);
1113 : : }
1114 : :
1115 : 0 : static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1116 : : {
1117 : 0 : return xfrm_policy_check(sk, dir, skb, AF_INET6);
1118 : : }
1119 : :
1120 : 0 : 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 : 0 : 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 : 0 : 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 : 0 : static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
1142 : : struct flowi *fl,
1143 : : unsigned int family)
1144 : : {
1145 : 0 : 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 : 0 : static inline int xfrm4_route_forward(struct sk_buff *skb)
1160 : : {
1161 : 0 : return xfrm_route_forward(skb, AF_INET);
1162 : : }
1163 : :
1164 : 0 : 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 : 1146 : static inline void xfrm_sk_free_policy(struct sock *sk)
1183 : : {
1184 : 1146 : struct xfrm_policy *pol;
1185 : :
1186 : 1146 : pol = rcu_dereference_protected(sk->sk_policy[0], 1);
1187 [ - + ]: 1146 : if (unlikely(pol != NULL)) {
1188 : 0 : xfrm_policy_delete(pol, XFRM_POLICY_MAX);
1189 : 0 : sk->sk_policy[0] = NULL;
1190 : : }
1191 : 1146 : pol = rcu_dereference_protected(sk->sk_policy[1], 1);
1192 [ - + ]: 1146 : if (unlikely(pol != NULL)) {
1193 : 0 : xfrm_policy_delete(pol, XFRM_POLICY_MAX+1);
1194 : 0 : sk->sk_policy[1] = NULL;
1195 : : }
1196 : 1146 : }
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 : 0 : xfrm_address_t *xfrm_flowi_daddr(const struct flowi *fl, unsigned short family)
1236 : : {
1237 [ # # # # : 0 : switch (family){
# # ]
1238 : 0 : case AF_INET:
1239 : 0 : return (xfrm_address_t *)&fl->u.ip4.daddr;
1240 : 0 : case AF_INET6:
1241 : 0 : return (xfrm_address_t *)&fl->u.ip6.daddr;
1242 : : }
1243 : : return NULL;
1244 : : }
1245 : :
1246 : : static __inline__
1247 : 0 : xfrm_address_t *xfrm_flowi_saddr(const struct flowi *fl, unsigned short family)
1248 : : {
1249 [ # # # # : 0 : switch (family){
# # ]
1250 : 0 : case AF_INET:
1251 : 0 : return (xfrm_address_t *)&fl->u.ip4.saddr;
1252 : 0 : 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 : 0 : 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 : 0 : 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 : 0 : __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 : 0 : 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 : 0 : return 1;
1294 : : 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 : 0 : case AF_INET:
1304 [ # # ]: 0 : return __xfrm4_state_addr_check(x, daddr, saddr);
1305 : 0 : 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 : 0 : static inline int xfrm_state_kern(const struct xfrm_state *x)
1329 : : {
1330 : 0 : return atomic_read(&x->tunnel_users);
1331 : : }
1332 : :
1333 : 0 : 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 : 0 : 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_net(struct net *net, struct sk_buff *skb,
1552 : : int (*finish)(struct net *, struct sock *,
1553 : : struct sk_buff *));
1554 : : int xfrm_trans_queue(struct sk_buff *skb,
1555 : : int (*finish)(struct net *, struct sock *,
1556 : : struct sk_buff *));
1557 : : int xfrm_output_resume(struct sk_buff *skb, int err);
1558 : : int xfrm_output(struct sock *sk, struct sk_buff *skb);
1559 : :
1560 : : #if IS_ENABLED(CONFIG_NET_PKTGEN)
1561 : : int pktgen_xfrm_outer_mode_output(struct xfrm_state *x, struct sk_buff *skb);
1562 : : #endif
1563 : :
1564 : : void xfrm_local_error(struct sk_buff *skb, int mtu);
1565 : : int xfrm4_extract_header(struct sk_buff *skb);
1566 : : int xfrm4_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1567 : : int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
1568 : : int encap_type);
1569 : : int xfrm4_transport_finish(struct sk_buff *skb, int async);
1570 : : int xfrm4_rcv(struct sk_buff *skb);
1571 : : int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
1572 : :
1573 : 0 : static inline int xfrm4_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi)
1574 : : {
1575 : 0 : XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL;
1576 : 0 : XFRM_SPI_SKB_CB(skb)->family = AF_INET;
1577 : 0 : XFRM_SPI_SKB_CB(skb)->daddroff = offsetof(struct iphdr, daddr);
1578 : 0 : return xfrm_input(skb, nexthdr, spi, 0);
1579 : : }
1580 : :
1581 : : int xfrm4_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1582 : : int xfrm4_output(struct net *net, struct sock *sk, struct sk_buff *skb);
1583 : : int xfrm4_output_finish(struct sock *sk, struct sk_buff *skb);
1584 : : int xfrm4_protocol_register(struct xfrm4_protocol *handler, unsigned char protocol);
1585 : : int xfrm4_protocol_deregister(struct xfrm4_protocol *handler, unsigned char protocol);
1586 : : int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family);
1587 : : int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family);
1588 : : void xfrm4_local_error(struct sk_buff *skb, u32 mtu);
1589 : : int xfrm6_extract_header(struct sk_buff *skb);
1590 : : int xfrm6_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1591 : : int xfrm6_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi,
1592 : : struct ip6_tnl *t);
1593 : : int xfrm6_transport_finish(struct sk_buff *skb, int async);
1594 : : int xfrm6_rcv_tnl(struct sk_buff *skb, struct ip6_tnl *t);
1595 : : int xfrm6_rcv(struct sk_buff *skb);
1596 : : int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
1597 : : xfrm_address_t *saddr, u8 proto);
1598 : : void xfrm6_local_error(struct sk_buff *skb, u32 mtu);
1599 : : int xfrm6_protocol_register(struct xfrm6_protocol *handler, unsigned char protocol);
1600 : : int xfrm6_protocol_deregister(struct xfrm6_protocol *handler, unsigned char protocol);
1601 : : int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family);
1602 : : int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family);
1603 : : __be32 xfrm6_tunnel_alloc_spi(struct net *net, xfrm_address_t *saddr);
1604 : : __be32 xfrm6_tunnel_spi_lookup(struct net *net, const xfrm_address_t *saddr);
1605 : : int xfrm6_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1606 : : int xfrm6_output(struct net *net, struct sock *sk, struct sk_buff *skb);
1607 : : int xfrm6_output_finish(struct sock *sk, struct sk_buff *skb);
1608 : : int xfrm6_find_1stfragopt(struct xfrm_state *x, struct sk_buff *skb,
1609 : : u8 **prevhdr);
1610 : :
1611 : : #ifdef CONFIG_XFRM
1612 : : int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
1613 : : int xfrm_user_policy(struct sock *sk, int optname,
1614 : : u8 __user *optval, int optlen);
1615 : : #else
1616 : : static inline int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
1617 : : {
1618 : : return -ENOPROTOOPT;
1619 : : }
1620 : : #endif
1621 : :
1622 : : struct dst_entry *__xfrm_dst_lookup(struct net *net, int tos, int oif,
1623 : : const xfrm_address_t *saddr,
1624 : : const xfrm_address_t *daddr,
1625 : : int family, u32 mark);
1626 : :
1627 : : struct xfrm_policy *xfrm_policy_alloc(struct net *net, gfp_t gfp);
1628 : :
1629 : : void xfrm_policy_walk_init(struct xfrm_policy_walk *walk, u8 type);
1630 : : int xfrm_policy_walk(struct net *net, struct xfrm_policy_walk *walk,
1631 : : int (*func)(struct xfrm_policy *, int, int, void*),
1632 : : void *);
1633 : : void xfrm_policy_walk_done(struct xfrm_policy_walk *walk, struct net *net);
1634 : : int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
1635 : : struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net, u32 mark, u32 if_id,
1636 : : u8 type, int dir,
1637 : : struct xfrm_selector *sel,
1638 : : struct xfrm_sec_ctx *ctx, int delete,
1639 : : int *err);
1640 : : struct xfrm_policy *xfrm_policy_byid(struct net *net, u32 mark, u32 if_id, u8,
1641 : : int dir, u32 id, int delete, int *err);
1642 : : int xfrm_policy_flush(struct net *net, u8 type, bool task_valid);
1643 : : void xfrm_policy_hash_rebuild(struct net *net);
1644 : : u32 xfrm_get_acqseq(void);
1645 : : int verify_spi_info(u8 proto, u32 min, u32 max);
1646 : : int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
1647 : : struct xfrm_state *xfrm_find_acq(struct net *net, const struct xfrm_mark *mark,
1648 : : u8 mode, u32 reqid, u32 if_id, u8 proto,
1649 : : const xfrm_address_t *daddr,
1650 : : const xfrm_address_t *saddr, int create,
1651 : : unsigned short family);
1652 : : int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
1653 : :
1654 : : #ifdef CONFIG_XFRM_MIGRATE
1655 : : int km_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
1656 : : const struct xfrm_migrate *m, int num_bundles,
1657 : : const struct xfrm_kmaddress *k,
1658 : : const struct xfrm_encap_tmpl *encap);
1659 : : struct xfrm_state *xfrm_migrate_state_find(struct xfrm_migrate *m, struct net *net);
1660 : : struct xfrm_state *xfrm_state_migrate(struct xfrm_state *x,
1661 : : struct xfrm_migrate *m,
1662 : : struct xfrm_encap_tmpl *encap);
1663 : : int xfrm_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
1664 : : struct xfrm_migrate *m, int num_bundles,
1665 : : struct xfrm_kmaddress *k, struct net *net,
1666 : : struct xfrm_encap_tmpl *encap);
1667 : : #endif
1668 : :
1669 : : int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
1670 : : void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 portid);
1671 : : int km_report(struct net *net, u8 proto, struct xfrm_selector *sel,
1672 : : xfrm_address_t *addr);
1673 : :
1674 : : void xfrm_input_init(void);
1675 : : int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
1676 : :
1677 : : void xfrm_probe_algs(void);
1678 : : int xfrm_count_pfkey_auth_supported(void);
1679 : : int xfrm_count_pfkey_enc_supported(void);
1680 : : struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
1681 : : struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
1682 : : struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
1683 : : struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
1684 : : struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
1685 : : struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe);
1686 : : struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe);
1687 : : struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe);
1688 : : struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len,
1689 : : int probe);
1690 : :
1691 : 0 : static inline bool xfrm6_addr_equal(const xfrm_address_t *a,
1692 : : const xfrm_address_t *b)
1693 : : {
1694 : 0 : return ipv6_addr_equal((const struct in6_addr *)a,
1695 : : (const struct in6_addr *)b);
1696 : : }
1697 : :
1698 : 0 : static inline bool xfrm_addr_equal(const xfrm_address_t *a,
1699 : : const xfrm_address_t *b,
1700 : : sa_family_t family)
1701 : : {
1702 [ # # # # : 0 : switch (family) {
# # # # #
# # # # #
# # # # ]
1703 : 0 : default:
1704 : : case AF_INET:
1705 : 0 : return ((__force u32)a->a4 ^ (__force u32)b->a4) == 0;
1706 : : case AF_INET6:
1707 : 0 : return xfrm6_addr_equal(a, b);
1708 : : }
1709 : : }
1710 : :
1711 : 0 : static inline int xfrm_policy_id2dir(u32 index)
1712 : : {
1713 [ # # # # : 0 : return index & 7;
# # # # #
# ]
1714 : : }
1715 : :
1716 : : #ifdef CONFIG_XFRM
1717 : 0 : static inline int xfrm_aevent_is_on(struct net *net)
1718 : : {
1719 : 0 : struct sock *nlsk;
1720 : 0 : int ret = 0;
1721 : :
1722 : 0 : rcu_read_lock();
1723 [ # # # # : 0 : nlsk = rcu_dereference(net->xfrm.nlsk);
# # # # #
# # # ]
1724 [ # # # # : 0 : if (nlsk)
# # # # #
# # # ]
1725 : 0 : ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
1726 : 0 : rcu_read_unlock();
1727 [ # # # # : 0 : return ret;
# # # # #
# # # ]
1728 : : }
1729 : :
1730 : 0 : static inline int xfrm_acquire_is_on(struct net *net)
1731 : : {
1732 : 0 : struct sock *nlsk;
1733 : 0 : int ret = 0;
1734 : :
1735 : 0 : rcu_read_lock();
1736 [ # # ]: 0 : nlsk = rcu_dereference(net->xfrm.nlsk);
1737 [ # # ]: 0 : if (nlsk)
1738 : 0 : ret = netlink_has_listeners(nlsk, XFRMNLGRP_ACQUIRE);
1739 : 0 : rcu_read_unlock();
1740 : :
1741 : 0 : return ret;
1742 : : }
1743 : : #endif
1744 : :
1745 : 0 : static inline unsigned int aead_len(struct xfrm_algo_aead *alg)
1746 : : {
1747 [ # # ]: 0 : return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1748 : : }
1749 : :
1750 : 0 : static inline unsigned int xfrm_alg_len(const struct xfrm_algo *alg)
1751 : : {
1752 [ # # # # : 0 : return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
# # ]
1753 : : }
1754 : :
1755 : 0 : static inline unsigned int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg)
1756 : : {
1757 [ # # ]: 0 : return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1758 : : }
1759 : :
1760 : 0 : static inline unsigned int xfrm_replay_state_esn_len(struct xfrm_replay_state_esn *replay_esn)
1761 : : {
1762 [ # # # # : 0 : return sizeof(*replay_esn) + replay_esn->bmp_len * sizeof(__u32);
# # # # ]
1763 : : }
1764 : :
1765 : : #ifdef CONFIG_XFRM_MIGRATE
1766 : : static inline int xfrm_replay_clone(struct xfrm_state *x,
1767 : : struct xfrm_state *orig)
1768 : : {
1769 : : x->replay_esn = kzalloc(xfrm_replay_state_esn_len(orig->replay_esn),
1770 : : GFP_KERNEL);
1771 : : if (!x->replay_esn)
1772 : : return -ENOMEM;
1773 : :
1774 : : x->replay_esn->bmp_len = orig->replay_esn->bmp_len;
1775 : : x->replay_esn->replay_window = orig->replay_esn->replay_window;
1776 : :
1777 : : x->preplay_esn = kmemdup(x->replay_esn,
1778 : : xfrm_replay_state_esn_len(x->replay_esn),
1779 : : GFP_KERNEL);
1780 : : if (!x->preplay_esn) {
1781 : : kfree(x->replay_esn);
1782 : : return -ENOMEM;
1783 : : }
1784 : :
1785 : : return 0;
1786 : : }
1787 : :
1788 : : static inline struct xfrm_algo_aead *xfrm_algo_aead_clone(struct xfrm_algo_aead *orig)
1789 : : {
1790 : : return kmemdup(orig, aead_len(orig), GFP_KERNEL);
1791 : : }
1792 : :
1793 : :
1794 : : static inline struct xfrm_algo *xfrm_algo_clone(struct xfrm_algo *orig)
1795 : : {
1796 : : return kmemdup(orig, xfrm_alg_len(orig), GFP_KERNEL);
1797 : : }
1798 : :
1799 : : static inline struct xfrm_algo_auth *xfrm_algo_auth_clone(struct xfrm_algo_auth *orig)
1800 : : {
1801 : : return kmemdup(orig, xfrm_alg_auth_len(orig), GFP_KERNEL);
1802 : : }
1803 : :
1804 : : static inline void xfrm_states_put(struct xfrm_state **states, int n)
1805 : : {
1806 : : int i;
1807 : : for (i = 0; i < n; i++)
1808 : : xfrm_state_put(*(states + i));
1809 : : }
1810 : :
1811 : : static inline void xfrm_states_delete(struct xfrm_state **states, int n)
1812 : : {
1813 : : int i;
1814 : : for (i = 0; i < n; i++)
1815 : : xfrm_state_delete(*(states + i));
1816 : : }
1817 : : #endif
1818 : :
1819 : : #ifdef CONFIG_XFRM
1820 : 0 : static inline struct xfrm_state *xfrm_input_state(struct sk_buff *skb)
1821 : : {
1822 [ # # # # : 0 : struct sec_path *sp = skb_sec_path(skb);
# # ]
1823 : :
1824 [ # # # # : 0 : return sp->xvec[sp->len - 1];
# # ]
1825 : : }
1826 : : #endif
1827 : :
1828 : 0 : static inline struct xfrm_offload *xfrm_offload(struct sk_buff *skb)
1829 : : {
1830 : : #ifdef CONFIG_XFRM
1831 [ # # # # : 0 : struct sec_path *sp = skb_sec_path(skb);
# # ]
1832 : :
1833 [ # # # # : 0 : if (!sp || !sp->olen || sp->len != sp->olen)
# # # # #
# # # # #
# # # # ]
1834 : : return NULL;
1835 : :
1836 [ # # ]: 0 : return &sp->ovec[sp->olen - 1];
1837 : : #else
1838 : : return NULL;
1839 : : #endif
1840 : : }
1841 : :
1842 : : void __init xfrm_dev_init(void);
1843 : :
1844 : : #ifdef CONFIG_XFRM_OFFLOAD
1845 : : void xfrm_dev_resume(struct sk_buff *skb);
1846 : : void xfrm_dev_backlog(struct softnet_data *sd);
1847 : : struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again);
1848 : : int xfrm_dev_state_add(struct net *net, struct xfrm_state *x,
1849 : : struct xfrm_user_offload *xuo);
1850 : : bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x);
1851 : :
1852 : : static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
1853 : : {
1854 : : struct xfrm_state_offload *xso = &x->xso;
1855 : :
1856 : : if (xso->dev && xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn)
1857 : : xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn(x);
1858 : : }
1859 : :
1860 : : static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
1861 : : {
1862 : : struct xfrm_state *x = dst->xfrm;
1863 : : struct xfrm_dst *xdst;
1864 : :
1865 : : if (!x || !x->type_offload)
1866 : : return false;
1867 : :
1868 : : xdst = (struct xfrm_dst *) dst;
1869 : : if (!x->xso.offload_handle && !xdst->child->xfrm)
1870 : : return true;
1871 : : if (x->xso.offload_handle && (x->xso.dev == xfrm_dst_path(dst)->dev) &&
1872 : : !xdst->child->xfrm)
1873 : : return true;
1874 : :
1875 : : return false;
1876 : : }
1877 : :
1878 : : static inline void xfrm_dev_state_delete(struct xfrm_state *x)
1879 : : {
1880 : : struct xfrm_state_offload *xso = &x->xso;
1881 : :
1882 : : if (xso->dev)
1883 : : xso->dev->xfrmdev_ops->xdo_dev_state_delete(x);
1884 : : }
1885 : :
1886 : : static inline void xfrm_dev_state_free(struct xfrm_state *x)
1887 : : {
1888 : : struct xfrm_state_offload *xso = &x->xso;
1889 : : struct net_device *dev = xso->dev;
1890 : :
1891 : : if (dev && dev->xfrmdev_ops) {
1892 : : if (dev->xfrmdev_ops->xdo_dev_state_free)
1893 : : dev->xfrmdev_ops->xdo_dev_state_free(x);
1894 : : xso->dev = NULL;
1895 : : dev_put(dev);
1896 : : }
1897 : : }
1898 : : #else
1899 : : static inline void xfrm_dev_resume(struct sk_buff *skb)
1900 : : {
1901 : : }
1902 : :
1903 : 9 : static inline void xfrm_dev_backlog(struct softnet_data *sd)
1904 : : {
1905 : 9 : }
1906 : :
1907 : : static inline struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again)
1908 : : {
1909 : : return skb;
1910 : : }
1911 : :
1912 : : static inline int xfrm_dev_state_add(struct net *net, struct xfrm_state *x, struct xfrm_user_offload *xuo)
1913 : : {
1914 : : return 0;
1915 : : }
1916 : :
1917 : 0 : static inline void xfrm_dev_state_delete(struct xfrm_state *x)
1918 : : {
1919 : 0 : }
1920 : :
1921 : 0 : static inline void xfrm_dev_state_free(struct xfrm_state *x)
1922 : : {
1923 : 0 : }
1924 : :
1925 : 0 : static inline bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x)
1926 : : {
1927 [ # # ]: 0 : return false;
1928 : : }
1929 : :
1930 : 0 : static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
1931 : : {
1932 : 0 : }
1933 : :
1934 : 0 : static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
1935 : : {
1936 : 0 : return false;
1937 : : }
1938 : : #endif
1939 : :
1940 : 0 : static inline int xfrm_mark_get(struct nlattr **attrs, struct xfrm_mark *m)
1941 : : {
1942 [ # # # # : 0 : if (attrs[XFRMA_MARK])
# # # # #
# # # # #
# # # # #
# ]
1943 : 0 : memcpy(m, nla_data(attrs[XFRMA_MARK]), sizeof(struct xfrm_mark));
1944 : : else
1945 : 0 : m->v = m->m = 0;
1946 : :
1947 [ # # # # : 0 : return m->v & m->m;
# # # # #
# # # #
# ]
1948 : : }
1949 : :
1950 : 0 : static inline int xfrm_mark_put(struct sk_buff *skb, const struct xfrm_mark *m)
1951 : : {
1952 : 0 : int ret = 0;
1953 : :
1954 [ # # # # : 0 : if (m->m | m->v)
# # # # #
# ]
1955 : 0 : ret = nla_put(skb, XFRMA_MARK, sizeof(struct xfrm_mark), m);
1956 [ # # # # ]: 0 : return ret;
1957 : : }
1958 : :
1959 : 0 : static inline __u32 xfrm_smark_get(__u32 mark, struct xfrm_state *x)
1960 : : {
1961 : 0 : struct xfrm_mark *m = &x->props.smark;
1962 : :
1963 : 0 : return (m->v & m->m) | (mark & ~m->m);
1964 : : }
1965 : :
1966 : 0 : static inline int xfrm_if_id_put(struct sk_buff *skb, __u32 if_id)
1967 : : {
1968 : 0 : int ret = 0;
1969 : :
1970 [ # # # # : 0 : if (if_id)
# # # # ]
1971 : 0 : ret = nla_put_u32(skb, XFRMA_IF_ID, if_id);
1972 [ # # ]: 0 : return ret;
1973 : : }
1974 : :
1975 : 0 : static inline int xfrm_tunnel_check(struct sk_buff *skb, struct xfrm_state *x,
1976 : : unsigned int family)
1977 : : {
1978 : 0 : bool tunnel = false;
1979 : :
1980 [ # # # ]: 0 : switch(family) {
1981 : 0 : case AF_INET:
1982 [ # # ]: 0 : if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4)
1983 : : tunnel = true;
1984 : : break;
1985 : 0 : case AF_INET6:
1986 [ # # ]: 0 : if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6)
1987 : : tunnel = true;
1988 : : break;
1989 : : }
1990 [ # # ]: 0 : if (tunnel && !(x->outer_mode.flags & XFRM_MODE_FLAG_TUNNEL))
1991 : 0 : return -EINVAL;
1992 : :
1993 : : return 0;
1994 : : }
1995 : : #endif /* _NET_XFRM_H */
|
