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