]> Git Repo - linux.git/blame - net/xfrm/xfrm_state.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
xfrm: replace deprecated strncpy with strscpy_pad
[linux.git] / net / xfrm / xfrm_state.c
CommitLineData
457c8996 1// SPDX-License-Identifier: GPL-2.0-only
1da177e4
LT		 2/*
3 * xfrm_state.c
4 *
5 * Changes:
6 * Mitsuru KANDA @USAGI
7 * Kazunori MIYAZAWA @USAGI
8 * Kunihiro Ishiguro <[email protected]>
9 * IPv6 support
10 * YOSHIFUJI Hideaki @USAGI
11 * Split up af-specific functions
12 * Derek Atkins <[email protected]>
13 * Add UDP Encapsulation
df71837d 14 *
1da177e4
LT		 15 */
16
b6459415 17#include <linux/compat.h>
1da177e4
LT		 18#include <linux/workqueue.h>
19#include <net/xfrm.h>
20#include <linux/pfkeyv2.h>
21#include <linux/ipsec.h>
22#include <linux/module.h>
f034b5d4 23#include <linux/cache.h>
68277acc 24#include <linux/audit.h>
7c0f6ba6 25#include <linux/uaccess.h>
9e0d57fd 26#include <linux/ktime.h>
5a0e3ad6 27#include <linux/slab.h>
9e0d57fd
YP		 28#include <linux/interrupt.h>
29#include <linux/kernel.h>
1da177e4 30
c7b37c76
FW		 31#include <crypto/aead.h>
32
44e36b42
DM		 33#include "xfrm_hash.h"
34
c8406998
FW		 35#define xfrm_state_deref_prot(table, net) \
36 rcu_dereference_protected((table), lockdep_is_held(&(net)->xfrm.xfrm_state_lock))
37
35db57bb
FW		 38static void xfrm_state_gc_task(struct work_struct *work);
39
1da177e4
LT		 40/* Each xfrm_state may be linked to two tables:
41
42 1. Hash table by (spi,daddr,ah/esp) to find SA by SPI. (input,ctl)
a624c108 43 2. Hash table by (daddr,family,reqid) to find what SAs exist for given
1da177e4
LT		 44 destination/tunnel endpoint. (output)
45 */
46
f034b5d4 47static unsigned int xfrm_state_hashmax __read_mostly = 1 * 1024 * 1024;
565f0fa9 48static struct kmem_cache *xfrm_state_cache __ro_after_init;
f034b5d4 49
35db57bb
FW		 50static DECLARE_WORK(xfrm_state_gc_work, xfrm_state_gc_task);
51static HLIST_HEAD(xfrm_state_gc_list);
07b87f9e 52static HLIST_HEAD(xfrm_state_dev_gc_list);
35db57bb 53
02efdff7
FW		 54static inline bool xfrm_state_hold_rcu(struct xfrm_state __rcu *x)
55{
88755e9c 56 return refcount_inc_not_zero(&x->refcnt);
02efdff7
FW		 57}
58
64d0cd00 59static inline unsigned int xfrm_dst_hash(struct net *net,
2ab38503
DM		 60 const xfrm_address_t *daddr,
61 const xfrm_address_t *saddr,
c1969f29 62 u32 reqid,
a624c108 63 unsigned short family)
f034b5d4 64{
64d0cd00 65 return __xfrm_dst_hash(daddr, saddr, reqid, family, net->xfrm.state_hmask);
f034b5d4
DM		 66}
67
64d0cd00 68static inline unsigned int xfrm_src_hash(struct net *net,
2ab38503
DM		 69 const xfrm_address_t *daddr,
70 const xfrm_address_t *saddr,
44e36b42 71 unsigned short family)
f034b5d4 72{
64d0cd00 73 return __xfrm_src_hash(daddr, saddr, family, net->xfrm.state_hmask);
f034b5d4
DM		 74}
75
f034b5d4 76static inline unsigned int
2ab38503
DM		 77xfrm_spi_hash(struct net *net, const xfrm_address_t *daddr,
78 __be32 spi, u8 proto, unsigned short family)
f034b5d4 79{
64d0cd00 80 return __xfrm_spi_hash(daddr, spi, proto, family, net->xfrm.state_hmask);
f034b5d4
DM		 81}
82
fe9f1d87
SD		 83static unsigned int xfrm_seq_hash(struct net *net, u32 seq)
84{
85 return __xfrm_seq_hash(seq, net->xfrm.state_hmask);
86}
87
3c611d40
LR		 88#define XFRM_STATE_INSERT(by, _n, _h, _type) \
89 { \
90 struct xfrm_state *_x = NULL; \
91 \
92 if (_type != XFRM_DEV_OFFLOAD_PACKET) { \
93 hlist_for_each_entry_rcu(_x, _h, by) { \
94 if (_x->xso.type == XFRM_DEV_OFFLOAD_PACKET) \
95 continue; \
96 break; \
97 } \
98 } \
99 \
100 if (!_x || _x->xso.type == XFRM_DEV_OFFLOAD_PACKET) \
101 /* SAD is empty or consist from HW SAs only */ \
102 hlist_add_head_rcu(_n, _h); \
103 else \
104 hlist_add_before_rcu(_n, &_x->by); \
105 }
106
f034b5d4
DM		 107static void xfrm_hash_transfer(struct hlist_head *list,
108 struct hlist_head *ndsttable,
109 struct hlist_head *nsrctable,
110 struct hlist_head *nspitable,
fe9f1d87 111 struct hlist_head *nseqtable,
f034b5d4
DM		 112 unsigned int nhashmask)
113{
b67bfe0d 114 struct hlist_node *tmp;
f034b5d4
DM		 115 struct xfrm_state *x;
116
b67bfe0d 117 hlist_for_each_entry_safe(x, tmp, list, bydst) {
f034b5d4
DM		 118 unsigned int h;
119
c1969f29
DM		 120 h = __xfrm_dst_hash(&x->id.daddr, &x->props.saddr,
121 x->props.reqid, x->props.family,
122 nhashmask);
3c611d40 123 XFRM_STATE_INSERT(bydst, &x->bydst, ndsttable + h, x->xso.type);
f034b5d4 124
667bbcb6
MN		 125 h = __xfrm_src_hash(&x->id.daddr, &x->props.saddr,
126 x->props.family,
f034b5d4 127 nhashmask);
3c611d40 128 XFRM_STATE_INSERT(bysrc, &x->bysrc, nsrctable + h, x->xso.type);
f034b5d4 129
7b4dc360
MN		 130 if (x->id.spi) {
131 h = __xfrm_spi_hash(&x->id.daddr, x->id.spi,
132 x->id.proto, x->props.family,
133 nhashmask);
3c611d40
LR		 134 XFRM_STATE_INSERT(byspi, &x->byspi, nspitable + h,
135 x->xso.type);
7b4dc360 136 }
fe9f1d87
SD		 137
138 if (x->km.seq) {
139 h = __xfrm_seq_hash(x->km.seq, nhashmask);
3c611d40
LR		 140 XFRM_STATE_INSERT(byseq, &x->byseq, nseqtable + h,
141 x->xso.type);
fe9f1d87 142 }
f034b5d4
DM		 143 }
144}
145
63082733 146static unsigned long xfrm_hash_new_size(unsigned int state_hmask)
f034b5d4 147{
63082733 148 return ((state_hmask + 1) << 1) * sizeof(struct hlist_head);
f034b5d4
DM		 149}
150
63082733 151static void xfrm_hash_resize(struct work_struct *work)
f034b5d4 152{
63082733 153 struct net *net = container_of(work, struct net, xfrm.state_hash_work);
fe9f1d87 154 struct hlist_head *ndst, *nsrc, *nspi, *nseq, *odst, *osrc, *ospi, *oseq;
f034b5d4
DM		 155 unsigned long nsize, osize;
156 unsigned int nhashmask, ohashmask;
157 int i;
158
63082733 159 nsize = xfrm_hash_new_size(net->xfrm.state_hmask);
44e36b42 160 ndst = xfrm_hash_alloc(nsize);
f034b5d4 161 if (!ndst)
0244790c 162 return;
44e36b42 163 nsrc = xfrm_hash_alloc(nsize);
f034b5d4 164 if (!nsrc) {
44e36b42 165 xfrm_hash_free(ndst, nsize);
0244790c 166 return;
f034b5d4 167 }
44e36b42 168 nspi = xfrm_hash_alloc(nsize);
f034b5d4 169 if (!nspi) {
44e36b42
DM		 170 xfrm_hash_free(ndst, nsize);
171 xfrm_hash_free(nsrc, nsize);
0244790c 172 return;
f034b5d4 173 }
fe9f1d87
SD		 174 nseq = xfrm_hash_alloc(nsize);
175 if (!nseq) {
176 xfrm_hash_free(ndst, nsize);
177 xfrm_hash_free(nsrc, nsize);
178 xfrm_hash_free(nspi, nsize);
179 return;
180 }
f034b5d4 181
283bc9f3 182 spin_lock_bh(&net->xfrm.xfrm_state_lock);
e88add19 183 write_seqcount_begin(&net->xfrm.xfrm_state_hash_generation);
f034b5d4
DM		 184
185 nhashmask = (nsize / sizeof(struct hlist_head)) - 1U;
c8406998 186 odst = xfrm_state_deref_prot(net->xfrm.state_bydst, net);
63082733 187 for (i = net->xfrm.state_hmask; i >= 0; i--)
fe9f1d87 188 xfrm_hash_transfer(odst + i, ndst, nsrc, nspi, nseq, nhashmask);
f034b5d4 189
c8406998
FW		 190 osrc = xfrm_state_deref_prot(net->xfrm.state_bysrc, net);
191 ospi = xfrm_state_deref_prot(net->xfrm.state_byspi, net);
fe9f1d87 192 oseq = xfrm_state_deref_prot(net->xfrm.state_byseq, net);
63082733 193 ohashmask = net->xfrm.state_hmask;
f034b5d4 194
c8406998
FW		 195 rcu_assign_pointer(net->xfrm.state_bydst, ndst);
196 rcu_assign_pointer(net->xfrm.state_bysrc, nsrc);
197 rcu_assign_pointer(net->xfrm.state_byspi, nspi);
fe9f1d87 198 rcu_assign_pointer(net->xfrm.state_byseq, nseq);
63082733 199 net->xfrm.state_hmask = nhashmask;
f034b5d4 200
e88add19 201 write_seqcount_end(&net->xfrm.xfrm_state_hash_generation);
283bc9f3 202 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
f034b5d4
DM		 203
204 osize = (ohashmask + 1) * sizeof(struct hlist_head);
df7274eb
FW		 205
206 synchronize_rcu();
207
44e36b42
DM		 208 xfrm_hash_free(odst, osize);
209 xfrm_hash_free(osrc, osize);
210 xfrm_hash_free(ospi, osize);
fe9f1d87 211 xfrm_hash_free(oseq, osize);
f034b5d4
DM		 212}
213
44abdc30
CW		 214static DEFINE_SPINLOCK(xfrm_state_afinfo_lock);
215static struct xfrm_state_afinfo __rcu *xfrm_state_afinfo[NPROTO];
1da177e4 216
1da177e4 217static DEFINE_SPINLOCK(xfrm_state_gc_lock);
07b87f9e 218static DEFINE_SPINLOCK(xfrm_state_dev_gc_lock);
1da177e4 219
53bc6b4d 220int __xfrm_state_delete(struct xfrm_state *x);
1da177e4 221
980ebd25 222int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol);
bb9cd077 223static bool km_is_alive(const struct km_event *c);
15e47304 224void km_state_expired(struct xfrm_state *x, int hard, u32 portid);
1da177e4 225
533cb5b0 226int xfrm_register_type(const struct xfrm_type *type, unsigned short family)
aa5d62cc 227{
7a9885b9 228 struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
aa5d62cc
HX		 229 int err = 0;
230
4f518e80 231 if (!afinfo)
aa5d62cc 232 return -EAFNOSUPPORT;
4f518e80
FW		 233
234#define X(afi, T, name) do { \
235 WARN_ON((afi)->type_ ## name); \
236 (afi)->type_ ## name = (T); \
237 } while (0)
238
239 switch (type->proto) {
240 case IPPROTO_COMP:
241 X(afinfo, type, comp);
242 break;
243 case IPPROTO_AH:
244 X(afinfo, type, ah);
245 break;
246 case IPPROTO_ESP:
247 X(afinfo, type, esp);
248 break;
249 case IPPROTO_IPIP:
250 X(afinfo, type, ipip);
251 break;
252 case IPPROTO_DSTOPTS:
253 X(afinfo, type, dstopts);
254 break;
255 case IPPROTO_ROUTING:
256 X(afinfo, type, routing);
257 break;
258 case IPPROTO_IPV6:
259 X(afinfo, type, ipip6);
260 break;
261 default:
262 WARN_ON(1);
263 err = -EPROTONOSUPPORT;
264 break;
265 }
266#undef X
af5d27c4 267 rcu_read_unlock();
aa5d62cc
HX		 268 return err;
269}
270EXPORT_SYMBOL(xfrm_register_type);
271
4f518e80 272void xfrm_unregister_type(const struct xfrm_type *type, unsigned short family)
aa5d62cc 273{
7a9885b9 274 struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
aa5d62cc
HX		 275
276 if (unlikely(afinfo == NULL))
4f518e80
FW		 277 return;
278
279#define X(afi, T, name) do { \
280 WARN_ON((afi)->type_ ## name != (T)); \
281 (afi)->type_ ## name = NULL; \
282 } while (0)
283
284 switch (type->proto) {
285 case IPPROTO_COMP:
286 X(afinfo, type, comp);
287 break;
288 case IPPROTO_AH:
289 X(afinfo, type, ah);
290 break;
291 case IPPROTO_ESP:
292 X(afinfo, type, esp);
293 break;
294 case IPPROTO_IPIP:
295 X(afinfo, type, ipip);
296 break;
297 case IPPROTO_DSTOPTS:
298 X(afinfo, type, dstopts);
299 break;
300 case IPPROTO_ROUTING:
301 X(afinfo, type, routing);
302 break;
303 case IPPROTO_IPV6:
304 X(afinfo, type, ipip6);
305 break;
306 default:
307 WARN_ON(1);
308 break;
309 }
310#undef X
af5d27c4 311 rcu_read_unlock();
aa5d62cc
HX		 312}
313EXPORT_SYMBOL(xfrm_unregister_type);
314
533cb5b0 315static const struct xfrm_type *xfrm_get_type(u8 proto, unsigned short family)
aa5d62cc 316{
4f518e80 317 const struct xfrm_type *type = NULL;
aa5d62cc 318 struct xfrm_state_afinfo *afinfo;
aa5d62cc
HX		 319 int modload_attempted = 0;
320
321retry:
322 afinfo = xfrm_state_get_afinfo(family);
323 if (unlikely(afinfo == NULL))
324 return NULL;
aa5d62cc 325
4f518e80
FW		 326 switch (proto) {
327 case IPPROTO_COMP:
328 type = afinfo->type_comp;
329 break;
330 case IPPROTO_AH:
331 type = afinfo->type_ah;
332 break;
333 case IPPROTO_ESP:
334 type = afinfo->type_esp;
335 break;
336 case IPPROTO_IPIP:
337 type = afinfo->type_ipip;
338 break;
339 case IPPROTO_DSTOPTS:
340 type = afinfo->type_dstopts;
341 break;
342 case IPPROTO_ROUTING:
343 type = afinfo->type_routing;
344 break;
345 case IPPROTO_IPV6:
346 type = afinfo->type_ipip6;
347 break;
348 default:
349 break;
350 }
351
aa5d62cc
HX		 352 if (unlikely(type && !try_module_get(type->owner)))
353 type = NULL;
75cda62d
FW		 354
355 rcu_read_unlock();
356
aa5d62cc 357 if (!type && !modload_attempted) {
aa5d62cc
HX		 358 request_module("xfrm-type-%d-%d", family, proto);
359 modload_attempted = 1;
360 goto retry;
361 }
362
aa5d62cc
HX		 363 return type;
364}
365
533cb5b0 366static void xfrm_put_type(const struct xfrm_type *type)
aa5d62cc
HX		 367{
368 module_put(type->owner);
369}
370
9d389d7f
SK		 371int xfrm_register_type_offload(const struct xfrm_type_offload *type,
372 unsigned short family)
373{
374 struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
9d389d7f
SK		 375 int err = 0;
376
377 if (unlikely(afinfo == NULL))
378 return -EAFNOSUPPORT;
4f518e80
FW		 379
380 switch (type->proto) {
381 case IPPROTO_ESP:
382 WARN_ON(afinfo->type_offload_esp);
383 afinfo->type_offload_esp = type;
384 break;
385 default:
386 WARN_ON(1);
387 err = -EPROTONOSUPPORT;
388 break;
389 }
390
9d389d7f
SK		 391 rcu_read_unlock();
392 return err;
393}
394EXPORT_SYMBOL(xfrm_register_type_offload);
395
4f518e80
FW		 396void xfrm_unregister_type_offload(const struct xfrm_type_offload *type,
397 unsigned short family)
9d389d7f
SK		 398{
399 struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
9d389d7f
SK		 400
401 if (unlikely(afinfo == NULL))
4f518e80
FW		 402 return;
403
404 switch (type->proto) {
405 case IPPROTO_ESP:
406 WARN_ON(afinfo->type_offload_esp != type);
407 afinfo->type_offload_esp = NULL;
408 break;
409 default:
410 WARN_ON(1);
411 break;
412 }
9d389d7f 413 rcu_read_unlock();
9d389d7f
SK		 414}
415EXPORT_SYMBOL(xfrm_unregister_type_offload);
416
ffdb5211
IT		 417static const struct xfrm_type_offload *
418xfrm_get_type_offload(u8 proto, unsigned short family, bool try_load)
9d389d7f 419{
4f518e80 420 const struct xfrm_type_offload *type = NULL;
9d389d7f 421 struct xfrm_state_afinfo *afinfo;
9d389d7f 422
ffdb5211 423retry:
9d389d7f
SK		 424 afinfo = xfrm_state_get_afinfo(family);
425 if (unlikely(afinfo == NULL))
426 return NULL;
9d389d7f 427
4f518e80
FW		 428 switch (proto) {
429 case IPPROTO_ESP:
430 type = afinfo->type_offload_esp;
431 break;
432 default:
433 break;
434 }
435
9d389d7f
SK		 436 if ((type && !try_module_get(type->owner)))
437 type = NULL;
438
2f10a61c
SD		 439 rcu_read_unlock();
440
ffdb5211
IT		 441 if (!type && try_load) {
442 request_module("xfrm-offload-%d-%d", family, proto);
545d8ae7 443 try_load = false;
ffdb5211
IT		 444 goto retry;
445 }
446
9d389d7f
SK		 447 return type;
448}
449
450static void xfrm_put_type_offload(const struct xfrm_type_offload *type)
451{
452 module_put(type->owner);
453}
454
4c145dce
FW		 455static const struct xfrm_mode xfrm4_mode_map[XFRM_MODE_MAX] = {
456 [XFRM_MODE_BEET] = {
457 .encap = XFRM_MODE_BEET,
458 .flags = XFRM_MODE_FLAG_TUNNEL,
459 .family = AF_INET,
460 },
461 [XFRM_MODE_TRANSPORT] = {
462 .encap = XFRM_MODE_TRANSPORT,
463 .family = AF_INET,
464 },
465 [XFRM_MODE_TUNNEL] = {
466 .encap = XFRM_MODE_TUNNEL,
467 .flags = XFRM_MODE_FLAG_TUNNEL,
468 .family = AF_INET,
469 },
470};
471
472static const struct xfrm_mode xfrm6_mode_map[XFRM_MODE_MAX] = {
473 [XFRM_MODE_BEET] = {
474 .encap = XFRM_MODE_BEET,
475 .flags = XFRM_MODE_FLAG_TUNNEL,
476 .family = AF_INET6,
477 },
478 [XFRM_MODE_ROUTEOPTIMIZATION] = {
479 .encap = XFRM_MODE_ROUTEOPTIMIZATION,
480 .family = AF_INET6,
481 },
482 [XFRM_MODE_TRANSPORT] = {
483 .encap = XFRM_MODE_TRANSPORT,
484 .family = AF_INET6,
485 },
486 [XFRM_MODE_TUNNEL] = {
487 .encap = XFRM_MODE_TUNNEL,
488 .flags = XFRM_MODE_FLAG_TUNNEL,
489 .family = AF_INET6,
490 },
491};
492
493static const struct xfrm_mode *xfrm_get_mode(unsigned int encap, int family)
494{
495 const struct xfrm_mode *mode;
aa5d62cc
HX		 496
497 if (unlikely(encap >= XFRM_MODE_MAX))
498 return NULL;
499
4c145dce
FW		 500 switch (family) {
501 case AF_INET:
502 mode = &xfrm4_mode_map[encap];
503 if (mode->family == family)
504 return mode;
505 break;
506 case AF_INET6:
507 mode = &xfrm6_mode_map[encap];
508 if (mode->family == family)
509 return mode;
510 break;
511 default:
512 break;
aa5d62cc
HX		 513 }
514
4c145dce 515 return NULL;
aa5d62cc
HX		 516}
517
4a135e53
MK		 518void xfrm_state_free(struct xfrm_state *x)
519{
520 kmem_cache_free(xfrm_state_cache, x);
521}
522EXPORT_SYMBOL(xfrm_state_free);
523
f75a2804 524static void ___xfrm_state_destroy(struct xfrm_state *x)
1da177e4 525{
671422b2 526 hrtimer_cancel(&x->mtimer);
a47f0ce0 527 del_timer_sync(&x->rtimer);
b5884793 528 kfree(x->aead);
a51482bd
JJ		 529 kfree(x->aalg);
530 kfree(x->ealg);
531 kfree(x->calg);
532 kfree(x->encap);
060f02a3 533 kfree(x->coaddr);
d8647b79
SK		 534 kfree(x->replay_esn);
535 kfree(x->preplay_esn);
9d389d7f
SK		 536 if (x->type_offload)
537 xfrm_put_type_offload(x->type_offload);
1da177e4
LT		 538 if (x->type) {
539 x->type->destructor(x);
540 xfrm_put_type(x->type);
541 }
86c6739e
SK		 542 if (x->xfrag.page)
543 put_page(x->xfrag.page);
d77e38e6 544 xfrm_dev_state_free(x);
df71837d 545 security_xfrm_state_free(x);
4a135e53 546 xfrm_state_free(x);
1da177e4
LT		 547}
548
c7837144 549static void xfrm_state_gc_task(struct work_struct *work)
1da177e4 550{
12a169e7 551 struct xfrm_state *x;
b67bfe0d 552 struct hlist_node *tmp;
12a169e7 553 struct hlist_head gc_list;
1da177e4 554
1da177e4 555 spin_lock_bh(&xfrm_state_gc_lock);
35db57bb 556 hlist_move_list(&xfrm_state_gc_list, &gc_list);
1da177e4
LT		 557 spin_unlock_bh(&xfrm_state_gc_lock);
558
df7274eb
FW		 559 synchronize_rcu();
560
b67bfe0d 561 hlist_for_each_entry_safe(x, tmp, &gc_list, gclist)
f75a2804 562 ___xfrm_state_destroy(x);
1da177e4
LT		 563}
564
3e94c2dc 565static enum hrtimer_restart xfrm_timer_handler(struct hrtimer *me)
1da177e4 566{
671422b2
TG		 567 struct xfrm_state *x = container_of(me, struct xfrm_state, mtimer);
568 enum hrtimer_restart ret = HRTIMER_NORESTART;
386c5680
AB		 569 time64_t now = ktime_get_real_seconds();
570 time64_t next = TIME64_MAX;
1da177e4 571 int warn = 0;
161a09e7 572 int err = 0;
1da177e4
LT		 573
574 spin_lock(&x->lock);
fd2bc419 575 xfrm_dev_state_update_stats(x);
f3da86dc 576
1da177e4
LT		 577 if (x->km.state == XFRM_STATE_DEAD)
578 goto out;
579 if (x->km.state == XFRM_STATE_EXPIRED)
580 goto expired;
581 if (x->lft.hard_add_expires_seconds) {
195e4aac 582 time64_t tmo = x->lft.hard_add_expires_seconds +
1da177e4 583 x->curlft.add_time - now;
e3c0d047
FD		 584 if (tmo <= 0) {
585 if (x->xflags & XFRM_SOFT_EXPIRE) {
586 /* enter hard expire without soft expire first?!
587 * setting a new date could trigger this.
1365e547 588 * workaround: fix x->curflt.add_time by below:
e3c0d047
FD		 589 */
590 x->curlft.add_time = now - x->saved_tmo - 1;
591 tmo = x->lft.hard_add_expires_seconds - x->saved_tmo;
592 } else
593 goto expired;
594 }
1da177e4
LT		 595 if (tmo < next)
596 next = tmo;
597 }
598 if (x->lft.hard_use_expires_seconds) {
195e4aac 599 time64_t tmo = x->lft.hard_use_expires_seconds +
0a9e5794 600 (READ_ONCE(x->curlft.use_time) ? : now) - now;
1da177e4
LT		 601 if (tmo <= 0)
602 goto expired;
603 if (tmo < next)
604 next = tmo;
605 }
606 if (x->km.dying)
607 goto resched;
608 if (x->lft.soft_add_expires_seconds) {
195e4aac 609 time64_t tmo = x->lft.soft_add_expires_seconds +
1da177e4 610 x->curlft.add_time - now;
e3c0d047 611 if (tmo <= 0) {
1da177e4 612 warn = 1;
e3c0d047
FD		 613 x->xflags &= ~XFRM_SOFT_EXPIRE;
614 } else if (tmo < next) {
1da177e4 615 next = tmo;
e3c0d047
FD		 616 x->xflags |= XFRM_SOFT_EXPIRE;
617 x->saved_tmo = tmo;
618 }
1da177e4
LT		 619 }
620 if (x->lft.soft_use_expires_seconds) {
195e4aac 621 time64_t tmo = x->lft.soft_use_expires_seconds +
0a9e5794 622 (READ_ONCE(x->curlft.use_time) ? : now) - now;
1da177e4
LT		 623 if (tmo <= 0)
624 warn = 1;
625 else if (tmo < next)
626 next = tmo;
627 }
628
4666faab 629 x->km.dying = warn;
1da177e4 630 if (warn)
53bc6b4d 631 km_state_expired(x, 0, 0);
1da177e4 632resched:
386c5680 633 if (next != TIME64_MAX) {
671422b2
TG		 634 hrtimer_forward_now(&x->mtimer, ktime_set(next, 0));
635 ret = HRTIMER_RESTART;
9e0d57fd 636 }
a47f0ce0 637
1da177e4
LT		 638 goto out;
639
640expired:
5b8ef341 641 if (x->km.state == XFRM_STATE_ACQ && x->id.spi == 0)
1da177e4 642 x->km.state = XFRM_STATE_EXPIRED;
161a09e7
JL		 643
644 err = __xfrm_state_delete(x);
0806ae4c 645 if (!err)
53bc6b4d 646 km_state_expired(x, 1, 0);
1da177e4 647
2e71029e 648 xfrm_audit_state_delete(x, err ? 0 : 1, true);
161a09e7 649
1da177e4
LT		 650out:
651 spin_unlock(&x->lock);
671422b2 652 return ret;
1da177e4
LT		 653}
654
e99e88a9 655static void xfrm_replay_timer_handler(struct timer_list *t);
0ac84752 656
673c09be 657struct xfrm_state *xfrm_state_alloc(struct net *net)
1da177e4
LT		 658{
659 struct xfrm_state *x;
660
a4c278d1 661 x = kmem_cache_zalloc(xfrm_state_cache, GFP_ATOMIC);
1da177e4
LT		 662
663 if (x) {
673c09be 664 write_pnet(&x->xs_net, net);
88755e9c 665 refcount_set(&x->refcnt, 1);
1da177e4 666 atomic_set(&x->tunnel_users, 0);
12a169e7 667 INIT_LIST_HEAD(&x->km.all);
0045e3d8 668 INIT_HLIST_NODE(&x->state_cache);
8f126e37
DM		 669 INIT_HLIST_NODE(&x->bydst);
670 INIT_HLIST_NODE(&x->bysrc);
671 INIT_HLIST_NODE(&x->byspi);
fe9f1d87 672 INIT_HLIST_NODE(&x->byseq);
671422b2
TG		 673 hrtimer_init(&x->mtimer, CLOCK_BOOTTIME, HRTIMER_MODE_ABS_SOFT);
674 x->mtimer.function = xfrm_timer_handler;
e99e88a9 675 timer_setup(&x->rtimer, xfrm_replay_timer_handler, 0);
386c5680 676 x->curlft.add_time = ktime_get_real_seconds();
1da177e4
LT		 677 x->lft.soft_byte_limit = XFRM_INF;
678 x->lft.soft_packet_limit = XFRM_INF;
679 x->lft.hard_byte_limit = XFRM_INF;
680 x->lft.hard_packet_limit = XFRM_INF;
f8cd5488
JHS		 681 x->replay_maxage = 0;
682 x->replay_maxdiff = 0;
1ddf9916 683 x->pcpu_num = UINT_MAX;
1da177e4
LT		 684 spin_lock_init(&x->lock);
685 }
686 return x;
687}
688EXPORT_SYMBOL(xfrm_state_alloc);
689
07b87f9e
SK		 690#ifdef CONFIG_XFRM_OFFLOAD
691void xfrm_dev_state_delete(struct xfrm_state *x)
692{
693 struct xfrm_dev_offload *xso = &x->xso;
694 struct net_device *dev = READ_ONCE(xso->dev);
695
696 if (dev) {
697 dev->xfrmdev_ops->xdo_dev_state_delete(x);
698 spin_lock_bh(&xfrm_state_dev_gc_lock);
699 hlist_add_head(&x->dev_gclist, &xfrm_state_dev_gc_list);
700 spin_unlock_bh(&xfrm_state_dev_gc_lock);
701 }
702}
2d531775 703EXPORT_SYMBOL_GPL(xfrm_dev_state_delete);
07b87f9e
SK		 704
705void xfrm_dev_state_free(struct xfrm_state *x)
706{
707 struct xfrm_dev_offload *xso = &x->xso;
708 struct net_device *dev = READ_ONCE(xso->dev);
709
710 if (dev && dev->xfrmdev_ops) {
711 spin_lock_bh(&xfrm_state_dev_gc_lock);
712 if (!hlist_unhashed(&x->dev_gclist))
713 hlist_del(&x->dev_gclist);
714 spin_unlock_bh(&xfrm_state_dev_gc_lock);
715
716 if (dev->xfrmdev_ops->xdo_dev_state_free)
717 dev->xfrmdev_ops->xdo_dev_state_free(x);
718 WRITE_ONCE(xso->dev, NULL);
719 xso->type = XFRM_DEV_OFFLOAD_UNSPECIFIED;
720 netdev_put(dev, &xso->dev_tracker);
721 }
722}
723#endif
724
f75a2804 725void __xfrm_state_destroy(struct xfrm_state *x, bool sync)
1da177e4 726{
547b792c 727 WARN_ON(x->km.state != XFRM_STATE_DEAD);
1da177e4 728
f75a2804
CW		 729 if (sync) {
730 synchronize_rcu();
731 ___xfrm_state_destroy(x);
732 } else {
733 spin_lock_bh(&xfrm_state_gc_lock);
734 hlist_add_head(&x->gclist, &xfrm_state_gc_list);
735 spin_unlock_bh(&xfrm_state_gc_lock);
736 schedule_work(&xfrm_state_gc_work);
737 }
1da177e4
LT		 738}
739EXPORT_SYMBOL(__xfrm_state_destroy);
740
53bc6b4d 741int __xfrm_state_delete(struct xfrm_state *x)
1da177e4 742{
98806f75 743 struct net *net = xs_net(x);
26b15dad
JHS		 744 int err = -ESRCH;
745
1da177e4
LT		 746 if (x->km.state != XFRM_STATE_DEAD) {
747 x->km.state = XFRM_STATE_DEAD;
0045e3d8 748
283bc9f3 749 spin_lock(&net->xfrm.xfrm_state_lock);
12a169e7 750 list_del(&x->km.all);
ae3fb6d3
FW		 751 hlist_del_rcu(&x->bydst);
752 hlist_del_rcu(&x->bysrc);
fe9f1d87
SD		 753 if (x->km.seq)
754 hlist_del_rcu(&x->byseq);
0045e3d8
SK		 755 if (!hlist_unhashed(&x->state_cache))
756 hlist_del_rcu(&x->state_cache);
81a331a0
SK		 757 if (!hlist_unhashed(&x->state_cache_input))
758 hlist_del_rcu(&x->state_cache_input);
759
a47f0ce0 760 if (x->id.spi)
ae3fb6d3 761 hlist_del_rcu(&x->byspi);
98806f75 762 net->xfrm.state_num--;
f531d13b 763 xfrm_nat_keepalive_state_updated(x);
283bc9f3 764 spin_unlock(&net->xfrm.xfrm_state_lock);
1da177e4 765
e27cca96
SD		 766 if (x->encap_sk)
767 sock_put(rcu_dereference_raw(x->encap_sk));
768
d77e38e6
SK		 769 xfrm_dev_state_delete(x);
770
1da177e4
LT		 771 /* All xfrm_state objects are created by xfrm_state_alloc.
772 * The xfrm_state_alloc call gives a reference, and that
773 * is what we are dropping here.
774 */
5dba4797 775 xfrm_state_put(x);
26b15dad 776 err = 0;
1da177e4 777 }
26b15dad
JHS		 778
779 return err;
1da177e4 780}
53bc6b4d 781EXPORT_SYMBOL(__xfrm_state_delete);
1da177e4 782
26b15dad 783int xfrm_state_delete(struct xfrm_state *x)
1da177e4 784{
26b15dad
JHS		 785 int err;
786
1da177e4 787 spin_lock_bh(&x->lock);
26b15dad 788 err = __xfrm_state_delete(x);
1da177e4 789 spin_unlock_bh(&x->lock);
26b15dad
JHS		 790
791 return err;
1da177e4
LT		 792}
793EXPORT_SYMBOL(xfrm_state_delete);
794
4aa2e62c
JL		 795#ifdef CONFIG_SECURITY_NETWORK_XFRM
796static inline int
2e71029e 797xfrm_state_flush_secctx_check(struct net *net, u8 proto, bool task_valid)
1da177e4 798{
4aa2e62c
JL		 799 int i, err = 0;
800
0e602451 801 for (i = 0; i <= net->xfrm.state_hmask; i++) {
4aa2e62c
JL		 802 struct xfrm_state *x;
803
b67bfe0d 804 hlist_for_each_entry(x, net->xfrm.state_bydst+i, bydst) {
4aa2e62c
JL		 805 if (xfrm_id_proto_match(x->id.proto, proto) &&
806 (err = security_xfrm_state_delete(x)) != 0) {
2e71029e 807 xfrm_audit_state_delete(x, 0, task_valid);
4aa2e62c
JL		 808 return err;
809 }
810 }
811 }
812
813 return err;
814}
d77e38e6
SK		 815
816static inline int
817xfrm_dev_state_flush_secctx_check(struct net *net, struct net_device *dev, bool task_valid)
818{
819 int i, err = 0;
820
821 for (i = 0; i <= net->xfrm.state_hmask; i++) {
822 struct xfrm_state *x;
87e0a94e 823 struct xfrm_dev_offload *xso;
d77e38e6
SK		 824
825 hlist_for_each_entry(x, net->xfrm.state_bydst+i, bydst) {
826 xso = &x->xso;
827
828 if (xso->dev == dev &&
829 (err = security_xfrm_state_delete(x)) != 0) {
830 xfrm_audit_state_delete(x, 0, task_valid);
831 return err;
832 }
833 }
834 }
835
836 return err;
837}
4aa2e62c
JL		 838#else
839static inline int
2e71029e 840xfrm_state_flush_secctx_check(struct net *net, u8 proto, bool task_valid)
4aa2e62c
JL		 841{
842 return 0;
843}
d77e38e6
SK		 844
845static inline int
846xfrm_dev_state_flush_secctx_check(struct net *net, struct net_device *dev, bool task_valid)
847{
848 return 0;
849}
4aa2e62c
JL		 850#endif
851
f75a2804 852int xfrm_state_flush(struct net *net, u8 proto, bool task_valid, bool sync)
4aa2e62c 853{
9e64cc95 854 int i, err = 0, cnt = 0;
1da177e4 855
283bc9f3 856 spin_lock_bh(&net->xfrm.xfrm_state_lock);
2e71029e 857 err = xfrm_state_flush_secctx_check(net, proto, task_valid);
4aa2e62c
JL		 858 if (err)
859 goto out;
860
9e64cc95 861 err = -ESRCH;
0e602451 862 for (i = 0; i <= net->xfrm.state_hmask; i++) {
8f126e37 863 struct xfrm_state *x;
1da177e4 864restart:
b67bfe0d 865 hlist_for_each_entry(x, net->xfrm.state_bydst+i, bydst) {
1da177e4 866 if (!xfrm_state_kern(x) &&
5794708f 867 xfrm_id_proto_match(x->id.proto, proto)) {
1da177e4 868 xfrm_state_hold(x);
283bc9f3 869 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1da177e4 870
161a09e7 871 err = xfrm_state_delete(x);
ab5f5e8b 872 xfrm_audit_state_delete(x, err ? 0 : 1,
2e71029e 873 task_valid);
f75a2804
CW		 874 if (sync)
875 xfrm_state_put_sync(x);
876 else
877 xfrm_state_put(x);
9e64cc95
JHS		 878 if (!err)
879 cnt++;
1da177e4 880
283bc9f3 881 spin_lock_bh(&net->xfrm.xfrm_state_lock);
1da177e4
LT		 882 goto restart;
883 }
884 }
885 }
dd269db8
AS		 886out:
887 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
e4db5b61 888 if (cnt)
9e64cc95 889 err = 0;
e4db5b61 890
4aa2e62c 891 return err;
1da177e4
LT		 892}
893EXPORT_SYMBOL(xfrm_state_flush);
894
d77e38e6
SK		 895int xfrm_dev_state_flush(struct net *net, struct net_device *dev, bool task_valid)
896{
07b87f9e
SK		 897 struct xfrm_state *x;
898 struct hlist_node *tmp;
899 struct xfrm_dev_offload *xso;
d77e38e6
SK		 900 int i, err = 0, cnt = 0;
901
902 spin_lock_bh(&net->xfrm.xfrm_state_lock);
903 err = xfrm_dev_state_flush_secctx_check(net, dev, task_valid);
904 if (err)
905 goto out;
906
907 err = -ESRCH;
908 for (i = 0; i <= net->xfrm.state_hmask; i++) {
d77e38e6
SK		 909restart:
910 hlist_for_each_entry(x, net->xfrm.state_bydst+i, bydst) {
911 xso = &x->xso;
912
913 if (!xfrm_state_kern(x) && xso->dev == dev) {
914 xfrm_state_hold(x);
915 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
916
917 err = xfrm_state_delete(x);
07b87f9e
SK		 918 xfrm_dev_state_free(x);
919
d77e38e6
SK		 920 xfrm_audit_state_delete(x, err ? 0 : 1,
921 task_valid);
922 xfrm_state_put(x);
923 if (!err)
924 cnt++;
925
926 spin_lock_bh(&net->xfrm.xfrm_state_lock);
927 goto restart;
928 }
929 }
930 }
931 if (cnt)
932 err = 0;
933
934out:
935 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
07b87f9e
SK		 936
937 spin_lock_bh(&xfrm_state_dev_gc_lock);
938restart_gc:
939 hlist_for_each_entry_safe(x, tmp, &xfrm_state_dev_gc_list, dev_gclist) {
940 xso = &x->xso;
941
942 if (xso->dev == dev) {
943 spin_unlock_bh(&xfrm_state_dev_gc_lock);
944 xfrm_dev_state_free(x);
945 spin_lock_bh(&xfrm_state_dev_gc_lock);
946 goto restart_gc;
947 }
948
949 }
950 spin_unlock_bh(&xfrm_state_dev_gc_lock);
951
952 xfrm_flush_gc();
953
d77e38e6
SK		 954 return err;
955}
956EXPORT_SYMBOL(xfrm_dev_state_flush);
957
e071041b 958void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si)
28d8909b 959{
283bc9f3 960 spin_lock_bh(&net->xfrm.xfrm_state_lock);
e071041b 961 si->sadcnt = net->xfrm.state_num;
ca92e173 962 si->sadhcnt = net->xfrm.state_hmask + 1;
28d8909b 963 si->sadhmcnt = xfrm_state_hashmax;
283bc9f3 964 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
28d8909b
JHS		 965}
966EXPORT_SYMBOL(xfrm_sad_getinfo);
967
bac95935
FW		 968static void
969__xfrm4_init_tempsel(struct xfrm_selector *sel, const struct flowi *fl)
970{
971 const struct flowi4 *fl4 = &fl->u.ip4;
972
973 sel->daddr.a4 = fl4->daddr;
974 sel->saddr.a4 = fl4->saddr;
975 sel->dport = xfrm_flowi_dport(fl, &fl4->uli);
976 sel->dport_mask = htons(0xffff);
977 sel->sport = xfrm_flowi_sport(fl, &fl4->uli);
978 sel->sport_mask = htons(0xffff);
979 sel->family = AF_INET;
980 sel->prefixlen_d = 32;
981 sel->prefixlen_s = 32;
982 sel->proto = fl4->flowi4_proto;
983 sel->ifindex = fl4->flowi4_oif;
984}
985
986static void
987__xfrm6_init_tempsel(struct xfrm_selector *sel, const struct flowi *fl)
988{
989 const struct flowi6 *fl6 = &fl->u.ip6;
990
991 /* Initialize temporary selector matching only to current session. */
992 *(struct in6_addr *)&sel->daddr = fl6->daddr;
993 *(struct in6_addr *)&sel->saddr = fl6->saddr;
994 sel->dport = xfrm_flowi_dport(fl, &fl6->uli);
995 sel->dport_mask = htons(0xffff);
996 sel->sport = xfrm_flowi_sport(fl, &fl6->uli);
997 sel->sport_mask = htons(0xffff);
998 sel->family = AF_INET6;
999 sel->prefixlen_d = 128;
1000 sel->prefixlen_s = 128;
1001 sel->proto = fl6->flowi6_proto;
1002 sel->ifindex = fl6->flowi6_oif;
1003}
1004
711059b9 1005static void
1a898592 1006xfrm_init_tempstate(struct xfrm_state *x, const struct flowi *fl,
04686013 1007 const struct xfrm_tmpl *tmpl,
33765d06 1008 const xfrm_address_t *daddr, const xfrm_address_t *saddr,
8444cf71 1009 unsigned short family)
1da177e4 1010{
bac95935
FW		 1011 switch (family) {
1012 case AF_INET:
1013 __xfrm4_init_tempsel(&x->sel, fl);
1014 break;
1015 case AF_INET6:
1016 __xfrm6_init_tempsel(&x->sel, fl);
1017 break;
1018 }
1019
5c1b9ab3 1020 x->id = tmpl->id;
bac95935 1021
5c1b9ab3
FW		 1022 switch (tmpl->encap_family) {
1023 case AF_INET:
1024 if (x->id.daddr.a4 == 0)
1025 x->id.daddr.a4 = daddr->a4;
1026 x->props.saddr = tmpl->saddr;
1027 if (x->props.saddr.a4 == 0)
1028 x->props.saddr.a4 = saddr->a4;
1029 break;
1030 case AF_INET6:
1031 if (ipv6_addr_any((struct in6_addr *)&x->id.daddr))
1032 memcpy(&x->id.daddr, daddr, sizeof(x->sel.daddr));
1033 memcpy(&x->props.saddr, &tmpl->saddr, sizeof(x->props.saddr));
1034 if (ipv6_addr_any((struct in6_addr *)&x->props.saddr))
1035 memcpy(&x->props.saddr, saddr, sizeof(x->props.saddr));
1036 break;
1037 }
3819a35f 1038
5c1b9ab3
FW		 1039 x->props.mode = tmpl->mode;
1040 x->props.reqid = tmpl->reqid;
1041 x->props.family = tmpl->encap_family;
1da177e4
LT		 1042}
1043
f8a70afa
LR		 1044static struct xfrm_state *__xfrm_state_lookup_all(struct net *net, u32 mark,
1045 const xfrm_address_t *daddr,
1046 __be32 spi, u8 proto,
1047 unsigned short family,
1048 struct xfrm_dev_offload *xdo)
1049{
1050 unsigned int h = xfrm_spi_hash(net, daddr, spi, proto, family);
1051 struct xfrm_state *x;
1052
1053 hlist_for_each_entry_rcu(x, net->xfrm.state_byspi + h, byspi) {
1054#ifdef CONFIG_XFRM_OFFLOAD
1055 if (xdo->type == XFRM_DEV_OFFLOAD_PACKET) {
1056 if (x->xso.type != XFRM_DEV_OFFLOAD_PACKET)
1057 /* HW states are in the head of list, there is
1058 * no need to iterate further.
1059 */
1060 break;
1061
1062 /* Packet offload: both policy and SA should
1063 * have same device.
1064 */
1065 if (xdo->dev != x->xso.dev)
1066 continue;
1067 } else if (x->xso.type == XFRM_DEV_OFFLOAD_PACKET)
1068 /* Skip HW policy for SW lookups */
1069 continue;
1070#endif
1071 if (x->props.family != family ||
1072 x->id.spi != spi ||
1073 x->id.proto != proto ||
1074 !xfrm_addr_equal(&x->id.daddr, daddr, family))
1075 continue;
1076
1077 if ((mark & x->mark.m) != x->mark.v)
1078 continue;
1079 if (!xfrm_state_hold_rcu(x))
1080 continue;
1081 return x;
1082 }
1083
1084 return NULL;
1085}
1086
9aa60088
DM		 1087static struct xfrm_state *__xfrm_state_lookup(struct net *net, u32 mark,
1088 const xfrm_address_t *daddr,
1089 __be32 spi, u8 proto,
1090 unsigned short family)
edcd5821 1091{
221df1ed 1092 unsigned int h = xfrm_spi_hash(net, daddr, spi, proto, family);
edcd5821
DM		 1093 struct xfrm_state *x;
1094
ae3fb6d3 1095 hlist_for_each_entry_rcu(x, net->xfrm.state_byspi + h, byspi) {
edcd5821
DM		 1096 if (x->props.family != family ||
1097 x->id.spi != spi ||
1802571b 1098 x->id.proto != proto ||
70e94e66 1099 !xfrm_addr_equal(&x->id.daddr, daddr, family))
edcd5821
DM		 1100 continue;
1101
3d6acfa7
JHS		 1102 if ((mark & x->mark.m) != x->mark.v)
1103 continue;
02efdff7
FW		 1104 if (!xfrm_state_hold_rcu(x))
1105 continue;
edcd5821
DM		 1106 return x;
1107 }
1108
1109 return NULL;
1110}
1111
81a331a0
SK		 1112struct xfrm_state *xfrm_input_state_lookup(struct net *net, u32 mark,
1113 const xfrm_address_t *daddr,
1114 __be32 spi, u8 proto,
1115 unsigned short family)
1116{
1117 struct hlist_head *state_cache_input;
1118 struct xfrm_state *x = NULL;
1119 int cpu = get_cpu();
1120
1121 state_cache_input = per_cpu_ptr(net->xfrm.state_cache_input, cpu);
1122
1123 rcu_read_lock();
1124 hlist_for_each_entry_rcu(x, state_cache_input, state_cache_input) {
1125 if (x->props.family != family ||
1126 x->id.spi != spi ||
1127 x->id.proto != proto ||
1128 !xfrm_addr_equal(&x->id.daddr, daddr, family))
1129 continue;
1130
1131 if ((mark & x->mark.m) != x->mark.v)
1132 continue;
1133 if (!xfrm_state_hold_rcu(x))
1134 continue;
1135 goto out;
1136 }
1137
1138 x = __xfrm_state_lookup(net, mark, daddr, spi, proto, family);
1139
1140 if (x && x->km.state == XFRM_STATE_VALID) {
1141 spin_lock_bh(&net->xfrm.xfrm_state_lock);
1142 if (hlist_unhashed(&x->state_cache_input)) {
1143 hlist_add_head_rcu(&x->state_cache_input, state_cache_input);
1144 } else {
1145 hlist_del_rcu(&x->state_cache_input);
1146 hlist_add_head_rcu(&x->state_cache_input, state_cache_input);
1147 }
1148 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1149 }
1150
1151out:
1152 rcu_read_unlock();
1153 put_cpu();
1154 return x;
1155}
1156EXPORT_SYMBOL(xfrm_input_state_lookup);
1157
9aa60088
DM		 1158static struct xfrm_state *__xfrm_state_lookup_byaddr(struct net *net, u32 mark,
1159 const xfrm_address_t *daddr,
1160 const xfrm_address_t *saddr,
1161 u8 proto, unsigned short family)
edcd5821 1162{
221df1ed 1163 unsigned int h = xfrm_src_hash(net, daddr, saddr, family);
edcd5821
DM		 1164 struct xfrm_state *x;
1165
ae3fb6d3 1166 hlist_for_each_entry_rcu(x, net->xfrm.state_bysrc + h, bysrc) {
edcd5821 1167 if (x->props.family != family ||
1802571b 1168 x->id.proto != proto ||
70e94e66
YH		 1169 !xfrm_addr_equal(&x->id.daddr, daddr, family) ||
1170 !xfrm_addr_equal(&x->props.saddr, saddr, family))
edcd5821
DM		 1171 continue;
1172
3d6acfa7
JHS		 1173 if ((mark & x->mark.m) != x->mark.v)
1174 continue;
02efdff7
FW		 1175 if (!xfrm_state_hold_rcu(x))
1176 continue;
edcd5821
DM		 1177 return x;
1178 }
1179
1180 return NULL;
1181}
1182
1183static inline struct xfrm_state *
1184__xfrm_state_locate(struct xfrm_state *x, int use_spi, int family)
1185{
221df1ed 1186 struct net *net = xs_net(x);
bd55775c 1187 u32 mark = x->mark.v & x->mark.m;
221df1ed 1188
edcd5821 1189 if (use_spi)
bd55775c
JHS		 1190 return __xfrm_state_lookup(net, mark, &x->id.daddr,
1191 x->id.spi, x->id.proto, family);
edcd5821 1192 else
bd55775c
JHS		 1193 return __xfrm_state_lookup_byaddr(net, mark,
1194 &x->id.daddr,
edcd5821
DM		 1195 &x->props.saddr,
1196 x->id.proto, family);
1197}
1198
98806f75 1199static void xfrm_hash_grow_check(struct net *net, int have_hash_collision)
2fab22f2
PM		 1200{
1201 if (have_hash_collision &&
98806f75
AD		 1202 (net->xfrm.state_hmask + 1) < xfrm_state_hashmax &&
1203 net->xfrm.state_num > net->xfrm.state_hmask)
1204 schedule_work(&net->xfrm.state_hash_work);
2fab22f2
PM		 1205}
1206
08ec9af1 1207static void xfrm_state_look_at(struct xfrm_policy *pol, struct xfrm_state *x,
4a08ab0f 1208 const struct flowi *fl, unsigned short family,
08ec9af1
DM		 1209 struct xfrm_state **best, int *acq_in_progress,
1210 int *error)
1211{
1ddf9916
SK		 1212 /* We need the cpu id just as a lookup key,
1213 * we don't require it to be stable.
1214 */
1215 unsigned int pcpu_id = get_cpu();
1216 put_cpu();
1217
08ec9af1
DM		 1218 /* Resolution logic:
1219 * 1. There is a valid state with matching selector. Done.
1220 * 2. Valid state with inappropriate selector. Skip.
1221 *
1222 * Entering area of "sysdeps".
1223 *
1224 * 3. If state is not valid, selector is temporary, it selects
1225 * only session which triggered previous resolution. Key
1226 * manager will do something to install a state with proper
1227 * selector.
1228 */
1229 if (x->km.state == XFRM_STATE_VALID) {
1230 if ((x->sel.family &&
e94ee171
HX		 1231 (x->sel.family != family ||
1232 !xfrm_selector_match(&x->sel, fl, family))) ||
3df98d79
PM		 1233 !security_xfrm_state_pol_flow_match(x, pol,
1234 &fl->u.__fl_common))
08ec9af1
DM		 1235 return;
1236
1ddf9916
SK		 1237 if (x->pcpu_num != UINT_MAX && x->pcpu_num != pcpu_id)
1238 return;
1239
08ec9af1 1240 if (!*best ||
1ddf9916 1241 ((*best)->pcpu_num == UINT_MAX && x->pcpu_num == pcpu_id) ||
08ec9af1
DM		 1242 (*best)->km.dying > x->km.dying ||
1243 ((*best)->km.dying == x->km.dying &&
1244 (*best)->curlft.add_time < x->curlft.add_time))
1245 *best = x;
1246 } else if (x->km.state == XFRM_STATE_ACQ) {
1ddf9916
SK		 1247 if (!*best || x->pcpu_num == pcpu_id)
1248 *acq_in_progress = 1;
08ec9af1
DM		 1249 } else if (x->km.state == XFRM_STATE_ERROR ||
1250 x->km.state == XFRM_STATE_EXPIRED) {
e94ee171
HX		 1251 if ((!x->sel.family ||
1252 (x->sel.family == family &&
1253 xfrm_selector_match(&x->sel, fl, family))) &&
3df98d79
PM		 1254 security_xfrm_state_pol_flow_match(x, pol,
1255 &fl->u.__fl_common))
08ec9af1
DM		 1256 *error = -ESRCH;
1257 }
1258}
1259
1da177e4 1260struct xfrm_state *
33765d06 1261xfrm_state_find(const xfrm_address_t *daddr, const xfrm_address_t *saddr,
b520e9f6 1262 const struct flowi *fl, struct xfrm_tmpl *tmpl,
1da177e4 1263 struct xfrm_policy *pol, int *err,
bc56b334 1264 unsigned short family, u32 if_id)
1da177e4 1265{
08ec9af1 1266 static xfrm_address_t saddr_wildcard = { };
5447c5e4 1267 struct net *net = xp_net(pol);
6a783c90 1268 unsigned int h, h_wildcard;
37b08e34 1269 struct xfrm_state *x, *x0, *to_put;
1da177e4
LT		 1270 int acquire_in_progress = 0;
1271 int error = 0;
1272 struct xfrm_state *best = NULL;
bd55775c 1273 u32 mark = pol->mark.v & pol->mark.m;
8444cf71 1274 unsigned short encap_family = tmpl->encap_family;
b65e3d7b 1275 unsigned int sequence;
0f24558e 1276 struct km_event c;
1ddf9916 1277 unsigned int pcpu_id;
0045e3d8 1278 bool cached = false;
1ddf9916
SK		 1279
1280 /* We need the cpu id just as a lookup key,
1281 * we don't require it to be stable.
1282 */
1283 pcpu_id = get_cpu();
1284 put_cpu();
a716c119 1285
37b08e34
DM		 1286 to_put = NULL;
1287
e88add19 1288 sequence = read_seqcount_begin(&net->xfrm.xfrm_state_hash_generation);
b65e3d7b 1289
d737a580 1290 rcu_read_lock();
0045e3d8
SK		 1291 hlist_for_each_entry_rcu(x, &pol->state_cache_list, state_cache) {
1292 if (x->props.family == encap_family &&
1293 x->props.reqid == tmpl->reqid &&
1294 (mark & x->mark.m) == x->mark.v &&
1295 x->if_id == if_id &&
1296 !(x->props.flags & XFRM_STATE_WILDRECV) &&
1297 xfrm_state_addr_check(x, daddr, saddr, encap_family) &&
1298 tmpl->mode == x->props.mode &&
1299 tmpl->id.proto == x->id.proto &&
1300 (tmpl->id.spi == x->id.spi || !tmpl->id.spi))
1301 xfrm_state_look_at(pol, x, fl, encap_family,
1302 &best, &acquire_in_progress, &error);
1303 }
1304
1305 if (best)
1306 goto cached;
1307
1308 hlist_for_each_entry_rcu(x, &pol->state_cache_list, state_cache) {
1309 if (x->props.family == encap_family &&
1310 x->props.reqid == tmpl->reqid &&
1311 (mark & x->mark.m) == x->mark.v &&
1312 x->if_id == if_id &&
1313 !(x->props.flags & XFRM_STATE_WILDRECV) &&
1314 xfrm_addr_equal(&x->id.daddr, daddr, encap_family) &&
1315 tmpl->mode == x->props.mode &&
1316 tmpl->id.proto == x->id.proto &&
1317 (tmpl->id.spi == x->id.spi || !tmpl->id.spi))
1318 xfrm_state_look_at(pol, x, fl, family,
1319 &best, &acquire_in_progress, &error);
1320 }
1321
1322cached:
1323 cached = true;
1324 if (best)
1325 goto found;
1326 else if (error)
1327 best = NULL;
1328 else if (acquire_in_progress) /* XXX: acquire_in_progress should not happen */
1329 WARN_ON(1);
1330
8444cf71 1331 h = xfrm_dst_hash(net, daddr, saddr, tmpl->reqid, encap_family);
ae3fb6d3 1332 hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h, bydst) {
f8a70afa
LR		 1333#ifdef CONFIG_XFRM_OFFLOAD
1334 if (pol->xdo.type == XFRM_DEV_OFFLOAD_PACKET) {
1335 if (x->xso.type != XFRM_DEV_OFFLOAD_PACKET)
1336 /* HW states are in the head of list, there is
1337 * no need to iterate further.
1338 */
1339 break;
1340
1341 /* Packet offload: both policy and SA should
1342 * have same device.
1343 */
1344 if (pol->xdo.dev != x->xso.dev)
1345 continue;
1346 } else if (x->xso.type == XFRM_DEV_OFFLOAD_PACKET)
1347 /* Skip HW policy for SW lookups */
1348 continue;
1349#endif
8444cf71 1350 if (x->props.family == encap_family &&
1da177e4 1351 x->props.reqid == tmpl->reqid &&
3d6acfa7 1352 (mark & x->mark.m) == x->mark.v &&
7e652640 1353 x->if_id == if_id &&
fbd9a5b4 1354 !(x->props.flags & XFRM_STATE_WILDRECV) &&
8444cf71 1355 xfrm_state_addr_check(x, daddr, saddr, encap_family) &&
1da177e4
LT		 1356 tmpl->mode == x->props.mode &&
1357 tmpl->id.proto == x->id.proto &&
08ec9af1 1358 (tmpl->id.spi == x->id.spi || !tmpl->id.spi))
e94ee171 1359 xfrm_state_look_at(pol, x, fl, family,
08ec9af1
DM		 1360 &best, &acquire_in_progress, &error);
1361 }
6f115638 1362 if (best || acquire_in_progress)
08ec9af1
DM		 1363 goto found;
1364
8444cf71 1365 h_wildcard = xfrm_dst_hash(net, daddr, &saddr_wildcard, tmpl->reqid, encap_family);
ae3fb6d3 1366 hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h_wildcard, bydst) {
f8a70afa
LR		 1367#ifdef CONFIG_XFRM_OFFLOAD
1368 if (pol->xdo.type == XFRM_DEV_OFFLOAD_PACKET) {
1369 if (x->xso.type != XFRM_DEV_OFFLOAD_PACKET)
1370 /* HW states are in the head of list, there is
1371 * no need to iterate further.
1372 */
1373 break;
1374
1375 /* Packet offload: both policy and SA should
1376 * have same device.
1377 */
1378 if (pol->xdo.dev != x->xso.dev)
1379 continue;
1380 } else if (x->xso.type == XFRM_DEV_OFFLOAD_PACKET)
1381 /* Skip HW policy for SW lookups */
1382 continue;
1383#endif
8444cf71 1384 if (x->props.family == encap_family &&
08ec9af1 1385 x->props.reqid == tmpl->reqid &&
3d6acfa7 1386 (mark & x->mark.m) == x->mark.v &&
7e652640 1387 x->if_id == if_id &&
08ec9af1 1388 !(x->props.flags & XFRM_STATE_WILDRECV) &&
f59bbdfa 1389 xfrm_addr_equal(&x->id.daddr, daddr, encap_family) &&
08ec9af1
DM		 1390 tmpl->mode == x->props.mode &&
1391 tmpl->id.proto == x->id.proto &&
1392 (tmpl->id.spi == x->id.spi || !tmpl->id.spi))
e94ee171 1393 xfrm_state_look_at(pol, x, fl, family,
08ec9af1 1394 &best, &acquire_in_progress, &error);
1da177e4
LT		 1395 }
1396
08ec9af1 1397found:
1ddf9916
SK		 1398 if (!(pol->flags & XFRM_POLICY_CPU_ACQUIRE) ||
1399 (best && (best->pcpu_num == pcpu_id)))
1400 x = best;
1401
1da177e4 1402 if (!x && !error && !acquire_in_progress) {
5c5d281a 1403 if (tmpl->id.spi &&
f8a70afa
LR		 1404 (x0 = __xfrm_state_lookup_all(net, mark, daddr,
1405 tmpl->id.spi, tmpl->id.proto,
1406 encap_family,
1407 &pol->xdo)) != NULL) {
37b08e34 1408 to_put = x0;
1da177e4
LT		 1409 error = -EEXIST;
1410 goto out;
1411 }
0f24558e
HG		 1412
1413 c.net = net;
1414 /* If the KMs have no listeners (yet...), avoid allocating an SA
1415 * for each and every packet - garbage collection might not
1416 * handle the flood.
1417 */
1418 if (!km_is_alive(&c)) {
1419 error = -ESRCH;
1420 goto out;
1421 }
1422
5447c5e4 1423 x = xfrm_state_alloc(net);
1da177e4
LT		 1424 if (x == NULL) {
1425 error = -ENOMEM;
1426 goto out;
1427 }
8444cf71 1428 /* Initialize temporary state matching only
1da177e4 1429 * to current session. */
8444cf71 1430 xfrm_init_tempstate(x, fl, tmpl, daddr, saddr, family);
bd55775c 1431 memcpy(&x->mark, &pol->mark, sizeof(x->mark));
7e652640 1432 x->if_id = if_id;
1ddf9916
SK		 1433 if ((pol->flags & XFRM_POLICY_CPU_ACQUIRE) && best)
1434 x->pcpu_num = pcpu_id;
1da177e4 1435
1d28f42c 1436 error = security_xfrm_state_alloc_acquire(x, pol->security, fl->flowi_secid);
e0d1caa7
VY		 1437 if (error) {
1438 x->km.state = XFRM_STATE_DEAD;
37b08e34 1439 to_put = x;
e0d1caa7
VY		 1440 x = NULL;
1441 goto out;
1442 }
f8a70afa
LR		 1443#ifdef CONFIG_XFRM_OFFLOAD
1444 if (pol->xdo.type == XFRM_DEV_OFFLOAD_PACKET) {
1445 struct xfrm_dev_offload *xdo = &pol->xdo;
1446 struct xfrm_dev_offload *xso = &x->xso;
1447
1448 xso->type = XFRM_DEV_OFFLOAD_PACKET;
1449 xso->dir = xdo->dir;
1450 xso->dev = xdo->dev;
1451 xso->real_dev = xdo->real_dev;
e0aeb9b9 1452 xso->flags = XFRM_DEV_OFFLOAD_FLAG_ACQ;
9199b915 1453 netdev_hold(xso->dev, &xso->dev_tracker, GFP_ATOMIC);
7681a4f5 1454 error = xso->dev->xfrmdev_ops->xdo_dev_state_add(x, NULL);
f8a70afa
LR		 1455 if (error) {
1456 xso->dir = 0;
1457 netdev_put(xso->dev, &xso->dev_tracker);
1458 xso->dev = NULL;
1459 xso->real_dev = NULL;
1460 xso->type = XFRM_DEV_OFFLOAD_UNSPECIFIED;
1461 x->km.state = XFRM_STATE_DEAD;
1462 to_put = x;
1463 x = NULL;
1464 goto out;
1465 }
1466 }
1467#endif
1da177e4 1468 if (km_query(x, tmpl, pol) == 0) {
d737a580 1469 spin_lock_bh(&net->xfrm.xfrm_state_lock);
1da177e4 1470 x->km.state = XFRM_STATE_ACQ;
a4a87fa4 1471 x->dir = XFRM_SA_DIR_OUT;
5447c5e4 1472 list_add(&x->km.all, &net->xfrm.state_all);
3c611d40
LR		 1473 XFRM_STATE_INSERT(bydst, &x->bydst,
1474 net->xfrm.state_bydst + h,
1475 x->xso.type);
8444cf71 1476 h = xfrm_src_hash(net, daddr, saddr, encap_family);
3c611d40
LR		 1477 XFRM_STATE_INSERT(bysrc, &x->bysrc,
1478 net->xfrm.state_bysrc + h,
1479 x->xso.type);
0045e3d8 1480 INIT_HLIST_NODE(&x->state_cache);
1da177e4 1481 if (x->id.spi) {
8444cf71 1482 h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto, encap_family);
3c611d40
LR		 1483 XFRM_STATE_INSERT(byspi, &x->byspi,
1484 net->xfrm.state_byspi + h,
1485 x->xso.type);
1da177e4 1486 }
fe9f1d87
SD		 1487 if (x->km.seq) {
1488 h = xfrm_seq_hash(net, x->km.seq);
3c611d40
LR		 1489 XFRM_STATE_INSERT(byseq, &x->byseq,
1490 net->xfrm.state_byseq + h,
1491 x->xso.type);
fe9f1d87 1492 }
b27aeadb 1493 x->lft.hard_add_expires_seconds = net->xfrm.sysctl_acq_expires;
671422b2
TG		 1494 hrtimer_start(&x->mtimer,
1495 ktime_set(net->xfrm.sysctl_acq_expires, 0),
1496 HRTIMER_MODE_REL_SOFT);
5447c5e4
AD		 1497 net->xfrm.state_num++;
1498 xfrm_hash_grow_check(net, x->bydst.next != NULL);
d737a580 1499 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1da177e4 1500 } else {
f8a70afa
LR		 1501#ifdef CONFIG_XFRM_OFFLOAD
1502 struct xfrm_dev_offload *xso = &x->xso;
1503
1504 if (xso->type == XFRM_DEV_OFFLOAD_PACKET) {
f3ec2b5d
LR		 1505 xfrm_dev_state_delete(x);
1506 xfrm_dev_state_free(x);
f8a70afa
LR		 1507 }
1508#endif
1da177e4 1509 x->km.state = XFRM_STATE_DEAD;
37b08e34 1510 to_put = x;
1da177e4
LT		 1511 x = NULL;
1512 error = -ESRCH;
1513 }
1ddf9916
SK		 1514
1515 /* Use the already installed 'fallback' while the CPU-specific
1516 * SA acquire is handled*/
1517 if (best)
1518 x = best;
1da177e4
LT		 1519 }
1520out:
02efdff7
FW		 1521 if (x) {
1522 if (!xfrm_state_hold_rcu(x)) {
1523 *err = -EAGAIN;
1524 x = NULL;
1525 }
1526 } else {
1da177e4 1527 *err = acquire_in_progress ? -EAGAIN : error;
02efdff7 1528 }
0045e3d8
SK		 1529
1530 if (x && x->km.state == XFRM_STATE_VALID && !cached &&
1531 (!(pol->flags & XFRM_POLICY_CPU_ACQUIRE) || x->pcpu_num == pcpu_id)) {
1532 spin_lock_bh(&net->xfrm.xfrm_state_lock);
1533 if (hlist_unhashed(&x->state_cache))
1534 hlist_add_head_rcu(&x->state_cache, &pol->state_cache_list);
1535 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1536 }
1537
d737a580 1538 rcu_read_unlock();
37b08e34
DM		 1539 if (to_put)
1540 xfrm_state_put(to_put);
b65e3d7b 1541
e88add19 1542 if (read_seqcount_retry(&net->xfrm.xfrm_state_hash_generation, sequence)) {
b65e3d7b
FW		 1543 *err = -EAGAIN;
1544 if (x) {
1545 xfrm_state_put(x);
1546 x = NULL;
1547 }
1548 }
1549
1da177e4
LT		 1550 return x;
1551}
1552
628529b6 1553struct xfrm_state *
7e652640 1554xfrm_stateonly_find(struct net *net, u32 mark, u32 if_id,
5447c5e4 1555 xfrm_address_t *daddr, xfrm_address_t *saddr,
628529b6
JHS		 1556 unsigned short family, u8 mode, u8 proto, u32 reqid)
1557{
4bda4f25 1558 unsigned int h;
628529b6 1559 struct xfrm_state *rx = NULL, *x = NULL;
628529b6 1560
4ae770bf 1561 spin_lock_bh(&net->xfrm.xfrm_state_lock);
5447c5e4 1562 h = xfrm_dst_hash(net, daddr, saddr, reqid, family);
b67bfe0d 1563 hlist_for_each_entry(x, net->xfrm.state_bydst+h, bydst) {
628529b6
JHS		 1564 if (x->props.family == family &&
1565 x->props.reqid == reqid &&
3d6acfa7 1566 (mark & x->mark.m) == x->mark.v &&
7e652640 1567 x->if_id == if_id &&
628529b6
JHS		 1568 !(x->props.flags & XFRM_STATE_WILDRECV) &&
1569 xfrm_state_addr_check(x, daddr, saddr, family) &&
1570 mode == x->props.mode &&
1571 proto == x->id.proto &&
1572 x->km.state == XFRM_STATE_VALID) {
1573 rx = x;
1574 break;
1575 }
1576 }
1577
1578 if (rx)
1579 xfrm_state_hold(rx);
4ae770bf 1580 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
628529b6
JHS		 1581
1582
1583 return rx;
1584}
1585EXPORT_SYMBOL(xfrm_stateonly_find);
1586
c454997e
FD		 1587struct xfrm_state *xfrm_state_lookup_byspi(struct net *net, __be32 spi,
1588 unsigned short family)
1589{
1590 struct xfrm_state *x;
1591 struct xfrm_state_walk *w;
1592
1593 spin_lock_bh(&net->xfrm.xfrm_state_lock);
1594 list_for_each_entry(w, &net->xfrm.state_all, all) {
1595 x = container_of(w, struct xfrm_state, km);
1596 if (x->props.family != family ||
1597 x->id.spi != spi)
1598 continue;
1599
c454997e 1600 xfrm_state_hold(x);
bdddbf69 1601 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
c454997e
FD		 1602 return x;
1603 }
1604 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1605 return NULL;
1606}
1607EXPORT_SYMBOL(xfrm_state_lookup_byspi);
1608
1da177e4
LT		 1609static void __xfrm_state_insert(struct xfrm_state *x)
1610{
98806f75 1611 struct net *net = xs_net(x);
a624c108 1612 unsigned int h;
1da177e4 1613
98806f75 1614 list_add(&x->km.all, &net->xfrm.state_all);
4c563f76 1615
98806f75 1616 h = xfrm_dst_hash(net, &x->id.daddr, &x->props.saddr,
c1969f29 1617 x->props.reqid, x->props.family);
3c611d40
LR		 1618 XFRM_STATE_INSERT(bydst, &x->bydst, net->xfrm.state_bydst + h,
1619 x->xso.type);
1da177e4 1620
98806f75 1621 h = xfrm_src_hash(net, &x->id.daddr, &x->props.saddr, x->props.family);
3c611d40
LR		 1622 XFRM_STATE_INSERT(bysrc, &x->bysrc, net->xfrm.state_bysrc + h,
1623 x->xso.type);
1da177e4 1624
7b4dc360 1625 if (x->id.spi) {
98806f75 1626 h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto,
6c44e6b7
MN		 1627 x->props.family);
1628
3c611d40
LR		 1629 XFRM_STATE_INSERT(byspi, &x->byspi, net->xfrm.state_byspi + h,
1630 x->xso.type);
6c44e6b7
MN		 1631 }
1632
fe9f1d87
SD		 1633 if (x->km.seq) {
1634 h = xfrm_seq_hash(net, x->km.seq);
1635
3c611d40
LR		 1636 XFRM_STATE_INSERT(byseq, &x->byseq, net->xfrm.state_byseq + h,
1637 x->xso.type);
fe9f1d87
SD		 1638 }
1639
671422b2 1640 hrtimer_start(&x->mtimer, ktime_set(1, 0), HRTIMER_MODE_REL_SOFT);
a47f0ce0
DM		 1641 if (x->replay_maxage)
1642 mod_timer(&x->rtimer, jiffies + x->replay_maxage);
f8cd5488 1643
98806f75 1644 net->xfrm.state_num++;
f034b5d4 1645
98806f75 1646 xfrm_hash_grow_check(net, x->bydst.next != NULL);
f531d13b 1647 xfrm_nat_keepalive_state_updated(x);
1da177e4
LT		 1648}
1649
283bc9f3 1650/* net->xfrm.xfrm_state_lock is held */
c7f5ea3a
DM		 1651static void __xfrm_state_bump_genids(struct xfrm_state *xnew)
1652{
98806f75 1653 struct net *net = xs_net(xnew);
c7f5ea3a
DM		 1654 unsigned short family = xnew->props.family;
1655 u32 reqid = xnew->props.reqid;
1656 struct xfrm_state *x;
c7f5ea3a 1657 unsigned int h;
3d6acfa7 1658 u32 mark = xnew->mark.v & xnew->mark.m;
7e652640 1659 u32 if_id = xnew->if_id;
1ddf9916 1660 u32 cpu_id = xnew->pcpu_num;
c7f5ea3a 1661
98806f75 1662 h = xfrm_dst_hash(net, &xnew->id.daddr, &xnew->props.saddr, reqid, family);
b67bfe0d 1663 hlist_for_each_entry(x, net->xfrm.state_bydst+h, bydst) {
c7f5ea3a
DM		 1664 if (x->props.family == family &&
1665 x->props.reqid == reqid &&
7e652640 1666 x->if_id == if_id &&
1ddf9916 1667 x->pcpu_num == cpu_id &&
3d6acfa7 1668 (mark & x->mark.m) == x->mark.v &&
70e94e66
YH		 1669 xfrm_addr_equal(&x->id.daddr, &xnew->id.daddr, family) &&
1670 xfrm_addr_equal(&x->props.saddr, &xnew->props.saddr, family))
34996cb9 1671 x->genid++;
c7f5ea3a
DM		 1672 }
1673}
1674
1da177e4
LT		 1675void xfrm_state_insert(struct xfrm_state *x)
1676{
283bc9f3
FD		 1677 struct net *net = xs_net(x);
1678
1679 spin_lock_bh(&net->xfrm.xfrm_state_lock);
c7f5ea3a 1680 __xfrm_state_bump_genids(x);
1da177e4 1681 __xfrm_state_insert(x);
283bc9f3 1682 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1da177e4
LT		 1683}
1684EXPORT_SYMBOL(xfrm_state_insert);
1685
283bc9f3 1686/* net->xfrm.xfrm_state_lock is held */
e473fcb4
MK		 1687static struct xfrm_state *__find_acq_core(struct net *net,
1688 const struct xfrm_mark *m,
a70486f0 1689 unsigned short family, u8 mode,
1ddf9916 1690 u32 reqid, u32 if_id, u32 pcpu_num, u8 proto,
a70486f0 1691 const xfrm_address_t *daddr,
e473fcb4
MK		 1692 const xfrm_address_t *saddr,
1693 int create)
2770834c 1694{
5447c5e4 1695 unsigned int h = xfrm_dst_hash(net, daddr, saddr, reqid, family);
2770834c 1696 struct xfrm_state *x;
3d6acfa7 1697 u32 mark = m->v & m->m;
2770834c 1698
b67bfe0d 1699 hlist_for_each_entry(x, net->xfrm.state_bydst+h, bydst) {
2770834c
DM		 1700 if (x->props.reqid != reqid ||
1701 x->props.mode != mode ||
1702 x->props.family != family ||
1703 x->km.state != XFRM_STATE_ACQ ||
75e252d9 1704 x->id.spi != 0 ||
1802571b 1705 x->id.proto != proto ||
3d6acfa7 1706 (mark & x->mark.m) != x->mark.v ||
1ddf9916 1707 x->pcpu_num != pcpu_num ||
70e94e66
YH		 1708 !xfrm_addr_equal(&x->id.daddr, daddr, family) ||
1709 !xfrm_addr_equal(&x->props.saddr, saddr, family))
2770834c
DM		 1710 continue;
1711
2770834c
DM		 1712 xfrm_state_hold(x);
1713 return x;
1714 }
1715
1716 if (!create)
1717 return NULL;
1718
5447c5e4 1719 x = xfrm_state_alloc(net);
2770834c
DM		 1720 if (likely(x)) {
1721 switch (family) {
1722 case AF_INET:
1723 x->sel.daddr.a4 = daddr->a4;
1724 x->sel.saddr.a4 = saddr->a4;
1725 x->sel.prefixlen_d = 32;
1726 x->sel.prefixlen_s = 32;
1727 x->props.saddr.a4 = saddr->a4;
1728 x->id.daddr.a4 = daddr->a4;
1729 break;
1730
1731 case AF_INET6:
15e318bd
JB		 1732 x->sel.daddr.in6 = daddr->in6;
1733 x->sel.saddr.in6 = saddr->in6;
2770834c
DM		 1734 x->sel.prefixlen_d = 128;
1735 x->sel.prefixlen_s = 128;
15e318bd
JB		 1736 x->props.saddr.in6 = saddr->in6;
1737 x->id.daddr.in6 = daddr->in6;
2770834c 1738 break;
3ff50b79 1739 }
2770834c 1740
1ddf9916 1741 x->pcpu_num = pcpu_num;
2770834c
DM		 1742 x->km.state = XFRM_STATE_ACQ;
1743 x->id.proto = proto;
1744 x->props.family = family;
1745 x->props.mode = mode;
1746 x->props.reqid = reqid;
7e652640 1747 x->if_id = if_id;
bd55775c
JHS		 1748 x->mark.v = m->v;
1749 x->mark.m = m->m;
b27aeadb 1750 x->lft.hard_add_expires_seconds = net->xfrm.sysctl_acq_expires;
2770834c 1751 xfrm_state_hold(x);
671422b2
TG		 1752 hrtimer_start(&x->mtimer,
1753 ktime_set(net->xfrm.sysctl_acq_expires, 0),
1754 HRTIMER_MODE_REL_SOFT);
5447c5e4 1755 list_add(&x->km.all, &net->xfrm.state_all);
3c611d40
LR		 1756 XFRM_STATE_INSERT(bydst, &x->bydst, net->xfrm.state_bydst + h,
1757 x->xso.type);
5447c5e4 1758 h = xfrm_src_hash(net, daddr, saddr, family);
3c611d40
LR		 1759 XFRM_STATE_INSERT(bysrc, &x->bysrc, net->xfrm.state_bysrc + h,
1760 x->xso.type);
918049f0 1761
5447c5e4 1762 net->xfrm.state_num++;
918049f0 1763
5447c5e4 1764 xfrm_hash_grow_check(net, x->bydst.next != NULL);
2770834c
DM		 1765 }
1766
1767 return x;
1768}
1769
1ddf9916 1770static struct xfrm_state *__xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq, u32 pcpu_num);
1da177e4
LT		 1771
1772int xfrm_state_add(struct xfrm_state *x)
1773{
5447c5e4 1774 struct net *net = xs_net(x);
37b08e34 1775 struct xfrm_state *x1, *to_put;
1da177e4
LT		 1776 int family;
1777 int err;
bd55775c 1778 u32 mark = x->mark.v & x->mark.m;
eb2971b6 1779 int use_spi = xfrm_id_proto_match(x->id.proto, IPSEC_PROTO_ANY);
1da177e4
LT		 1780
1781 family = x->props.family;
1da177e4 1782
37b08e34
DM		 1783 to_put = NULL;
1784
283bc9f3 1785 spin_lock_bh(&net->xfrm.xfrm_state_lock);
1da177e4 1786
edcd5821 1787 x1 = __xfrm_state_locate(x, use_spi, family);
1da177e4 1788 if (x1) {
37b08e34 1789 to_put = x1;
1da177e4
LT		 1790 x1 = NULL;
1791 err = -EEXIST;
1792 goto out;
1793 }
1794
eb2971b6 1795 if (use_spi && x->km.seq) {
1ddf9916 1796 x1 = __xfrm_find_acq_byseq(net, mark, x->km.seq, x->pcpu_num);
75e252d9 1797 if (x1 && ((x1->id.proto != x->id.proto) ||
70e94e66 1798 !xfrm_addr_equal(&x1->id.daddr, &x->id.daddr, family))) {
37b08e34 1799 to_put = x1;
1da177e4
LT		 1800 x1 = NULL;
1801 }
1802 }
1803
eb2971b6 1804 if (use_spi && !x1)
bd55775c 1805 x1 = __find_acq_core(net, &x->mark, family, x->props.mode,
1ddf9916 1806 x->props.reqid, x->if_id, x->pcpu_num, x->id.proto,
2770834c 1807 &x->id.daddr, &x->props.saddr, 0);
1da177e4 1808
c7f5ea3a 1809 __xfrm_state_bump_genids(x);
1da177e4
LT		 1810 __xfrm_state_insert(x);
1811 err = 0;
1812
1813out:
283bc9f3 1814 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1da177e4
LT		 1815
1816 if (x1) {
1817 xfrm_state_delete(x1);
1818 xfrm_state_put(x1);
1819 }
1820
37b08e34
DM		 1821 if (to_put)
1822 xfrm_state_put(to_put);
1823
1da177e4
LT		 1824 return err;
1825}
1826EXPORT_SYMBOL(xfrm_state_add);
1827
80c9abaa 1828#ifdef CONFIG_XFRM_MIGRATE
7aa05d30
AA		 1829static inline int clone_security(struct xfrm_state *x, struct xfrm_sec_ctx *security)
1830{
1831 struct xfrm_user_sec_ctx *uctx;
1832 int size = sizeof(*uctx) + security->ctx_len;
1833 int err;
1834
1835 uctx = kmalloc(size, GFP_KERNEL);
1836 if (!uctx)
1837 return -ENOMEM;
1838
1839 uctx->exttype = XFRMA_SEC_CTX;
1840 uctx->len = size;
1841 uctx->ctx_doi = security->ctx_doi;
1842 uctx->ctx_alg = security->ctx_alg;
1843 uctx->ctx_len = security->ctx_len;
1844 memcpy(uctx + 1, security->ctx_str, security->ctx_len);
1845 err = security_xfrm_state_alloc(x, uctx);
1846 kfree(uctx);
1847 if (err)
1848 return err;
1849
1850 return 0;
1851}
1852
4ab47d47
AA		 1853static struct xfrm_state *xfrm_state_clone(struct xfrm_state *orig,
1854 struct xfrm_encap_tmpl *encap)
80c9abaa 1855{
98806f75 1856 struct net *net = xs_net(orig);
98806f75 1857 struct xfrm_state *x = xfrm_state_alloc(net);
80c9abaa 1858 if (!x)
553f9118 1859 goto out;
80c9abaa
SS		 1860
1861 memcpy(&x->id, &orig->id, sizeof(x->id));
1862 memcpy(&x->sel, &orig->sel, sizeof(x->sel));
1863 memcpy(&x->lft, &orig->lft, sizeof(x->lft));
1864 x->props.mode = orig->props.mode;
1865 x->props.replay_window = orig->props.replay_window;
1866 x->props.reqid = orig->props.reqid;
1867 x->props.family = orig->props.family;
1868 x->props.saddr = orig->props.saddr;
1869
1870 if (orig->aalg) {
4447bb33 1871 x->aalg = xfrm_algo_auth_clone(orig->aalg);
80c9abaa
SS		 1872 if (!x->aalg)
1873 goto error;
1874 }
1875 x->props.aalgo = orig->props.aalgo;
1876
ee5c2317
SK		 1877 if (orig->aead) {
1878 x->aead = xfrm_algo_aead_clone(orig->aead);
75bf50f4 1879 x->geniv = orig->geniv;
ee5c2317
SK		 1880 if (!x->aead)
1881 goto error;
1882 }
80c9abaa
SS		 1883 if (orig->ealg) {
1884 x->ealg = xfrm_algo_clone(orig->ealg);
1885 if (!x->ealg)
1886 goto error;
1887 }
1888 x->props.ealgo = orig->props.ealgo;
1889
1890 if (orig->calg) {
1891 x->calg = xfrm_algo_clone(orig->calg);
1892 if (!x->calg)
1893 goto error;
1894 }
1895 x->props.calgo = orig->props.calgo;
1896
4ab47d47
AA		 1897 if (encap || orig->encap) {
1898 if (encap)
1899 x->encap = kmemdup(encap, sizeof(*x->encap),
1900 GFP_KERNEL);
1901 else
1902 x->encap = kmemdup(orig->encap, sizeof(*x->encap),
1903 GFP_KERNEL);
1904
80c9abaa
SS		 1905 if (!x->encap)
1906 goto error;
1907 }
1908
7aa05d30
AA		 1909 if (orig->security)
1910 if (clone_security(x, orig->security))
1911 goto error;
1912
80c9abaa
SS		 1913 if (orig->coaddr) {
1914 x->coaddr = kmemdup(orig->coaddr, sizeof(*x->coaddr),
1915 GFP_KERNEL);
1916 if (!x->coaddr)
1917 goto error;
1918 }
1919
af2f464e 1920 if (orig->replay_esn) {
cc9ab60e 1921 if (xfrm_replay_clone(x, orig))
af2f464e
SK		 1922 goto error;
1923 }
1924
bd55775c 1925 memcpy(&x->mark, &orig->mark, sizeof(x->mark));
545e5c57 1926 memcpy(&x->props.smark, &orig->props.smark, sizeof(x->props.smark));
bd55775c 1927
80c9abaa 1928 x->props.flags = orig->props.flags;
a947b0a9 1929 x->props.extra_flags = orig->props.extra_flags;
80c9abaa 1930
1ddf9916 1931 x->pcpu_num = orig->pcpu_num;
7e652640 1932 x->if_id = orig->if_id;
ee5c2317
SK		 1933 x->tfcpad = orig->tfcpad;
1934 x->replay_maxdiff = orig->replay_maxdiff;
1935 x->replay_maxage = orig->replay_maxage;
8366685b 1936 memcpy(&x->curlft, &orig->curlft, sizeof(x->curlft));
80c9abaa
SS		 1937 x->km.state = orig->km.state;
1938 x->km.seq = orig->km.seq;
a486cd23
AA		 1939 x->replay = orig->replay;
1940 x->preplay = orig->preplay;
4e484b3e 1941 x->mapping_maxage = orig->mapping_maxage;
6aa811ac 1942 x->lastused = orig->lastused;
4e484b3e
AA		 1943 x->new_mapping = 0;
1944 x->new_mapping_sport = 0;
a4a87fa4 1945 x->dir = orig->dir;
80c9abaa
SS		 1946
1947 return x;
1948
1949 error:
553f9118
HX		 1950 xfrm_state_put(x);
1951out:
80c9abaa
SS		 1952 return NULL;
1953}
80c9abaa 1954
c1aca308
YY		 1955struct xfrm_state *xfrm_migrate_state_find(struct xfrm_migrate *m, struct net *net,
1956 u32 if_id)
80c9abaa
SS		 1957{
1958 unsigned int h;
8c0cba22
SK		 1959 struct xfrm_state *x = NULL;
1960
1961 spin_lock_bh(&net->xfrm.xfrm_state_lock);
80c9abaa
SS		 1962
1963 if (m->reqid) {
283bc9f3 1964 h = xfrm_dst_hash(net, &m->old_daddr, &m->old_saddr,
80c9abaa 1965 m->reqid, m->old_family);
283bc9f3 1966 hlist_for_each_entry(x, net->xfrm.state_bydst+h, bydst) {
80c9abaa
SS		 1967 if (x->props.mode != m->mode ||
1968 x->id.proto != m->proto)
1969 continue;
1970 if (m->reqid && x->props.reqid != m->reqid)
1971 continue;
c1aca308
YY		 1972 if (if_id != 0 && x->if_id != if_id)
1973 continue;
70e94e66
YH		 1974 if (!xfrm_addr_equal(&x->id.daddr, &m->old_daddr,
1975 m->old_family) ||
1976 !xfrm_addr_equal(&x->props.saddr, &m->old_saddr,
1977 m->old_family))
80c9abaa
SS		 1978 continue;
1979 xfrm_state_hold(x);
8c0cba22 1980 break;
80c9abaa
SS		 1981 }
1982 } else {
283bc9f3 1983 h = xfrm_src_hash(net, &m->old_daddr, &m->old_saddr,
80c9abaa 1984 m->old_family);
283bc9f3 1985 hlist_for_each_entry(x, net->xfrm.state_bysrc+h, bysrc) {
80c9abaa
SS		 1986 if (x->props.mode != m->mode ||
1987 x->id.proto != m->proto)
1988 continue;
c1aca308
YY		 1989 if (if_id != 0 && x->if_id != if_id)
1990 continue;
70e94e66
YH		 1991 if (!xfrm_addr_equal(&x->id.daddr, &m->old_daddr,
1992 m->old_family) ||
1993 !xfrm_addr_equal(&x->props.saddr, &m->old_saddr,
1994 m->old_family))
80c9abaa
SS		 1995 continue;
1996 xfrm_state_hold(x);
8c0cba22 1997 break;
80c9abaa
SS		 1998 }
1999 }
2000
8c0cba22
SK		 2001 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
2002
2003 return x;
80c9abaa
SS		 2004}
2005EXPORT_SYMBOL(xfrm_migrate_state_find);
2006
3e94c2dc 2007struct xfrm_state *xfrm_state_migrate(struct xfrm_state *x,
4ab47d47
AA		 2008 struct xfrm_migrate *m,
2009 struct xfrm_encap_tmpl *encap)
80c9abaa
SS		 2010{
2011 struct xfrm_state *xc;
80c9abaa 2012
4ab47d47 2013 xc = xfrm_state_clone(x, encap);
80c9abaa
SS		 2014 if (!xc)
2015 return NULL;
2016
e03c3bba
YY		 2017 xc->props.family = m->new_family;
2018
2019 if (xfrm_init_state(xc) < 0)
2020 goto error;
2021
80c9abaa
SS		 2022 memcpy(&xc->id.daddr, &m->new_daddr, sizeof(xc->id.daddr));
2023 memcpy(&xc->props.saddr, &m->new_saddr, sizeof(xc->props.saddr));
2024
2025 /* add state */
70e94e66 2026 if (xfrm_addr_equal(&x->id.daddr, &m->new_daddr, m->new_family)) {
80c9abaa
SS		 2027 /* a care is needed when the destination address of the
2028 state is to be updated as it is a part of triplet */
2029 xfrm_state_insert(xc);
2030 } else {
cc9ab60e 2031 if (xfrm_state_add(xc) < 0)
80c9abaa
SS		 2032 goto error;
2033 }
2034
2035 return xc;
2036error:
78347c8c 2037 xfrm_state_put(xc);
80c9abaa
SS		 2038 return NULL;
2039}
2040EXPORT_SYMBOL(xfrm_state_migrate);
2041#endif
2042
1da177e4
LT		 2043int xfrm_state_update(struct xfrm_state *x)
2044{
37b08e34 2045 struct xfrm_state *x1, *to_put;
1da177e4 2046 int err;
eb2971b6 2047 int use_spi = xfrm_id_proto_match(x->id.proto, IPSEC_PROTO_ANY);
283bc9f3 2048 struct net *net = xs_net(x);
1da177e4 2049
37b08e34
DM		 2050 to_put = NULL;
2051
283bc9f3 2052 spin_lock_bh(&net->xfrm.xfrm_state_lock);
edcd5821 2053 x1 = __xfrm_state_locate(x, use_spi, x->props.family);
1da177e4
LT		 2054
2055 err = -ESRCH;
2056 if (!x1)
2057 goto out;
2058
2059 if (xfrm_state_kern(x1)) {
37b08e34 2060 to_put = x1;
1da177e4
LT		 2061 err = -EEXIST;
2062 goto out;
2063 }
2064
2065 if (x1->km.state == XFRM_STATE_ACQ) {
a4a87fa4
AA		 2066 if (x->dir && x1->dir != x->dir)
2067 goto out;
2068
1da177e4
LT		 2069 __xfrm_state_insert(x);
2070 x = NULL;
a4a87fa4
AA		 2071 } else {
2072 if (x1->dir != x->dir)
2073 goto out;
1da177e4
LT		 2074 }
2075 err = 0;
2076
2077out:
283bc9f3 2078 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1da177e4 2079
37b08e34
DM		 2080 if (to_put)
2081 xfrm_state_put(to_put);
2082
1da177e4
LT		 2083 if (err)
2084 return err;
2085
2086 if (!x) {
2087 xfrm_state_delete(x1);
2088 xfrm_state_put(x1);
2089 return 0;
2090 }
2091
2092 err = -EINVAL;
2093 spin_lock_bh(&x1->lock);
2094 if (likely(x1->km.state == XFRM_STATE_VALID)) {
257a4b01
HX		 2095 if (x->encap && x1->encap &&
2096 x->encap->encap_type == x1->encap->encap_type)
1da177e4 2097 memcpy(x1->encap, x->encap, sizeof(*x1->encap));
257a4b01
HX		 2098 else if (x->encap || x1->encap)
2099 goto fail;
2100
060f02a3
NT		 2101 if (x->coaddr && x1->coaddr) {
2102 memcpy(x1->coaddr, x->coaddr, sizeof(*x1->coaddr));
2103 }
2104 if (!use_spi && memcmp(&x1->sel, &x->sel, sizeof(x1->sel)))
2105 memcpy(&x1->sel, &x->sel, sizeof(x1->sel));
1da177e4
LT		 2106 memcpy(&x1->lft, &x->lft, sizeof(x1->lft));
2107 x1->km.dying = 0;
2108
671422b2
TG		 2109 hrtimer_start(&x1->mtimer, ktime_set(1, 0),
2110 HRTIMER_MODE_REL_SOFT);
0a9e5794 2111 if (READ_ONCE(x1->curlft.use_time))
1da177e4
LT		 2112 xfrm_state_check_expire(x1);
2113
5baf4f9c 2114 if (x->props.smark.m || x->props.smark.v || x->if_id) {
6d8e85ff
NH		 2115 spin_lock_bh(&net->xfrm.xfrm_state_lock);
2116
5baf4f9c
NH		 2117 if (x->props.smark.m || x->props.smark.v)
2118 x1->props.smark = x->props.smark;
2119
2120 if (x->if_id)
2121 x1->if_id = x->if_id;
6d8e85ff
NH		 2122
2123 __xfrm_state_bump_genids(x1);
2124 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
2125 }
2126
1da177e4 2127 err = 0;
8fcbc637
TG		 2128 x->km.state = XFRM_STATE_DEAD;
2129 __xfrm_state_put(x);
1da177e4 2130 }
257a4b01
HX		 2131
2132fail:
1da177e4
LT		 2133 spin_unlock_bh(&x1->lock);
2134
2135 xfrm_state_put(x1);
2136
2137 return err;
2138}
2139EXPORT_SYMBOL(xfrm_state_update);
2140
2141int xfrm_state_check_expire(struct xfrm_state *x)
2142{
fd2bc419 2143 xfrm_dev_state_update_stats(x);
f3da86dc 2144
0a9e5794
ED		 2145 if (!READ_ONCE(x->curlft.use_time))
2146 WRITE_ONCE(x->curlft.use_time, ktime_get_real_seconds());
1da177e4 2147
1da177e4
LT		 2148 if (x->curlft.bytes >= x->lft.hard_byte_limit ||
2149 x->curlft.packets >= x->lft.hard_packet_limit) {
4666faab 2150 x->km.state = XFRM_STATE_EXPIRED;
671422b2 2151 hrtimer_start(&x->mtimer, 0, HRTIMER_MODE_REL_SOFT);
1da177e4
LT		 2152 return -EINVAL;
2153 }
2154
2155 if (!x->km.dying &&
2156 (x->curlft.bytes >= x->lft.soft_byte_limit ||
4666faab
HX		 2157 x->curlft.packets >= x->lft.soft_packet_limit)) {
2158 x->km.dying = 1;
53bc6b4d 2159 km_state_expired(x, 0, 0);
4666faab 2160 }
1da177e4
LT		 2161 return 0;
2162}
2163EXPORT_SYMBOL(xfrm_state_check_expire);
2164
f9f221c9
LR		 2165void xfrm_state_update_stats(struct net *net)
2166{
2167 struct xfrm_state *x;
2168 int i;
2169
2170 spin_lock_bh(&net->xfrm.xfrm_state_lock);
2171 for (i = 0; i <= net->xfrm.state_hmask; i++) {
2172 hlist_for_each_entry(x, net->xfrm.state_bydst + i, bydst)
2173 xfrm_dev_state_update_stats(x);
2174 }
2175 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
2176}
2177
1da177e4 2178struct xfrm_state *
a70486f0 2179xfrm_state_lookup(struct net *net, u32 mark, const xfrm_address_t *daddr, __be32 spi,
bd55775c 2180 u8 proto, unsigned short family)
1da177e4
LT		 2181{
2182 struct xfrm_state *x;
1da177e4 2183
c2f672fc 2184 rcu_read_lock();
bd55775c 2185 x = __xfrm_state_lookup(net, mark, daddr, spi, proto, family);
c2f672fc 2186 rcu_read_unlock();
1da177e4
LT		 2187 return x;
2188}
2189EXPORT_SYMBOL(xfrm_state_lookup);
2190
2191struct xfrm_state *
bd55775c 2192xfrm_state_lookup_byaddr(struct net *net, u32 mark,
a70486f0 2193 const xfrm_address_t *daddr, const xfrm_address_t *saddr,
eb2971b6
MN		 2194 u8 proto, unsigned short family)
2195{
2196 struct xfrm_state *x;
eb2971b6 2197
283bc9f3 2198 spin_lock_bh(&net->xfrm.xfrm_state_lock);
bd55775c 2199 x = __xfrm_state_lookup_byaddr(net, mark, daddr, saddr, proto, family);
283bc9f3 2200 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
eb2971b6
MN		 2201 return x;
2202}
2203EXPORT_SYMBOL(xfrm_state_lookup_byaddr);
2204
2205struct xfrm_state *
e473fcb4 2206xfrm_find_acq(struct net *net, const struct xfrm_mark *mark, u8 mode, u32 reqid,
1ddf9916 2207 u32 if_id, u32 pcpu_num, u8 proto, const xfrm_address_t *daddr,
e473fcb4 2208 const xfrm_address_t *saddr, int create, unsigned short family)
1da177e4
LT		 2209{
2210 struct xfrm_state *x;
1da177e4 2211
283bc9f3 2212 spin_lock_bh(&net->xfrm.xfrm_state_lock);
1ddf9916
SK		 2213 x = __find_acq_core(net, mark, family, mode, reqid, if_id, pcpu_num,
2214 proto, daddr, saddr, create);
283bc9f3 2215 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
2770834c 2216
1da177e4
LT		 2217 return x;
2218}
2219EXPORT_SYMBOL(xfrm_find_acq);
2220
41a49cc3 2221#ifdef CONFIG_XFRM_SUB_POLICY
3aaf3915
FW		 2222#if IS_ENABLED(CONFIG_IPV6)
2223/* distribution counting sort function for xfrm_state and xfrm_tmpl */
2224static void
2225__xfrm6_sort(void **dst, void **src, int n,
2226 int (*cmp)(const void *p), int maxclass)
2227{
2228 int count[XFRM_MAX_DEPTH] = { };
2229 int class[XFRM_MAX_DEPTH];
2230 int i;
2231
2232 for (i = 0; i < n; i++) {
2233 int c = cmp(src[i]);
2234
2235 class[i] = c;
2236 count[c]++;
2237 }
2238
2239 for (i = 2; i < maxclass; i++)
2240 count[i] += count[i - 1];
2241
2242 for (i = 0; i < n; i++) {
2243 dst[count[class[i] - 1]++] = src[i];
2244 src[i] = NULL;
2245 }
2246}
2247
2248/* Rule for xfrm_state:
2249 *
2250 * rule 1: select IPsec transport except AH
2251 * rule 2: select MIPv6 RO or inbound trigger
2252 * rule 3: select IPsec transport AH
2253 * rule 4: select IPsec tunnel
2254 * rule 5: others
2255 */
2256static int __xfrm6_state_sort_cmp(const void *p)
2257{
2258 const struct xfrm_state *v = p;
2259
2260 switch (v->props.mode) {
2261 case XFRM_MODE_TRANSPORT:
2262 if (v->id.proto != IPPROTO_AH)
2263 return 1;
2264 else
2265 return 3;
2266#if IS_ENABLED(CONFIG_IPV6_MIP6)
2267 case XFRM_MODE_ROUTEOPTIMIZATION:
2268 case XFRM_MODE_IN_TRIGGER:
2269 return 2;
2270#endif
2271 case XFRM_MODE_TUNNEL:
2272 case XFRM_MODE_BEET:
2273 return 4;
2274 }
2275 return 5;
2276}
2277
2278/* Rule for xfrm_tmpl:
2279 *
2280 * rule 1: select IPsec transport
2281 * rule 2: select MIPv6 RO or inbound trigger
2282 * rule 3: select IPsec tunnel
2283 * rule 4: others
2284 */
2285static int __xfrm6_tmpl_sort_cmp(const void *p)
2286{
2287 const struct xfrm_tmpl *v = p;
2288
2289 switch (v->mode) {
2290 case XFRM_MODE_TRANSPORT:
2291 return 1;
2292#if IS_ENABLED(CONFIG_IPV6_MIP6)
2293 case XFRM_MODE_ROUTEOPTIMIZATION:
2294 case XFRM_MODE_IN_TRIGGER:
2295 return 2;
2296#endif
2297 case XFRM_MODE_TUNNEL:
2298 case XFRM_MODE_BEET:
2299 return 3;
2300 }
2301 return 4;
2302}
2303#else
2304static inline int __xfrm6_state_sort_cmp(const void *p) { return 5; }
2305static inline int __xfrm6_tmpl_sort_cmp(const void *p) { return 4; }
2306
2307static inline void
2308__xfrm6_sort(void **dst, void **src, int n,
2309 int (*cmp)(const void *p), int maxclass)
2310{
2311 int i;
2312
2313 for (i = 0; i < n; i++)
2314 dst[i] = src[i];
2315}
2316#endif /* CONFIG_IPV6 */
2317
2318void
41a49cc3 2319xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,
3aaf3915 2320 unsigned short family)
41a49cc3 2321{
3f5a95ad 2322 int i;
41a49cc3 2323
3aaf3915
FW		 2324 if (family == AF_INET6)
2325 __xfrm6_sort((void **)dst, (void **)src, n,
2326 __xfrm6_tmpl_sort_cmp, 5);
3f5a95ad
KD		 2327 else
2328 for (i = 0; i < n; i++)
2329 dst[i] = src[i];
41a49cc3 2330}
41a49cc3 2331
3aaf3915 2332void
41a49cc3
MN		 2333xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src, int n,
2334 unsigned short family)
2335{
3f5a95ad 2336 int i;
283bc9f3 2337
3aaf3915
FW		 2338 if (family == AF_INET6)
2339 __xfrm6_sort((void **)dst, (void **)src, n,
2340 __xfrm6_state_sort_cmp, 6);
3f5a95ad
KD		 2341 else
2342 for (i = 0; i < n; i++)
2343 dst[i] = src[i];
41a49cc3 2344}
41a49cc3
MN		 2345#endif
2346
1da177e4
LT		 2347/* Silly enough, but I'm lazy to build resolution list */
2348
1ddf9916 2349static struct xfrm_state *__xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq, u32 pcpu_num)
1da177e4 2350{
fe9f1d87
SD		 2351 unsigned int h = xfrm_seq_hash(net, seq);
2352 struct xfrm_state *x;
8f126e37 2353
fe9f1d87
SD		 2354 hlist_for_each_entry_rcu(x, net->xfrm.state_byseq + h, byseq) {
2355 if (x->km.seq == seq &&
2356 (mark & x->mark.m) == x->mark.v &&
1ddf9916 2357 x->pcpu_num == pcpu_num &&
fe9f1d87
SD		 2358 x->km.state == XFRM_STATE_ACQ) {
2359 xfrm_state_hold(x);
2360 return x;
1da177e4
LT		 2361 }
2362 }
fe9f1d87 2363
1da177e4
LT		 2364 return NULL;
2365}
2366
1ddf9916 2367struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq, u32 pcpu_num)
1da177e4
LT		 2368{
2369 struct xfrm_state *x;
2370
283bc9f3 2371 spin_lock_bh(&net->xfrm.xfrm_state_lock);
1ddf9916 2372 x = __xfrm_find_acq_byseq(net, mark, seq, pcpu_num);
283bc9f3 2373 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1da177e4
LT		 2374 return x;
2375}
2376EXPORT_SYMBOL(xfrm_find_acq_byseq);
2377
2378u32 xfrm_get_acqseq(void)
2379{
2380 u32 res;
6836b9bd 2381 static atomic_t acqseq;
2382
2383 do {
2384 res = atomic_inc_return(&acqseq);
2385 } while (!res);
1da177e4 2386
1da177e4
LT		 2387 return res;
2388}
2389EXPORT_SYMBOL(xfrm_get_acqseq);
2390
c2dad11e 2391int verify_spi_info(u8 proto, u32 min, u32 max, struct netlink_ext_ack *extack)
776e9dd9
FD		 2392{
2393 switch (proto) {
2394 case IPPROTO_AH:
2395 case IPPROTO_ESP:
2396 break;
2397
2398 case IPPROTO_COMP:
2399 /* IPCOMP spi is 16-bits. */
c2dad11e
SD		 2400 if (max >= 0x10000) {
2401 NL_SET_ERR_MSG(extack, "IPCOMP SPI must be <= 65535");
776e9dd9 2402 return -EINVAL;
c2dad11e 2403 }
776e9dd9
FD		 2404 break;
2405
2406 default:
c2dad11e 2407 NL_SET_ERR_MSG(extack, "Invalid protocol, must be one of AH, ESP, IPCOMP");
776e9dd9
FD		 2408 return -EINVAL;
2409 }
2410
c2dad11e
SD		 2411 if (min > max) {
2412 NL_SET_ERR_MSG(extack, "Invalid SPI range: min > max");
776e9dd9 2413 return -EINVAL;
c2dad11e 2414 }
776e9dd9
FD		 2415
2416 return 0;
2417}
2418EXPORT_SYMBOL(verify_spi_info);
2419
c2dad11e
SD		 2420int xfrm_alloc_spi(struct xfrm_state *x, u32 low, u32 high,
2421 struct netlink_ext_ack *extack)
1da177e4 2422{
221df1ed 2423 struct net *net = xs_net(x);
f034b5d4 2424 unsigned int h;
1da177e4 2425 struct xfrm_state *x0;
658b219e
HX		 2426 int err = -ENOENT;
2427 __be32 minspi = htonl(low);
2428 __be32 maxspi = htonl(high);
a779d913 2429 __be32 newspi = 0;
bd55775c 2430 u32 mark = x->mark.v & x->mark.m;
1da177e4 2431
658b219e 2432 spin_lock_bh(&x->lock);
c2dad11e
SD		 2433 if (x->km.state == XFRM_STATE_DEAD) {
2434 NL_SET_ERR_MSG(extack, "Target ACQUIRE is in DEAD state");
658b219e 2435 goto unlock;
c2dad11e 2436 }
658b219e
HX		 2437
2438 err = 0;
1da177e4 2439 if (x->id.spi)
658b219e
HX		 2440 goto unlock;
2441
2442 err = -ENOENT;
1da177e4
LT		 2443
2444 if (minspi == maxspi) {
bd55775c 2445 x0 = xfrm_state_lookup(net, mark, &x->id.daddr, minspi, x->id.proto, x->props.family);
1da177e4 2446 if (x0) {
c2dad11e 2447 NL_SET_ERR_MSG(extack, "Requested SPI is already in use");
1da177e4 2448 xfrm_state_put(x0);
658b219e 2449 goto unlock;
1da177e4 2450 }
a779d913 2451 newspi = minspi;
1da177e4
LT		 2452 } else {
2453 u32 spi = 0;
9b7a787d 2454 for (h = 0; h < high-low+1; h++) {
e8a533cb 2455 spi = get_random_u32_inclusive(low, high);
bd55775c 2456 x0 = xfrm_state_lookup(net, mark, &x->id.daddr, htonl(spi), x->id.proto, x->props.family);
1da177e4 2457 if (x0 == NULL) {
a779d913 2458 newspi = htonl(spi);
1da177e4
LT		 2459 break;
2460 }
2461 xfrm_state_put(x0);
2462 }
2463 }
a779d913 2464 if (newspi) {
283bc9f3 2465 spin_lock_bh(&net->xfrm.xfrm_state_lock);
a779d913 2466 x->id.spi = newspi;
12604d8a 2467 h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto, x->props.family);
3c611d40
LR		 2468 XFRM_STATE_INSERT(byspi, &x->byspi, net->xfrm.state_byspi + h,
2469 x->xso.type);
283bc9f3 2470 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
658b219e
HX		 2471
2472 err = 0;
c2dad11e
SD		 2473 } else {
2474 NL_SET_ERR_MSG(extack, "No SPI available in the requested range");
1da177e4 2475 }
658b219e
HX		 2476
2477unlock:
2478 spin_unlock_bh(&x->lock);
2479
2480 return err;
1da177e4
LT		 2481}
2482EXPORT_SYMBOL(xfrm_alloc_spi);
2483
d3623099 2484static bool __xfrm_state_filter_match(struct xfrm_state *x,
870a2df4 2485 struct xfrm_address_filter *filter)
d3623099
ND		 2486{
2487 if (filter) {
2488 if ((filter->family == AF_INET ||
2489 filter->family == AF_INET6) &&
2490 x->props.family != filter->family)
2491 return false;
2492
2493 return addr_match(&x->props.saddr, &filter->saddr,
2494 filter->splen) &&
2495 addr_match(&x->id.daddr, &filter->daddr,
2496 filter->dplen);
2497 }
2498 return true;
2499}
2500
284fa7da 2501int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
4c563f76 2502 int (*func)(struct xfrm_state *, int, void*),
1da177e4
LT		 2503 void *data)
2504{
12a169e7
HX		 2505 struct xfrm_state *state;
2506 struct xfrm_state_walk *x;
1da177e4
LT		 2507 int err = 0;
2508
12a169e7 2509 if (walk->seq != 0 && list_empty(&walk->all))
4c563f76
TT		 2510 return 0;
2511
283bc9f3 2512 spin_lock_bh(&net->xfrm.xfrm_state_lock);
12a169e7 2513 if (list_empty(&walk->all))
284fa7da 2514 x = list_first_entry(&net->xfrm.state_all, struct xfrm_state_walk, all);
12a169e7 2515 else
80077702 2516 x = list_first_entry(&walk->all, struct xfrm_state_walk, all);
284fa7da 2517 list_for_each_entry_from(x, &net->xfrm.state_all, all) {
12a169e7 2518 if (x->state == XFRM_STATE_DEAD)
4c563f76 2519 continue;
12a169e7
HX		 2520 state = container_of(x, struct xfrm_state, km);
2521 if (!xfrm_id_proto_match(state->id.proto, walk->proto))
4c563f76 2522 continue;
d3623099
ND		 2523 if (!__xfrm_state_filter_match(state, walk->filter))
2524 continue;
12a169e7
HX		 2525 err = func(state, walk->seq, data);
2526 if (err) {
2527 list_move_tail(&walk->all, &x->all);
2528 goto out;
1da177e4 2529 }
12a169e7 2530 walk->seq++;
1da177e4 2531 }
12a169e7 2532 if (walk->seq == 0) {
1da177e4
LT		 2533 err = -ENOENT;
2534 goto out;
2535 }
12a169e7 2536 list_del_init(&walk->all);
1da177e4 2537out:
283bc9f3 2538 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
1da177e4
LT		 2539 return err;
2540}
2541EXPORT_SYMBOL(xfrm_state_walk);
2542
d3623099 2543void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto,
870a2df4 2544 struct xfrm_address_filter *filter)
5c182458 2545{
12a169e7 2546 INIT_LIST_HEAD(&walk->all);
5c182458 2547 walk->proto = proto;
12a169e7
HX		 2548 walk->state = XFRM_STATE_DEAD;
2549 walk->seq = 0;
d3623099 2550 walk->filter = filter;
5c182458
HX		 2551}
2552EXPORT_SYMBOL(xfrm_state_walk_init);
2553
283bc9f3 2554void xfrm_state_walk_done(struct xfrm_state_walk *walk, struct net *net)
abb81c4f 2555{
d3623099
ND		 2556 kfree(walk->filter);
2557
12a169e7 2558 if (list_empty(&walk->all))
5c182458 2559 return;
5c182458 2560
283bc9f3 2561 spin_lock_bh(&net->xfrm.xfrm_state_lock);
12a169e7 2562 list_del(&walk->all);
283bc9f3 2563 spin_unlock_bh(&net->xfrm.xfrm_state_lock);
abb81c4f
HX		 2564}
2565EXPORT_SYMBOL(xfrm_state_walk_done);
2566
e99e88a9 2567static void xfrm_replay_timer_handler(struct timer_list *t)
f8cd5488 2568{
e99e88a9 2569 struct xfrm_state *x = from_timer(x, t, rtimer);
f8cd5488
JHS		 2570
2571 spin_lock(&x->lock);
2572
2717096a 2573 if (x->km.state == XFRM_STATE_VALID) {
a6483b79 2574 if (xfrm_aevent_is_on(xs_net(x)))
cfc61c59 2575 xfrm_replay_notify(x, XFRM_REPLAY_TIMEOUT);
2717096a
JHS		 2576 else
2577 x->xflags |= XFRM_TIME_DEFER;
2578 }
f8cd5488
JHS		 2579
2580 spin_unlock(&x->lock);
2581}
2582
df01812e 2583static LIST_HEAD(xfrm_km_list);
1da177e4 2584
214e005b 2585void km_policy_notify(struct xfrm_policy *xp, int dir, const struct km_event *c)
1da177e4
LT		 2586{
2587 struct xfrm_mgr *km;
2588
85168c00
CW		 2589 rcu_read_lock();
2590 list_for_each_entry_rcu(km, &xfrm_km_list, list)
26b15dad
JHS		 2591 if (km->notify_policy)
2592 km->notify_policy(xp, dir, c);
85168c00 2593 rcu_read_unlock();
26b15dad 2594}
1da177e4 2595
214e005b 2596void km_state_notify(struct xfrm_state *x, const struct km_event *c)
26b15dad
JHS		 2597{
2598 struct xfrm_mgr *km;
85168c00
CW		 2599 rcu_read_lock();
2600 list_for_each_entry_rcu(km, &xfrm_km_list, list)
26b15dad
JHS		 2601 if (km->notify)
2602 km->notify(x, c);
85168c00 2603 rcu_read_unlock();
26b15dad
JHS		 2604}
2605
2606EXPORT_SYMBOL(km_policy_notify);
2607EXPORT_SYMBOL(km_state_notify);
2608
15e47304 2609void km_state_expired(struct xfrm_state *x, int hard, u32 portid)
26b15dad
JHS		 2610{
2611 struct km_event c;
2612
bf08867f 2613 c.data.hard = hard;
15e47304 2614 c.portid = portid;
f60f6b8f 2615 c.event = XFRM_MSG_EXPIRE;
26b15dad 2616 km_state_notify(x, &c);
1da177e4
LT		 2617}
2618
53bc6b4d 2619EXPORT_SYMBOL(km_state_expired);
26b15dad
JHS		 2620/*
2621 * We send to all registered managers regardless of failure
2622 * We are happy with one success
2623*/
980ebd25 2624int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol)
1da177e4 2625{
26b15dad 2626 int err = -EINVAL, acqret;
1da177e4
LT		 2627 struct xfrm_mgr *km;
2628
85168c00
CW		 2629 rcu_read_lock();
2630 list_for_each_entry_rcu(km, &xfrm_km_list, list) {
65e0736b 2631 acqret = km->acquire(x, t, pol);
26b15dad
JHS		 2632 if (!acqret)
2633 err = acqret;
1da177e4 2634 }
85168c00 2635 rcu_read_unlock();
1da177e4
LT		 2636 return err;
2637}
980ebd25 2638EXPORT_SYMBOL(km_query);
1da177e4 2639
4e484b3e 2640static int __km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport)
1da177e4
LT		 2641{
2642 int err = -EINVAL;
2643 struct xfrm_mgr *km;
2644
85168c00
CW		 2645 rcu_read_lock();
2646 list_for_each_entry_rcu(km, &xfrm_km_list, list) {
1da177e4
LT		 2647 if (km->new_mapping)
2648 err = km->new_mapping(x, ipaddr, sport);
2649 if (!err)
2650 break;
2651 }
85168c00 2652 rcu_read_unlock();
1da177e4
LT		 2653 return err;
2654}
4e484b3e
AA		 2655
2656int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport)
2657{
2658 int ret = 0;
2659
2660 if (x->mapping_maxage) {
2661 if ((jiffies / HZ - x->new_mapping) > x->mapping_maxage ||
2662 x->new_mapping_sport != sport) {
2663 x->new_mapping_sport = sport;
2664 x->new_mapping = jiffies / HZ;
2665 ret = __km_new_mapping(x, ipaddr, sport);
2666 }
2667 } else {
2668 ret = __km_new_mapping(x, ipaddr, sport);
2669 }
2670
2671 return ret;
2672}
1da177e4
LT		 2673EXPORT_SYMBOL(km_new_mapping);
2674
15e47304 2675void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 portid)
1da177e4 2676{
26b15dad 2677 struct km_event c;
1da177e4 2678
bf08867f 2679 c.data.hard = hard;
15e47304 2680 c.portid = portid;
f60f6b8f 2681 c.event = XFRM_MSG_POLEXPIRE;
26b15dad 2682 km_policy_notify(pol, dir, &c);
1da177e4 2683}
a70fcb0b 2684EXPORT_SYMBOL(km_policy_expired);
1da177e4 2685
2d60abc2 2686#ifdef CONFIG_XFRM_MIGRATE
183cad12
DM		 2687int km_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
2688 const struct xfrm_migrate *m, int num_migrate,
8bafd730
AA		 2689 const struct xfrm_kmaddress *k,
2690 const struct xfrm_encap_tmpl *encap)
80c9abaa
SS		 2691{
2692 int err = -EINVAL;
2693 int ret;
2694 struct xfrm_mgr *km;
2695
85168c00
CW		 2696 rcu_read_lock();
2697 list_for_each_entry_rcu(km, &xfrm_km_list, list) {
80c9abaa 2698 if (km->migrate) {
8bafd730
AA		 2699 ret = km->migrate(sel, dir, type, m, num_migrate, k,
2700 encap);
80c9abaa
SS		 2701 if (!ret)
2702 err = ret;
2703 }
2704 }
85168c00 2705 rcu_read_unlock();
80c9abaa
SS		 2706 return err;
2707}
2708EXPORT_SYMBOL(km_migrate);
2d60abc2 2709#endif
80c9abaa 2710
db983c11 2711int km_report(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr)
97a64b45
MN		 2712{
2713 int err = -EINVAL;
2714 int ret;
2715 struct xfrm_mgr *km;
2716
85168c00
CW		 2717 rcu_read_lock();
2718 list_for_each_entry_rcu(km, &xfrm_km_list, list) {
97a64b45 2719 if (km->report) {
db983c11 2720 ret = km->report(net, proto, sel, addr);
97a64b45
MN		 2721 if (!ret)
2722 err = ret;
2723 }
2724 }
85168c00 2725 rcu_read_unlock();
97a64b45
MN		 2726 return err;
2727}
2728EXPORT_SYMBOL(km_report);
2729
bb9cd077 2730static bool km_is_alive(const struct km_event *c)
0f24558e
HG		 2731{
2732 struct xfrm_mgr *km;
2733 bool is_alive = false;
2734
2735 rcu_read_lock();
2736 list_for_each_entry_rcu(km, &xfrm_km_list, list) {
2737 if (km->is_alive && km->is_alive(c)) {
2738 is_alive = true;
2739 break;
2740 }
2741 }
2742 rcu_read_unlock();
2743
2744 return is_alive;
2745}
0f24558e 2746
c9e7c76d
DS		 2747#if IS_ENABLED(CONFIG_XFRM_USER_COMPAT)
2748static DEFINE_SPINLOCK(xfrm_translator_lock);
2749static struct xfrm_translator __rcu *xfrm_translator;
2750
2751struct xfrm_translator *xfrm_get_translator(void)
2752{
2753 struct xfrm_translator *xtr;
2754
2755 rcu_read_lock();
2756 xtr = rcu_dereference(xfrm_translator);
2757 if (unlikely(!xtr))
2758 goto out;
2759 if (!try_module_get(xtr->owner))
2760 xtr = NULL;
2761out:
2762 rcu_read_unlock();
2763 return xtr;
2764}
2765EXPORT_SYMBOL_GPL(xfrm_get_translator);
2766
2767void xfrm_put_translator(struct xfrm_translator *xtr)
2768{
2769 module_put(xtr->owner);
2770}
2771EXPORT_SYMBOL_GPL(xfrm_put_translator);
2772
2773int xfrm_register_translator(struct xfrm_translator *xtr)
2774{
2775 int err = 0;
2776
2777 spin_lock_bh(&xfrm_translator_lock);
2778 if (unlikely(xfrm_translator != NULL))
2779 err = -EEXIST;
2780 else
2781 rcu_assign_pointer(xfrm_translator, xtr);
2782 spin_unlock_bh(&xfrm_translator_lock);
2783
2784 return err;
2785}
2786EXPORT_SYMBOL_GPL(xfrm_register_translator);
2787
2788int xfrm_unregister_translator(struct xfrm_translator *xtr)
2789{
2790 int err = 0;
2791
2792 spin_lock_bh(&xfrm_translator_lock);
2793 if (likely(xfrm_translator != NULL)) {
2794 if (rcu_access_pointer(xfrm_translator) != xtr)
2795 err = -EINVAL;
2796 else
2797 RCU_INIT_POINTER(xfrm_translator, NULL);
2798 }
2799 spin_unlock_bh(&xfrm_translator_lock);
2800 synchronize_rcu();
2801
2802 return err;
2803}
2804EXPORT_SYMBOL_GPL(xfrm_unregister_translator);
2805#endif
2806
c6d1b26a 2807int xfrm_user_policy(struct sock *sk, int optname, sockptr_t optval, int optlen)
1da177e4
LT		 2808{
2809 int err;
2810 u8 *data;
2811 struct xfrm_mgr *km;
2812 struct xfrm_policy *pol = NULL;
2813
c6d1b26a 2814 if (sockptr_is_null(optval) && !optlen) {
be8f8284
LC		 2815 xfrm_sk_policy_insert(sk, XFRM_POLICY_IN, NULL);
2816 xfrm_sk_policy_insert(sk, XFRM_POLICY_OUT, NULL);
2817 __sk_dst_reset(sk);
2818 return 0;
2819 }
2820
1da177e4
LT		 2821 if (optlen <= 0 || optlen > PAGE_SIZE)
2822 return -EMSGSIZE;
2823
c6d1b26a 2824 data = memdup_sockptr(optval, optlen);
a133d930
GT		 2825 if (IS_ERR(data))
2826 return PTR_ERR(data);
1da177e4 2827
96392ee5
DS		 2828 if (in_compat_syscall()) {
2829 struct xfrm_translator *xtr = xfrm_get_translator();
2830
48f486e1
YK		 2831 if (!xtr) {
2832 kfree(data);
96392ee5 2833 return -EOPNOTSUPP;
48f486e1 2834 }
96392ee5
DS		 2835
2836 err = xtr->xlate_user_policy_sockptr(&data, optlen);
2837 xfrm_put_translator(xtr);
2838 if (err) {
2839 kfree(data);
2840 return err;
2841 }
2842 }
2843
1da177e4 2844 err = -EINVAL;
85168c00
CW		 2845 rcu_read_lock();
2846 list_for_each_entry_rcu(km, &xfrm_km_list, list) {
cb969f07 2847 pol = km->compile_policy(sk, optname, data,
1da177e4
LT		 2848 optlen, &err);
2849 if (err >= 0)
2850 break;
2851 }
85168c00 2852 rcu_read_unlock();
1da177e4
LT		 2853
2854 if (err >= 0) {
2855 xfrm_sk_policy_insert(sk, err, pol);
2856 xfrm_pol_put(pol);
2b06cdf3 2857 __sk_dst_reset(sk);
1da177e4
LT		 2858 err = 0;
2859 }
2860
1da177e4
LT		 2861 kfree(data);
2862 return err;
2863}
2864EXPORT_SYMBOL(xfrm_user_policy);
2865
85168c00
CW		 2866static DEFINE_SPINLOCK(xfrm_km_lock);
2867
f41b284a 2868void xfrm_register_km(struct xfrm_mgr *km)
1da177e4 2869{
85168c00
CW		 2870 spin_lock_bh(&xfrm_km_lock);
2871 list_add_tail_rcu(&km->list, &xfrm_km_list);
2872 spin_unlock_bh(&xfrm_km_lock);
1da177e4
LT		 2873}
2874EXPORT_SYMBOL(xfrm_register_km);
2875
f41b284a 2876void xfrm_unregister_km(struct xfrm_mgr *km)
1da177e4 2877{
85168c00
CW		 2878 spin_lock_bh(&xfrm_km_lock);
2879 list_del_rcu(&km->list);
2880 spin_unlock_bh(&xfrm_km_lock);
2881 synchronize_rcu();
1da177e4
LT		 2882}
2883EXPORT_SYMBOL(xfrm_unregister_km);
2884
2885int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo)
2886{
2887 int err = 0;
423826a7
FW		 2888
2889 if (WARN_ON(afinfo->family >= NPROTO))
1da177e4 2890 return -EAFNOSUPPORT;
423826a7 2891
44abdc30 2892 spin_lock_bh(&xfrm_state_afinfo_lock);
1da177e4 2893 if (unlikely(xfrm_state_afinfo[afinfo->family] != NULL))
f31e8d4f 2894 err = -EEXIST;
edcd5821 2895 else
44abdc30
CW		 2896 rcu_assign_pointer(xfrm_state_afinfo[afinfo->family], afinfo);
2897 spin_unlock_bh(&xfrm_state_afinfo_lock);
1da177e4
LT		 2898 return err;
2899}
2900EXPORT_SYMBOL(xfrm_state_register_afinfo);
2901
2902int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo)
2903{
423826a7
FW		 2904 int err = 0, family = afinfo->family;
2905
2906 if (WARN_ON(family >= NPROTO))
1da177e4 2907 return -EAFNOSUPPORT;
423826a7 2908
44abdc30 2909 spin_lock_bh(&xfrm_state_afinfo_lock);
1da177e4 2910 if (likely(xfrm_state_afinfo[afinfo->family] != NULL)) {
423826a7 2911 if (rcu_access_pointer(xfrm_state_afinfo[family]) != afinfo)
1da177e4 2912 err = -EINVAL;
edcd5821 2913 else
44abdc30 2914 RCU_INIT_POINTER(xfrm_state_afinfo[afinfo->family], NULL);
1da177e4 2915 }
44abdc30
CW		 2916 spin_unlock_bh(&xfrm_state_afinfo_lock);
2917 synchronize_rcu();
1da177e4
LT		 2918 return err;
2919}
2920EXPORT_SYMBOL(xfrm_state_unregister_afinfo);
2921
711059b9
FW		 2922struct xfrm_state_afinfo *xfrm_state_afinfo_get_rcu(unsigned int family)
2923{
2924 if (unlikely(family >= NPROTO))
2925 return NULL;
2926
2927 return rcu_dereference(xfrm_state_afinfo[family]);
2928}
733a5fac 2929EXPORT_SYMBOL_GPL(xfrm_state_afinfo_get_rcu);
711059b9 2930
628e341f 2931struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned int family)
1da177e4
LT		 2932{
2933 struct xfrm_state_afinfo *afinfo;
2934 if (unlikely(family >= NPROTO))
2935 return NULL;
44abdc30
CW		 2936 rcu_read_lock();
2937 afinfo = rcu_dereference(xfrm_state_afinfo[family]);
546be240 2938 if (unlikely(!afinfo))
44abdc30 2939 rcu_read_unlock();
1da177e4
LT		 2940 return afinfo;
2941}
2942
b48c05ab
SK		 2943void xfrm_flush_gc(void)
2944{
2945 flush_work(&xfrm_state_gc_work);
2946}
2947EXPORT_SYMBOL(xfrm_flush_gc);
2948
1da177e4
LT		 2949/* Temporarily located here until net/xfrm/xfrm_tunnel.c is created */
2950void xfrm_state_delete_tunnel(struct xfrm_state *x)
2951{
2952 if (x->tunnel) {
2953 struct xfrm_state *t = x->tunnel;
2954
2955 if (atomic_read(&t->tunnel_users) == 2)
2956 xfrm_state_delete(t);
2957 atomic_dec(&t->tunnel_users);
f75a2804 2958 xfrm_state_put_sync(t);
1da177e4
LT		 2959 x->tunnel = NULL;
2960 }
2961}
2962EXPORT_SYMBOL(xfrm_state_delete_tunnel);
2963
a6d95c5a 2964u32 xfrm_state_mtu(struct xfrm_state *x, int mtu)
1da177e4 2965{
b3b73b8e 2966 const struct xfrm_type *type = READ_ONCE(x->type);
c7b37c76
FW		 2967 struct crypto_aead *aead;
2968 u32 blksize, net_adj = 0;
2969
2970 if (x->km.state != XFRM_STATE_VALID ||
2971 !type || type->proto != IPPROTO_ESP)
2972 return mtu - x->props.header_len;
2973
2974 aead = x->data;
2975 blksize = ALIGN(crypto_aead_blocksize(aead), 4);
1da177e4 2976
c7b37c76
FW		 2977 switch (x->props.mode) {
2978 case XFRM_MODE_TRANSPORT:
2979 case XFRM_MODE_BEET:
2980 if (x->props.family == AF_INET)
2981 net_adj = sizeof(struct iphdr);
2982 else if (x->props.family == AF_INET6)
2983 net_adj = sizeof(struct ipv6hdr);
2984 break;
2985 case XFRM_MODE_TUNNEL:
2986 break;
2987 default:
2988 WARN_ON_ONCE(1);
2989 break;
2990 }
b3b73b8e 2991
c7b37c76
FW		 2992 return ((mtu - x->props.header_len - crypto_aead_authsize(aead) -
2993 net_adj) & ~(blksize - 1)) + net_adj - 2;
1da177e4 2994}
a6d95c5a 2995EXPORT_SYMBOL_GPL(xfrm_state_mtu);
1da177e4 2996
741f9a10
SD		 2997int __xfrm_init_state(struct xfrm_state *x, bool init_replay, bool offload,
2998 struct netlink_ext_ack *extack)
72cb6962 2999{
c9500d7b
FW		 3000 const struct xfrm_mode *inner_mode;
3001 const struct xfrm_mode *outer_mode;
d094cd83 3002 int family = x->props.family;
72cb6962
HX		 3003 int err;
3004
e4681747 3005 if (family == AF_INET &&
0968d2a4 3006 READ_ONCE(xs_net(x)->ipv4.sysctl_ip_no_pmtu_disc))
e4681747 3007 x->props.flags |= XFRM_STATE_NOPMTUDISC;
d094cd83
HX		 3008
3009 err = -EPROTONOSUPPORT;
13996378 3010
df9dcb45
KM		 3011 if (x->sel.family != AF_UNSPEC) {
3012 inner_mode = xfrm_get_mode(x->props.mode, x->sel.family);
741f9a10
SD		 3013 if (inner_mode == NULL) {
3014 NL_SET_ERR_MSG(extack, "Requested mode not found");
df9dcb45 3015 goto error;
741f9a10 3016 }
df9dcb45
KM		 3017
3018 if (!(inner_mode->flags & XFRM_MODE_FLAG_TUNNEL) &&
741f9a10
SD		 3019 family != x->sel.family) {
3020 NL_SET_ERR_MSG(extack, "Only tunnel modes can accommodate a change of family");
df9dcb45 3021 goto error;
741f9a10 3022 }
df9dcb45 3023
c9500d7b 3024 x->inner_mode = *inner_mode;
df9dcb45 3025 } else {
4c145dce 3026 const struct xfrm_mode *inner_mode_iaf;
d81d2285 3027 int iafamily = AF_INET;
df9dcb45 3028
d81d2285 3029 inner_mode = xfrm_get_mode(x->props.mode, x->props.family);
741f9a10
SD		 3030 if (inner_mode == NULL) {
3031 NL_SET_ERR_MSG(extack, "Requested mode not found");
df9dcb45 3032 goto error;
741f9a10 3033 }
df9dcb45 3034
c9500d7b 3035 x->inner_mode = *inner_mode;
df9dcb45 3036
d81d2285
MW		 3037 if (x->props.family == AF_INET)
3038 iafamily = AF_INET6;
df9dcb45 3039
d81d2285
MW		 3040 inner_mode_iaf = xfrm_get_mode(x->props.mode, iafamily);
3041 if (inner_mode_iaf) {
3042 if (inner_mode_iaf->flags & XFRM_MODE_FLAG_TUNNEL)
c9500d7b 3043 x->inner_mode_iaf = *inner_mode_iaf;
df9dcb45
KM		 3044 }
3045 }
13996378 3046
d094cd83 3047 x->type = xfrm_get_type(x->id.proto, family);
741f9a10
SD		 3048 if (x->type == NULL) {
3049 NL_SET_ERR_MSG(extack, "Requested type not found");
72cb6962 3050 goto error;
741f9a10 3051 }
72cb6962 3052
ffdb5211 3053 x->type_offload = xfrm_get_type_offload(x->id.proto, family, offload);
9d389d7f 3054
e1e10b44 3055 err = x->type->init_state(x, extack);
72cb6962
HX		 3056 if (err)
3057 goto error;
3058
c9500d7b
FW		 3059 outer_mode = xfrm_get_mode(x->props.mode, family);
3060 if (!outer_mode) {
741f9a10 3061 NL_SET_ERR_MSG(extack, "Requested mode not found");
599901c3 3062 err = -EPROTONOSUPPORT;
b59f45d0 3063 goto error;
599901c3 3064 }
b59f45d0 3065
c9500d7b 3066 x->outer_mode = *outer_mode;
a454f0cc 3067 if (init_replay) {
1cf9a3ae 3068 err = xfrm_init_replay(x, extack);
a454f0cc
WY		 3069 if (err)
3070 goto error;
3071 }
3072
f531d13b
EB		 3073 if (x->nat_keepalive_interval) {
3074 if (x->dir != XFRM_SA_DIR_OUT) {
3075 NL_SET_ERR_MSG(extack, "NAT keepalive is only supported for outbound SAs");
3076 err = -EINVAL;
3077 goto error;
3078 }
3079
3080 if (!x->encap || x->encap->encap_type != UDP_ENCAP_ESPINUDP) {
3081 NL_SET_ERR_MSG(extack,
3082 "NAT keepalive is only supported for UDP encapsulation");
3083 err = -EINVAL;
3084 goto error;
3085 }
3086 }
3087
72cb6962
HX		 3088error:
3089 return err;
3090}
3091
a454f0cc
WY		 3092EXPORT_SYMBOL(__xfrm_init_state);
3093
3094int xfrm_init_state(struct xfrm_state *x)
3095{
cc01572e
YK		 3096 int err;
3097
741f9a10 3098 err = __xfrm_init_state(x, true, false, NULL);
cc01572e
YK		 3099 if (!err)
3100 x->km.state = XFRM_STATE_VALID;
3101
3102 return err;
a454f0cc
WY		 3103}
3104
72cb6962 3105EXPORT_SYMBOL(xfrm_init_state);
a716c119 3106
d62ddc21 3107int __net_init xfrm_state_init(struct net *net)
1da177e4 3108{
f034b5d4
DM		 3109 unsigned int sz;
3110
565f0fa9
MK		 3111 if (net_eq(net, &init_net))
3112 xfrm_state_cache = KMEM_CACHE(xfrm_state,
3113 SLAB_HWCACHE_ALIGN | SLAB_PANIC);
3114
9d4139c7
AD		 3115 INIT_LIST_HEAD(&net->xfrm.state_all);
3116
f034b5d4
DM		 3117 sz = sizeof(struct hlist_head) * 8;
3118
73d189dc
AD		 3119 net->xfrm.state_bydst = xfrm_hash_alloc(sz);
3120 if (!net->xfrm.state_bydst)
3121 goto out_bydst;
d320bbb3
AD		 3122 net->xfrm.state_bysrc = xfrm_hash_alloc(sz);
3123 if (!net->xfrm.state_bysrc)
3124 goto out_bysrc;
b754a4fd
AD		 3125 net->xfrm.state_byspi = xfrm_hash_alloc(sz);
3126 if (!net->xfrm.state_byspi)
3127 goto out_byspi;
fe9f1d87
SD		 3128 net->xfrm.state_byseq = xfrm_hash_alloc(sz);
3129 if (!net->xfrm.state_byseq)
3130 goto out_byseq;
81a331a0
SK		 3131
3132 net->xfrm.state_cache_input = alloc_percpu(struct hlist_head);
3133 if (!net->xfrm.state_cache_input)
3134 goto out_state_cache_input;
3135
529983ec 3136 net->xfrm.state_hmask = ((sz / sizeof(struct hlist_head)) - 1);
1da177e4 3137
0bf7c5b0 3138 net->xfrm.state_num = 0;
63082733 3139 INIT_WORK(&net->xfrm.state_hash_work, xfrm_hash_resize);
283bc9f3 3140 spin_lock_init(&net->xfrm.xfrm_state_lock);
bc8e0adf
AD		 3141 seqcount_spinlock_init(&net->xfrm.xfrm_state_hash_generation,
3142 &net->xfrm.xfrm_state_lock);
d62ddc21 3143 return 0;
73d189dc 3144
81a331a0
SK		 3145out_state_cache_input:
3146 xfrm_hash_free(net->xfrm.state_byseq, sz);
fe9f1d87
SD		 3147out_byseq:
3148 xfrm_hash_free(net->xfrm.state_byspi, sz);
b754a4fd
AD		 3149out_byspi:
3150 xfrm_hash_free(net->xfrm.state_bysrc, sz);
d320bbb3
AD		 3151out_bysrc:
3152 xfrm_hash_free(net->xfrm.state_bydst, sz);
73d189dc
AD		 3153out_bydst:
3154 return -ENOMEM;
d62ddc21
AD		 3155}
3156
3157void xfrm_state_fini(struct net *net)
3158{
73d189dc
AD		 3159 unsigned int sz;
3160
7c2776ee 3161 flush_work(&net->xfrm.state_hash_work);
35db57bb 3162 flush_work(&xfrm_state_gc_work);
dbb2483b 3163 xfrm_state_flush(net, 0, false, true);
7c2776ee 3164
9d4139c7 3165 WARN_ON(!list_empty(&net->xfrm.state_all));
73d189dc 3166
529983ec 3167 sz = (net->xfrm.state_hmask + 1) * sizeof(struct hlist_head);
fe9f1d87
SD		 3168 WARN_ON(!hlist_empty(net->xfrm.state_byseq));
3169 xfrm_hash_free(net->xfrm.state_byseq, sz);
b754a4fd
AD		 3170 WARN_ON(!hlist_empty(net->xfrm.state_byspi));
3171 xfrm_hash_free(net->xfrm.state_byspi, sz);
d320bbb3
AD		 3172 WARN_ON(!hlist_empty(net->xfrm.state_bysrc));
3173 xfrm_hash_free(net->xfrm.state_bysrc, sz);
73d189dc
AD		 3174 WARN_ON(!hlist_empty(net->xfrm.state_bydst));
3175 xfrm_hash_free(net->xfrm.state_bydst, sz);
81a331a0 3176 free_percpu(net->xfrm.state_cache_input);
1da177e4
LT		 3177}
3178
ab5f5e8b 3179#ifdef CONFIG_AUDITSYSCALL
cf35f43e
IJ		 3180static void xfrm_audit_helper_sainfo(struct xfrm_state *x,
3181 struct audit_buffer *audit_buf)
ab5f5e8b 3182{
68277acc
PM		 3183 struct xfrm_sec_ctx *ctx = x->security;
3184 u32 spi = ntohl(x->id.spi);
3185
3186 if (ctx)
ab5f5e8b 3187 audit_log_format(audit_buf, " sec_alg=%u sec_doi=%u sec_obj=%s",
68277acc 3188 ctx->ctx_alg, ctx->ctx_doi, ctx->ctx_str);
ab5f5e8b 3189
9b7a787d 3190 switch (x->props.family) {
ab5f5e8b 3191 case AF_INET:
21454aaa
HH		 3192 audit_log_format(audit_buf, " src=%pI4 dst=%pI4",
3193 &x->props.saddr.a4, &x->id.daddr.a4);
ab5f5e8b
JL		 3194 break;
3195 case AF_INET6:
5b095d98 3196 audit_log_format(audit_buf, " src=%pI6 dst=%pI6",
fdb46ee7 3197 x->props.saddr.a6, x->id.daddr.a6);
ab5f5e8b
JL		 3198 break;
3199 }
68277acc
PM		 3200
3201 audit_log_format(audit_buf, " spi=%u(0x%x)", spi, spi);
ab5f5e8b
JL		 3202}
3203
cf35f43e
IJ		 3204static void xfrm_audit_helper_pktinfo(struct sk_buff *skb, u16 family,
3205 struct audit_buffer *audit_buf)
afeb14b4 3206{
b71d1d42
ED		 3207 const struct iphdr *iph4;
3208 const struct ipv6hdr *iph6;
afeb14b4
PM		 3209
3210 switch (family) {
3211 case AF_INET:
3212 iph4 = ip_hdr(skb);
21454aaa
HH		 3213 audit_log_format(audit_buf, " src=%pI4 dst=%pI4",
3214 &iph4->saddr, &iph4->daddr);
afeb14b4
PM		 3215 break;
3216 case AF_INET6:
3217 iph6 = ipv6_hdr(skb);
3218 audit_log_format(audit_buf,
5b095d98 3219 " src=%pI6 dst=%pI6 flowlbl=0x%x%02x%02x",
9b7a787d 3220 &iph6->saddr, &iph6->daddr,
afeb14b4
PM		 3221 iph6->flow_lbl[0] & 0x0f,
3222 iph6->flow_lbl[1],
3223 iph6->flow_lbl[2]);
3224 break;
3225 }
3226}
3227
2e71029e 3228void xfrm_audit_state_add(struct xfrm_state *x, int result, bool task_valid)
ab5f5e8b
JL		 3229{
3230 struct audit_buffer *audit_buf;
ab5f5e8b 3231
afeb14b4 3232 audit_buf = xfrm_audit_start("SAD-add");
ab5f5e8b
JL		 3233 if (audit_buf == NULL)
3234 return;
2e71029e 3235 xfrm_audit_helper_usrinfo(task_valid, audit_buf);
afeb14b4
PM		 3236 xfrm_audit_helper_sainfo(x, audit_buf);
3237 audit_log_format(audit_buf, " res=%u", result);
ab5f5e8b
JL		 3238 audit_log_end(audit_buf);
3239}
3240EXPORT_SYMBOL_GPL(xfrm_audit_state_add);
3241
2e71029e 3242void xfrm_audit_state_delete(struct xfrm_state *x, int result, bool task_valid)
ab5f5e8b
JL		 3243{
3244 struct audit_buffer *audit_buf;
ab5f5e8b 3245
afeb14b4 3246 audit_buf = xfrm_audit_start("SAD-delete");
ab5f5e8b
JL		 3247 if (audit_buf == NULL)
3248 return;
2e71029e 3249 xfrm_audit_helper_usrinfo(task_valid, audit_buf);
afeb14b4
PM		 3250 xfrm_audit_helper_sainfo(x, audit_buf);
3251 audit_log_format(audit_buf, " res=%u", result);
ab5f5e8b
JL		 3252 audit_log_end(audit_buf);
3253}
3254EXPORT_SYMBOL_GPL(xfrm_audit_state_delete);
afeb14b4
PM		 3255
3256void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
3257 struct sk_buff *skb)
3258{
3259 struct audit_buffer *audit_buf;
3260 u32 spi;
3261
3262 audit_buf = xfrm_audit_start("SA-replay-overflow");
3263 if (audit_buf == NULL)
3264 return;
3265 xfrm_audit_helper_pktinfo(skb, x->props.family, audit_buf);
3266 /* don't record the sequence number because it's inherent in this kind
3267 * of audit message */
3268 spi = ntohl(x->id.spi);
3269 audit_log_format(audit_buf, " spi=%u(0x%x)", spi, spi);
3270 audit_log_end(audit_buf);
3271}
3272EXPORT_SYMBOL_GPL(xfrm_audit_state_replay_overflow);
3273
9fdc4883 3274void xfrm_audit_state_replay(struct xfrm_state *x,
afeb14b4
PM		 3275 struct sk_buff *skb, __be32 net_seq)
3276{
3277 struct audit_buffer *audit_buf;
3278 u32 spi;
3279
3280 audit_buf = xfrm_audit_start("SA-replayed-pkt");
3281 if (audit_buf == NULL)
3282 return;
3283 xfrm_audit_helper_pktinfo(skb, x->props.family, audit_buf);
3284 spi = ntohl(x->id.spi);
3285 audit_log_format(audit_buf, " spi=%u(0x%x) seqno=%u",
3286 spi, spi, ntohl(net_seq));
3287 audit_log_end(audit_buf);
3288}
9fdc4883 3289EXPORT_SYMBOL_GPL(xfrm_audit_state_replay);
afeb14b4
PM		 3290
3291void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family)
3292{
3293 struct audit_buffer *audit_buf;
3294
3295 audit_buf = xfrm_audit_start("SA-notfound");
3296 if (audit_buf == NULL)
3297 return;
3298 xfrm_audit_helper_pktinfo(skb, family, audit_buf);
3299 audit_log_end(audit_buf);
3300}
3301EXPORT_SYMBOL_GPL(xfrm_audit_state_notfound_simple);
3302
3303void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
3304 __be32 net_spi, __be32 net_seq)
3305{
3306 struct audit_buffer *audit_buf;
3307 u32 spi;
3308
3309 audit_buf = xfrm_audit_start("SA-notfound");
3310 if (audit_buf == NULL)
3311 return;
3312 xfrm_audit_helper_pktinfo(skb, family, audit_buf);
3313 spi = ntohl(net_spi);
3314 audit_log_format(audit_buf, " spi=%u(0x%x) seqno=%u",
3315 spi, spi, ntohl(net_seq));
3316 audit_log_end(audit_buf);
3317}
3318EXPORT_SYMBOL_GPL(xfrm_audit_state_notfound);
3319
3320void xfrm_audit_state_icvfail(struct xfrm_state *x,
3321 struct sk_buff *skb, u8 proto)
3322{
3323 struct audit_buffer *audit_buf;
3324 __be32 net_spi;
3325 __be32 net_seq;
3326
3327 audit_buf = xfrm_audit_start("SA-icv-failure");
3328 if (audit_buf == NULL)
3329 return;
3330 xfrm_audit_helper_pktinfo(skb, x->props.family, audit_buf);
3331 if (xfrm_parse_spi(skb, proto, &net_spi, &net_seq) == 0) {
3332 u32 spi = ntohl(net_spi);
3333 audit_log_format(audit_buf, " spi=%u(0x%x) seqno=%u",
3334 spi, spi, ntohl(net_seq));
3335 }
3336 audit_log_end(audit_buf);
3337}
3338EXPORT_SYMBOL_GPL(xfrm_audit_state_icvfail);
ab5f5e8b 3339#endif /* CONFIG_AUDITSYSCALL */
Empty description
This page took 1.944883 seconds and 4 git commands to generate.