]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - net/xfrm/xfrm_state.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
netns xfrm: trivial netns propagations
[mirror_ubuntu-artful-kernel.git] / net / xfrm / xfrm_state.c
CommitLineData
1da177e4
LT		 1/*
2 * xfrm_state.c
3 *
4 * Changes:
5 * Mitsuru KANDA @USAGI
6 * Kazunori MIYAZAWA @USAGI
7 * Kunihiro Ishiguro <kunihiro@ipinfusion.com>
8 * IPv6 support
9 * YOSHIFUJI Hideaki @USAGI
10 * Split up af-specific functions
11 * Derek Atkins <derek@ihtfp.com>
12 * Add UDP Encapsulation
df71837d 13 *
1da177e4
LT		 14 */
15
16#include <linux/workqueue.h>
17#include <net/xfrm.h>
18#include <linux/pfkeyv2.h>
19#include <linux/ipsec.h>
20#include <linux/module.h>
f034b5d4 21#include <linux/cache.h>
68277acc 22#include <linux/audit.h>
b5890d8b 23#include <asm/uaccess.h>
1da177e4 24
44e36b42
DM		 25#include "xfrm_hash.h"
26
ee857a7d
DM		 27struct sock *xfrm_nl;
28EXPORT_SYMBOL(xfrm_nl);
29
01e67d08 30u32 sysctl_xfrm_aevent_etime __read_mostly = XFRM_AE_ETIME;
a70fcb0b
DM		 31EXPORT_SYMBOL(sysctl_xfrm_aevent_etime);
32
01e67d08 33u32 sysctl_xfrm_aevent_rseqth __read_mostly = XFRM_AE_SEQT_SIZE;
a70fcb0b
DM		 34EXPORT_SYMBOL(sysctl_xfrm_aevent_rseqth);
35
01e67d08
DM		 36u32 sysctl_xfrm_acq_expires __read_mostly = 30;
37
1da177e4
LT		 38/* Each xfrm_state may be linked to two tables:
39
40 1. Hash table by (spi,daddr,ah/esp) to find SA by SPI. (input,ctl)
a624c108 41 2. Hash table by (daddr,family,reqid) to find what SAs exist for given
1da177e4
LT		 42 destination/tunnel endpoint. (output)
43 */
44
45static DEFINE_SPINLOCK(xfrm_state_lock);
46
f034b5d4 47static unsigned int xfrm_state_hashmax __read_mostly = 1 * 1024 * 1024;
9d4a706d 48static unsigned int xfrm_state_genid;
f034b5d4 49
17c2a42a
HX		 50static struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned int family);
51static void xfrm_state_put_afinfo(struct xfrm_state_afinfo *afinfo);
52
afeb14b4
PM		 53#ifdef CONFIG_AUDITSYSCALL
54static void xfrm_audit_state_replay(struct xfrm_state *x,
55 struct sk_buff *skb, __be32 net_seq);
56#else
57#define xfrm_audit_state_replay(x, s, sq) do { ; } while (0)
58#endif /* CONFIG_AUDITSYSCALL */
59
64d0cd00
AD		 60static inline unsigned int xfrm_dst_hash(struct net *net,
61 xfrm_address_t *daddr,
c1969f29
DM		 62 xfrm_address_t *saddr,
63 u32 reqid,
a624c108 64 unsigned short family)
f034b5d4 65{
64d0cd00 66 return __xfrm_dst_hash(daddr, saddr, reqid, family, net->xfrm.state_hmask);
f034b5d4
DM		 67}
68
64d0cd00
AD		 69static inline unsigned int xfrm_src_hash(struct net *net,
70 xfrm_address_t *daddr,
667bbcb6 71 xfrm_address_t *saddr,
44e36b42 72 unsigned short family)
f034b5d4 73{
64d0cd00 74 return __xfrm_src_hash(daddr, saddr, family, net->xfrm.state_hmask);
f034b5d4
DM		 75}
76
f034b5d4 77static inline unsigned int
64d0cd00 78xfrm_spi_hash(struct net *net, xfrm_address_t *daddr, __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
f034b5d4
DM		 83static void xfrm_hash_transfer(struct hlist_head *list,
84 struct hlist_head *ndsttable,
85 struct hlist_head *nsrctable,
86 struct hlist_head *nspitable,
87 unsigned int nhashmask)
88{
89 struct hlist_node *entry, *tmp;
90 struct xfrm_state *x;
91
92 hlist_for_each_entry_safe(x, entry, tmp, list, bydst) {
93 unsigned int h;
94
c1969f29
DM		 95 h = __xfrm_dst_hash(&x->id.daddr, &x->props.saddr,
96 x->props.reqid, x->props.family,
97 nhashmask);
f034b5d4
DM		 98 hlist_add_head(&x->bydst, ndsttable+h);
99
667bbcb6
MN		 100 h = __xfrm_src_hash(&x->id.daddr, &x->props.saddr,
101 x->props.family,
f034b5d4
DM		 102 nhashmask);
103 hlist_add_head(&x->bysrc, nsrctable+h);
104
7b4dc360
MN		 105 if (x->id.spi) {
106 h = __xfrm_spi_hash(&x->id.daddr, x->id.spi,
107 x->id.proto, x->props.family,
108 nhashmask);
109 hlist_add_head(&x->byspi, nspitable+h);
110 }
f034b5d4
DM		 111 }
112}
113
63082733 114static unsigned long xfrm_hash_new_size(unsigned int state_hmask)
f034b5d4 115{
63082733 116 return ((state_hmask + 1) << 1) * sizeof(struct hlist_head);
f034b5d4
DM		 117}
118
119static DEFINE_MUTEX(hash_resize_mutex);
120
63082733 121static void xfrm_hash_resize(struct work_struct *work)
f034b5d4 122{
63082733 123 struct net *net = container_of(work, struct net, xfrm.state_hash_work);
f034b5d4
DM		 124 struct hlist_head *ndst, *nsrc, *nspi, *odst, *osrc, *ospi;
125 unsigned long nsize, osize;
126 unsigned int nhashmask, ohashmask;
127 int i;
128
129 mutex_lock(&hash_resize_mutex);
130
63082733 131 nsize = xfrm_hash_new_size(net->xfrm.state_hmask);
44e36b42 132 ndst = xfrm_hash_alloc(nsize);
f034b5d4
DM		 133 if (!ndst)
134 goto out_unlock;
44e36b42 135 nsrc = xfrm_hash_alloc(nsize);
f034b5d4 136 if (!nsrc) {
44e36b42 137 xfrm_hash_free(ndst, nsize);
f034b5d4
DM		 138 goto out_unlock;
139 }
44e36b42 140 nspi = xfrm_hash_alloc(nsize);
f034b5d4 141 if (!nspi) {
44e36b42
DM		 142 xfrm_hash_free(ndst, nsize);
143 xfrm_hash_free(nsrc, nsize);
f034b5d4
DM		 144 goto out_unlock;
145 }
146
147 spin_lock_bh(&xfrm_state_lock);
148
149 nhashmask = (nsize / sizeof(struct hlist_head)) - 1U;
63082733
AD		 150 for (i = net->xfrm.state_hmask; i >= 0; i--)
151 xfrm_hash_transfer(net->xfrm.state_bydst+i, ndst, nsrc, nspi,
f034b5d4
DM		 152 nhashmask);
153
63082733
AD		 154 odst = net->xfrm.state_bydst;
155 osrc = net->xfrm.state_bysrc;
156 ospi = net->xfrm.state_byspi;
157 ohashmask = net->xfrm.state_hmask;
f034b5d4 158
63082733
AD		 159 net->xfrm.state_bydst = ndst;
160 net->xfrm.state_bysrc = nsrc;
161 net->xfrm.state_byspi = nspi;
162 net->xfrm.state_hmask = nhashmask;
f034b5d4
DM		 163
164 spin_unlock_bh(&xfrm_state_lock);
165
166 osize = (ohashmask + 1) * sizeof(struct hlist_head);
44e36b42
DM		 167 xfrm_hash_free(odst, osize);
168 xfrm_hash_free(osrc, osize);
169 xfrm_hash_free(ospi, osize);
f034b5d4
DM		 170
171out_unlock:
172 mutex_unlock(&hash_resize_mutex);
173}
174
1da177e4
LT		 175static DEFINE_RWLOCK(xfrm_state_afinfo_lock);
176static struct xfrm_state_afinfo *xfrm_state_afinfo[NPROTO];
177
1da177e4
LT		 178static DEFINE_SPINLOCK(xfrm_state_gc_lock);
179
53bc6b4d 180int __xfrm_state_delete(struct xfrm_state *x);
1da177e4 181
980ebd25 182int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol);
53bc6b4d 183void km_state_expired(struct xfrm_state *x, int hard, u32 pid);
1da177e4 184
aa5d62cc
HX		 185static struct xfrm_state_afinfo *xfrm_state_lock_afinfo(unsigned int family)
186{
187 struct xfrm_state_afinfo *afinfo;
188 if (unlikely(family >= NPROTO))
189 return NULL;
190 write_lock_bh(&xfrm_state_afinfo_lock);
191 afinfo = xfrm_state_afinfo[family];
192 if (unlikely(!afinfo))
193 write_unlock_bh(&xfrm_state_afinfo_lock);
194 return afinfo;
195}
196
197static void xfrm_state_unlock_afinfo(struct xfrm_state_afinfo *afinfo)
9a429c49 198 __releases(xfrm_state_afinfo_lock)
aa5d62cc
HX		 199{
200 write_unlock_bh(&xfrm_state_afinfo_lock);
201}
202
533cb5b0 203int xfrm_register_type(const struct xfrm_type *type, unsigned short family)
aa5d62cc
HX		 204{
205 struct xfrm_state_afinfo *afinfo = xfrm_state_lock_afinfo(family);
533cb5b0 206 const struct xfrm_type **typemap;
aa5d62cc
HX		 207 int err = 0;
208
209 if (unlikely(afinfo == NULL))
210 return -EAFNOSUPPORT;
211 typemap = afinfo->type_map;
212
213 if (likely(typemap[type->proto] == NULL))
214 typemap[type->proto] = type;
215 else
216 err = -EEXIST;
217 xfrm_state_unlock_afinfo(afinfo);
218 return err;
219}
220EXPORT_SYMBOL(xfrm_register_type);
221
533cb5b0 222int xfrm_unregister_type(const struct xfrm_type *type, unsigned short family)
aa5d62cc
HX		 223{
224 struct xfrm_state_afinfo *afinfo = xfrm_state_lock_afinfo(family);
533cb5b0 225 const struct xfrm_type **typemap;
aa5d62cc
HX		 226 int err = 0;
227
228 if (unlikely(afinfo == NULL))
229 return -EAFNOSUPPORT;
230 typemap = afinfo->type_map;
231
232 if (unlikely(typemap[type->proto] != type))
233 err = -ENOENT;
234 else
235 typemap[type->proto] = NULL;
236 xfrm_state_unlock_afinfo(afinfo);
237 return err;
238}
239EXPORT_SYMBOL(xfrm_unregister_type);
240
533cb5b0 241static const struct xfrm_type *xfrm_get_type(u8 proto, unsigned short family)
aa5d62cc
HX		 242{
243 struct xfrm_state_afinfo *afinfo;
533cb5b0
ED		 244 const struct xfrm_type **typemap;
245 const struct xfrm_type *type;
aa5d62cc
HX		 246 int modload_attempted = 0;
247
248retry:
249 afinfo = xfrm_state_get_afinfo(family);
250 if (unlikely(afinfo == NULL))
251 return NULL;
252 typemap = afinfo->type_map;
253
254 type = typemap[proto];
255 if (unlikely(type && !try_module_get(type->owner)))
256 type = NULL;
257 if (!type && !modload_attempted) {
258 xfrm_state_put_afinfo(afinfo);
259 request_module("xfrm-type-%d-%d", family, proto);
260 modload_attempted = 1;
261 goto retry;
262 }
263
264 xfrm_state_put_afinfo(afinfo);
265 return type;
266}
267
533cb5b0 268static void xfrm_put_type(const struct xfrm_type *type)
aa5d62cc
HX		 269{
270 module_put(type->owner);
271}
272
273int xfrm_register_mode(struct xfrm_mode *mode, int family)
274{
275 struct xfrm_state_afinfo *afinfo;
276 struct xfrm_mode **modemap;
277 int err;
278
279 if (unlikely(mode->encap >= XFRM_MODE_MAX))
280 return -EINVAL;
281
282 afinfo = xfrm_state_lock_afinfo(family);
283 if (unlikely(afinfo == NULL))
284 return -EAFNOSUPPORT;
285
286 err = -EEXIST;
287 modemap = afinfo->mode_map;
17c2a42a
HX		 288 if (modemap[mode->encap])
289 goto out;
aa5d62cc 290
17c2a42a
HX		 291 err = -ENOENT;
292 if (!try_module_get(afinfo->owner))
293 goto out;
294
295 mode->afinfo = afinfo;
296 modemap[mode->encap] = mode;
297 err = 0;
298
299out:
aa5d62cc
HX		 300 xfrm_state_unlock_afinfo(afinfo);
301 return err;
302}
303EXPORT_SYMBOL(xfrm_register_mode);
304
305int xfrm_unregister_mode(struct xfrm_mode *mode, int family)
306{
307 struct xfrm_state_afinfo *afinfo;
308 struct xfrm_mode **modemap;
309 int err;
310
311 if (unlikely(mode->encap >= XFRM_MODE_MAX))
312 return -EINVAL;
313
314 afinfo = xfrm_state_lock_afinfo(family);
315 if (unlikely(afinfo == NULL))
316 return -EAFNOSUPPORT;
317
318 err = -ENOENT;
319 modemap = afinfo->mode_map;
320 if (likely(modemap[mode->encap] == mode)) {
321 modemap[mode->encap] = NULL;
17c2a42a 322 module_put(mode->afinfo->owner);
aa5d62cc
HX		 323 err = 0;
324 }
325
326 xfrm_state_unlock_afinfo(afinfo);
327 return err;
328}
329EXPORT_SYMBOL(xfrm_unregister_mode);
330
331static struct xfrm_mode *xfrm_get_mode(unsigned int encap, int family)
332{
333 struct xfrm_state_afinfo *afinfo;
334 struct xfrm_mode *mode;
335 int modload_attempted = 0;
336
337 if (unlikely(encap >= XFRM_MODE_MAX))
338 return NULL;
339
340retry:
341 afinfo = xfrm_state_get_afinfo(family);
342 if (unlikely(afinfo == NULL))
343 return NULL;
344
345 mode = afinfo->mode_map[encap];
346 if (unlikely(mode && !try_module_get(mode->owner)))
347 mode = NULL;
348 if (!mode && !modload_attempted) {
349 xfrm_state_put_afinfo(afinfo);
350 request_module("xfrm-mode-%d-%d", family, encap);
351 modload_attempted = 1;
352 goto retry;
353 }
354
355 xfrm_state_put_afinfo(afinfo);
356 return mode;
357}
358
359static void xfrm_put_mode(struct xfrm_mode *mode)
360{
361 module_put(mode->owner);
362}
363
1da177e4
LT		 364static void xfrm_state_gc_destroy(struct xfrm_state *x)
365{
a47f0ce0
DM		 366 del_timer_sync(&x->timer);
367 del_timer_sync(&x->rtimer);
a51482bd
JJ		 368 kfree(x->aalg);
369 kfree(x->ealg);
370 kfree(x->calg);
371 kfree(x->encap);
060f02a3 372 kfree(x->coaddr);
13996378
HX		 373 if (x->inner_mode)
374 xfrm_put_mode(x->inner_mode);
df9dcb45
KM		 375 if (x->inner_mode_iaf)
376 xfrm_put_mode(x->inner_mode_iaf);
13996378
HX		 377 if (x->outer_mode)
378 xfrm_put_mode(x->outer_mode);
1da177e4
LT		 379 if (x->type) {
380 x->type->destructor(x);
381 xfrm_put_type(x->type);
382 }
df71837d 383 security_xfrm_state_free(x);
1da177e4
LT		 384 kfree(x);
385}
386
c7837144 387static void xfrm_state_gc_task(struct work_struct *work)
1da177e4 388{
c7837144 389 struct net *net = container_of(work, struct net, xfrm.state_gc_work);
12a169e7
HX		 390 struct xfrm_state *x;
391 struct hlist_node *entry, *tmp;
392 struct hlist_head gc_list;
1da177e4 393
1da177e4 394 spin_lock_bh(&xfrm_state_gc_lock);
c7837144 395 hlist_move_list(&net->xfrm.state_gc_list, &gc_list);
1da177e4
LT		 396 spin_unlock_bh(&xfrm_state_gc_lock);
397
12a169e7 398 hlist_for_each_entry_safe(x, entry, tmp, &gc_list, gclist)
1da177e4 399 xfrm_state_gc_destroy(x);
8f126e37 400
50a30657 401 wake_up(&net->xfrm.km_waitq);
1da177e4
LT		 402}
403
404static inline unsigned long make_jiffies(long secs)
405{
406 if (secs >= (MAX_SCHEDULE_TIMEOUT-1)/HZ)
407 return MAX_SCHEDULE_TIMEOUT-1;
408 else
a716c119 409 return secs*HZ;
1da177e4
LT		 410}
411
412static void xfrm_timer_handler(unsigned long data)
413{
414 struct xfrm_state *x = (struct xfrm_state*)data;
98806f75 415 struct net *net = xs_net(x);
9d729f72 416 unsigned long now = get_seconds();
1da177e4
LT		 417 long next = LONG_MAX;
418 int warn = 0;
161a09e7 419 int err = 0;
1da177e4
LT		 420
421 spin_lock(&x->lock);
422 if (x->km.state == XFRM_STATE_DEAD)
423 goto out;
424 if (x->km.state == XFRM_STATE_EXPIRED)
425 goto expired;
426 if (x->lft.hard_add_expires_seconds) {
427 long tmo = x->lft.hard_add_expires_seconds +
428 x->curlft.add_time - now;
429 if (tmo <= 0)
430 goto expired;
431 if (tmo < next)
432 next = tmo;
433 }
434 if (x->lft.hard_use_expires_seconds) {
435 long tmo = x->lft.hard_use_expires_seconds +
436 (x->curlft.use_time ? : now) - now;
437 if (tmo <= 0)
438 goto expired;
439 if (tmo < next)
440 next = tmo;
441 }
442 if (x->km.dying)
443 goto resched;
444 if (x->lft.soft_add_expires_seconds) {
445 long tmo = x->lft.soft_add_expires_seconds +
446 x->curlft.add_time - now;
447 if (tmo <= 0)
448 warn = 1;
449 else if (tmo < next)
450 next = tmo;
451 }
452 if (x->lft.soft_use_expires_seconds) {
453 long tmo = x->lft.soft_use_expires_seconds +
454 (x->curlft.use_time ? : now) - now;
455 if (tmo <= 0)
456 warn = 1;
457 else if (tmo < next)
458 next = tmo;
459 }
460
4666faab 461 x->km.dying = warn;
1da177e4 462 if (warn)
53bc6b4d 463 km_state_expired(x, 0, 0);
1da177e4 464resched:
a47f0ce0
DM		 465 if (next != LONG_MAX)
466 mod_timer(&x->timer, jiffies + make_jiffies(next));
467
1da177e4
LT		 468 goto out;
469
470expired:
471 if (x->km.state == XFRM_STATE_ACQ && x->id.spi == 0) {
472 x->km.state = XFRM_STATE_EXPIRED;
98806f75 473 wake_up(&net->xfrm.km_waitq);
1da177e4
LT		 474 next = 2;
475 goto resched;
476 }
161a09e7
JL		 477
478 err = __xfrm_state_delete(x);
479 if (!err && x->id.spi)
53bc6b4d 480 km_state_expired(x, 1, 0);
1da177e4 481
ab5f5e8b 482 xfrm_audit_state_delete(x, err ? 0 : 1,
2532386f
EP		 483 audit_get_loginuid(current),
484 audit_get_sessionid(current), 0);
161a09e7 485
1da177e4
LT		 486out:
487 spin_unlock(&x->lock);
1da177e4
LT		 488}
489
0ac84752
DM		 490static void xfrm_replay_timer_handler(unsigned long data);
491
673c09be 492struct xfrm_state *xfrm_state_alloc(struct net *net)
1da177e4
LT		 493{
494 struct xfrm_state *x;
495
0da974f4 496 x = kzalloc(sizeof(struct xfrm_state), GFP_ATOMIC);
1da177e4
LT		 497
498 if (x) {
673c09be 499 write_pnet(&x->xs_net, net);
1da177e4
LT		 500 atomic_set(&x->refcnt, 1);
501 atomic_set(&x->tunnel_users, 0);
12a169e7 502 INIT_LIST_HEAD(&x->km.all);
8f126e37
DM		 503 INIT_HLIST_NODE(&x->bydst);
504 INIT_HLIST_NODE(&x->bysrc);
505 INIT_HLIST_NODE(&x->byspi);
b24b8a24
PE		 506 setup_timer(&x->timer, xfrm_timer_handler, (unsigned long)x);
507 setup_timer(&x->rtimer, xfrm_replay_timer_handler,
508 (unsigned long)x);
9d729f72 509 x->curlft.add_time = get_seconds();
1da177e4
LT		 510 x->lft.soft_byte_limit = XFRM_INF;
511 x->lft.soft_packet_limit = XFRM_INF;
512 x->lft.hard_byte_limit = XFRM_INF;
513 x->lft.hard_packet_limit = XFRM_INF;
f8cd5488
JHS		 514 x->replay_maxage = 0;
515 x->replay_maxdiff = 0;
df9dcb45
KM		 516 x->inner_mode = NULL;
517 x->inner_mode_iaf = NULL;
1da177e4
LT		 518 spin_lock_init(&x->lock);
519 }
520 return x;
521}
522EXPORT_SYMBOL(xfrm_state_alloc);
523
524void __xfrm_state_destroy(struct xfrm_state *x)
525{
98806f75
AD		 526 struct net *net = xs_net(x);
527
547b792c 528 WARN_ON(x->km.state != XFRM_STATE_DEAD);
1da177e4
LT		 529
530 spin_lock_bh(&xfrm_state_gc_lock);
98806f75 531 hlist_add_head(&x->gclist, &net->xfrm.state_gc_list);
1da177e4 532 spin_unlock_bh(&xfrm_state_gc_lock);
98806f75 533 schedule_work(&net->xfrm.state_gc_work);
1da177e4
LT		 534}
535EXPORT_SYMBOL(__xfrm_state_destroy);
536
53bc6b4d 537int __xfrm_state_delete(struct xfrm_state *x)
1da177e4 538{
98806f75 539 struct net *net = xs_net(x);
26b15dad
JHS		 540 int err = -ESRCH;
541
1da177e4
LT		 542 if (x->km.state != XFRM_STATE_DEAD) {
543 x->km.state = XFRM_STATE_DEAD;
544 spin_lock(&xfrm_state_lock);
12a169e7 545 list_del(&x->km.all);
8f126e37 546 hlist_del(&x->bydst);
8f126e37 547 hlist_del(&x->bysrc);
a47f0ce0 548 if (x->id.spi)
8f126e37 549 hlist_del(&x->byspi);
98806f75 550 net->xfrm.state_num--;
1da177e4 551 spin_unlock(&xfrm_state_lock);
1da177e4 552
1da177e4
LT		 553 /* All xfrm_state objects are created by xfrm_state_alloc.
554 * The xfrm_state_alloc call gives a reference, and that
555 * is what we are dropping here.
556 */
5dba4797 557 xfrm_state_put(x);
26b15dad 558 err = 0;
1da177e4 559 }
26b15dad
JHS		 560
561 return err;
1da177e4 562}
53bc6b4d 563EXPORT_SYMBOL(__xfrm_state_delete);
1da177e4 564
26b15dad 565int xfrm_state_delete(struct xfrm_state *x)
1da177e4 566{
26b15dad
JHS		 567 int err;
568
1da177e4 569 spin_lock_bh(&x->lock);
26b15dad 570 err = __xfrm_state_delete(x);
1da177e4 571 spin_unlock_bh(&x->lock);
26b15dad
JHS		 572
573 return err;
1da177e4
LT		 574}
575EXPORT_SYMBOL(xfrm_state_delete);
576
4aa2e62c
JL		 577#ifdef CONFIG_SECURITY_NETWORK_XFRM
578static inline int
579xfrm_state_flush_secctx_check(u8 proto, struct xfrm_audit *audit_info)
1da177e4 580{
4aa2e62c
JL		 581 int i, err = 0;
582
529983ec 583 for (i = 0; i <= init_net.xfrm.state_hmask; i++) {
4aa2e62c
JL		 584 struct hlist_node *entry;
585 struct xfrm_state *x;
586
73d189dc 587 hlist_for_each_entry(x, entry, init_net.xfrm.state_bydst+i, bydst) {
4aa2e62c
JL		 588 if (xfrm_id_proto_match(x->id.proto, proto) &&
589 (err = security_xfrm_state_delete(x)) != 0) {
ab5f5e8b
JL		 590 xfrm_audit_state_delete(x, 0,
591 audit_info->loginuid,
2532386f 592 audit_info->sessionid,
ab5f5e8b 593 audit_info->secid);
4aa2e62c
JL		 594 return err;
595 }
596 }
597 }
598
599 return err;
600}
601#else
602static inline int
603xfrm_state_flush_secctx_check(u8 proto, struct xfrm_audit *audit_info)
604{
605 return 0;
606}
607#endif
608
609int xfrm_state_flush(u8 proto, struct xfrm_audit *audit_info)
610{
611 int i, err = 0;
1da177e4
LT		 612
613 spin_lock_bh(&xfrm_state_lock);
4aa2e62c
JL		 614 err = xfrm_state_flush_secctx_check(proto, audit_info);
615 if (err)
616 goto out;
617
529983ec 618 for (i = 0; i <= init_net.xfrm.state_hmask; i++) {
8f126e37
DM		 619 struct hlist_node *entry;
620 struct xfrm_state *x;
1da177e4 621restart:
73d189dc 622 hlist_for_each_entry(x, entry, init_net.xfrm.state_bydst+i, bydst) {
1da177e4 623 if (!xfrm_state_kern(x) &&
5794708f 624 xfrm_id_proto_match(x->id.proto, proto)) {
1da177e4
LT		 625 xfrm_state_hold(x);
626 spin_unlock_bh(&xfrm_state_lock);
627
161a09e7 628 err = xfrm_state_delete(x);
ab5f5e8b
JL		 629 xfrm_audit_state_delete(x, err ? 0 : 1,
630 audit_info->loginuid,
2532386f 631 audit_info->sessionid,
ab5f5e8b 632 audit_info->secid);
1da177e4
LT		 633 xfrm_state_put(x);
634
635 spin_lock_bh(&xfrm_state_lock);
636 goto restart;
637 }
638 }
639 }
4aa2e62c
JL		 640 err = 0;
641
642out:
1da177e4 643 spin_unlock_bh(&xfrm_state_lock);
50a30657 644 wake_up(&init_net.xfrm.km_waitq);
4aa2e62c 645 return err;
1da177e4
LT		 646}
647EXPORT_SYMBOL(xfrm_state_flush);
648
af11e316 649void xfrm_sad_getinfo(struct xfrmk_sadinfo *si)
28d8909b
JHS		 650{
651 spin_lock_bh(&xfrm_state_lock);
0bf7c5b0 652 si->sadcnt = init_net.xfrm.state_num;
529983ec 653 si->sadhcnt = init_net.xfrm.state_hmask;
28d8909b
JHS		 654 si->sadhmcnt = xfrm_state_hashmax;
655 spin_unlock_bh(&xfrm_state_lock);
656}
657EXPORT_SYMBOL(xfrm_sad_getinfo);
658
1da177e4
LT		 659static int
660xfrm_init_tempsel(struct xfrm_state *x, struct flowi *fl,
661 struct xfrm_tmpl *tmpl,
662 xfrm_address_t *daddr, xfrm_address_t *saddr,
663 unsigned short family)
664{
665 struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
666 if (!afinfo)
667 return -1;
668 afinfo->init_tempsel(x, fl, tmpl, daddr, saddr);
669 xfrm_state_put_afinfo(afinfo);
670 return 0;
671}
672
a94cfd19 673static struct xfrm_state *__xfrm_state_lookup(xfrm_address_t *daddr, __be32 spi, u8 proto, unsigned short family)
edcd5821 674{
64d0cd00 675 unsigned int h = xfrm_spi_hash(&init_net, daddr, spi, proto, family);
edcd5821 676 struct xfrm_state *x;
8f126e37 677 struct hlist_node *entry;
edcd5821 678
b754a4fd 679 hlist_for_each_entry(x, entry, init_net.xfrm.state_byspi+h, byspi) {
edcd5821
DM		 680 if (x->props.family != family ||
681 x->id.spi != spi ||
682 x->id.proto != proto)
683 continue;
684
685 switch (family) {
686 case AF_INET:
687 if (x->id.daddr.a4 != daddr->a4)
688 continue;
689 break;
690 case AF_INET6:
691 if (!ipv6_addr_equal((struct in6_addr *)daddr,
692 (struct in6_addr *)
693 x->id.daddr.a6))
694 continue;
695 break;
3ff50b79 696 }
edcd5821
DM		 697
698 xfrm_state_hold(x);
699 return x;
700 }
701
702 return NULL;
703}
704
705static struct xfrm_state *__xfrm_state_lookup_byaddr(xfrm_address_t *daddr, xfrm_address_t *saddr, u8 proto, unsigned short family)
706{
64d0cd00 707 unsigned int h = xfrm_src_hash(&init_net, daddr, saddr, family);
edcd5821 708 struct xfrm_state *x;
8f126e37 709 struct hlist_node *entry;
edcd5821 710
d320bbb3 711 hlist_for_each_entry(x, entry, init_net.xfrm.state_bysrc+h, bysrc) {
edcd5821
DM		 712 if (x->props.family != family ||
713 x->id.proto != proto)
714 continue;
715
716 switch (family) {
717 case AF_INET:
718 if (x->id.daddr.a4 != daddr->a4 ||
719 x->props.saddr.a4 != saddr->a4)
720 continue;
721 break;
722 case AF_INET6:
723 if (!ipv6_addr_equal((struct in6_addr *)daddr,
724 (struct in6_addr *)
725 x->id.daddr.a6) ||
726 !ipv6_addr_equal((struct in6_addr *)saddr,
727 (struct in6_addr *)
728 x->props.saddr.a6))
729 continue;
730 break;
3ff50b79 731 }
edcd5821
DM		 732
733 xfrm_state_hold(x);
734 return x;
735 }
736
737 return NULL;
738}
739
740static inline struct xfrm_state *
741__xfrm_state_locate(struct xfrm_state *x, int use_spi, int family)
742{
743 if (use_spi)
744 return __xfrm_state_lookup(&x->id.daddr, x->id.spi,
745 x->id.proto, family);
746 else
747 return __xfrm_state_lookup_byaddr(&x->id.daddr,
748 &x->props.saddr,
749 x->id.proto, family);
750}
751
98806f75 752static void xfrm_hash_grow_check(struct net *net, int have_hash_collision)
2fab22f2
PM		 753{
754 if (have_hash_collision &&
98806f75
AD		 755 (net->xfrm.state_hmask + 1) < xfrm_state_hashmax &&
756 net->xfrm.state_num > net->xfrm.state_hmask)
757 schedule_work(&net->xfrm.state_hash_work);
2fab22f2
PM		 758}
759
1da177e4 760struct xfrm_state *
a716c119 761xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr,
1da177e4
LT		 762 struct flowi *fl, struct xfrm_tmpl *tmpl,
763 struct xfrm_policy *pol, int *err,
764 unsigned short family)
765{
4bda4f25 766 unsigned int h;
8f126e37 767 struct hlist_node *entry;
37b08e34 768 struct xfrm_state *x, *x0, *to_put;
1da177e4
LT		 769 int acquire_in_progress = 0;
770 int error = 0;
771 struct xfrm_state *best = NULL;
a716c119 772
37b08e34
DM		 773 to_put = NULL;
774
1da177e4 775 spin_lock_bh(&xfrm_state_lock);
64d0cd00 776 h = xfrm_dst_hash(&init_net, daddr, saddr, tmpl->reqid, family);
73d189dc 777 hlist_for_each_entry(x, entry, init_net.xfrm.state_bydst+h, bydst) {
1da177e4
LT		 778 if (x->props.family == family &&
779 x->props.reqid == tmpl->reqid &&
fbd9a5b4 780 !(x->props.flags & XFRM_STATE_WILDRECV) &&
1da177e4
LT		 781 xfrm_state_addr_check(x, daddr, saddr, family) &&
782 tmpl->mode == x->props.mode &&
783 tmpl->id.proto == x->id.proto &&
784 (tmpl->id.spi == x->id.spi || !tmpl->id.spi)) {
785 /* Resolution logic:
786 1. There is a valid state with matching selector.
787 Done.
788 2. Valid state with inappropriate selector. Skip.
789
790 Entering area of "sysdeps".
791
792 3. If state is not valid, selector is temporary,
793 it selects only session which triggered
794 previous resolution. Key manager will do
795 something to install a state with proper
796 selector.
797 */
798 if (x->km.state == XFRM_STATE_VALID) {
df9dcb45 799 if ((x->sel.family && !xfrm_selector_match(&x->sel, fl, x->sel.family)) ||
e0d1caa7 800 !security_xfrm_state_pol_flow_match(x, pol, fl))
1da177e4
LT		 801 continue;
802 if (!best ||
803 best->km.dying > x->km.dying ||
804 (best->km.dying == x->km.dying &&
805 best->curlft.add_time < x->curlft.add_time))
806 best = x;
807 } else if (x->km.state == XFRM_STATE_ACQ) {
808 acquire_in_progress = 1;
809 } else if (x->km.state == XFRM_STATE_ERROR ||
810 x->km.state == XFRM_STATE_EXPIRED) {
48b8d783 811 if (xfrm_selector_match(&x->sel, fl, x->sel.family) &&
e0d1caa7 812 security_xfrm_state_pol_flow_match(x, pol, fl))
1da177e4
LT		 813 error = -ESRCH;
814 }
815 }
816 }
817
818 x = best;
819 if (!x && !error && !acquire_in_progress) {
5c5d281a 820 if (tmpl->id.spi &&
edcd5821
DM		 821 (x0 = __xfrm_state_lookup(daddr, tmpl->id.spi,
822 tmpl->id.proto, family)) != NULL) {
37b08e34 823 to_put = x0;
1da177e4
LT		 824 error = -EEXIST;
825 goto out;
826 }
673c09be 827 x = xfrm_state_alloc(&init_net);
1da177e4
LT		 828 if (x == NULL) {
829 error = -ENOMEM;
830 goto out;
831 }
832 /* Initialize temporary selector matching only
833 * to current session. */
834 xfrm_init_tempsel(x, fl, tmpl, daddr, saddr, family);
835
e0d1caa7
VY		 836 error = security_xfrm_state_alloc_acquire(x, pol->security, fl->secid);
837 if (error) {
838 x->km.state = XFRM_STATE_DEAD;
37b08e34 839 to_put = x;
e0d1caa7
VY		 840 x = NULL;
841 goto out;
842 }
843
1da177e4
LT		 844 if (km_query(x, tmpl, pol) == 0) {
845 x->km.state = XFRM_STATE_ACQ;
9d4139c7 846 list_add(&x->km.all, &init_net.xfrm.state_all);
73d189dc 847 hlist_add_head(&x->bydst, init_net.xfrm.state_bydst+h);
64d0cd00 848 h = xfrm_src_hash(&init_net, daddr, saddr, family);
d320bbb3 849 hlist_add_head(&x->bysrc, init_net.xfrm.state_bysrc+h);
1da177e4 850 if (x->id.spi) {
64d0cd00 851 h = xfrm_spi_hash(&init_net, &x->id.daddr, x->id.spi, x->id.proto, family);
b754a4fd 852 hlist_add_head(&x->byspi, init_net.xfrm.state_byspi+h);
1da177e4 853 }
01e67d08
DM		 854 x->lft.hard_add_expires_seconds = sysctl_xfrm_acq_expires;
855 x->timer.expires = jiffies + sysctl_xfrm_acq_expires*HZ;
1da177e4 856 add_timer(&x->timer);
0bf7c5b0 857 init_net.xfrm.state_num++;
98806f75 858 xfrm_hash_grow_check(&init_net, x->bydst.next != NULL);
1da177e4
LT		 859 } else {
860 x->km.state = XFRM_STATE_DEAD;
37b08e34 861 to_put = x;
1da177e4
LT		 862 x = NULL;
863 error = -ESRCH;
864 }
865 }
866out:
867 if (x)
868 xfrm_state_hold(x);
869 else
870 *err = acquire_in_progress ? -EAGAIN : error;
871 spin_unlock_bh(&xfrm_state_lock);
37b08e34
DM		 872 if (to_put)
873 xfrm_state_put(to_put);
1da177e4
LT		 874 return x;
875}
876
628529b6
JHS		 877struct xfrm_state *
878xfrm_stateonly_find(xfrm_address_t *daddr, xfrm_address_t *saddr,
879 unsigned short family, u8 mode, u8 proto, u32 reqid)
880{
4bda4f25 881 unsigned int h;
628529b6
JHS		 882 struct xfrm_state *rx = NULL, *x = NULL;
883 struct hlist_node *entry;
884
885 spin_lock(&xfrm_state_lock);
64d0cd00 886 h = xfrm_dst_hash(&init_net, daddr, saddr, reqid, family);
73d189dc 887 hlist_for_each_entry(x, entry, init_net.xfrm.state_bydst+h, bydst) {
628529b6
JHS		 888 if (x->props.family == family &&
889 x->props.reqid == reqid &&
890 !(x->props.flags & XFRM_STATE_WILDRECV) &&
891 xfrm_state_addr_check(x, daddr, saddr, family) &&
892 mode == x->props.mode &&
893 proto == x->id.proto &&
894 x->km.state == XFRM_STATE_VALID) {
895 rx = x;
896 break;
897 }
898 }
899
900 if (rx)
901 xfrm_state_hold(rx);
902 spin_unlock(&xfrm_state_lock);
903
904
905 return rx;
906}
907EXPORT_SYMBOL(xfrm_stateonly_find);
908
1da177e4
LT		 909static void __xfrm_state_insert(struct xfrm_state *x)
910{
98806f75 911 struct net *net = xs_net(x);
a624c108 912 unsigned int h;
1da177e4 913
9d4a706d
DM		 914 x->genid = ++xfrm_state_genid;
915
98806f75 916 list_add(&x->km.all, &net->xfrm.state_all);
4c563f76 917
98806f75 918 h = xfrm_dst_hash(net, &x->id.daddr, &x->props.saddr,
c1969f29 919 x->props.reqid, x->props.family);
98806f75 920 hlist_add_head(&x->bydst, net->xfrm.state_bydst+h);
1da177e4 921
98806f75
AD		 922 h = xfrm_src_hash(net, &x->id.daddr, &x->props.saddr, x->props.family);
923 hlist_add_head(&x->bysrc, net->xfrm.state_bysrc+h);
1da177e4 924
7b4dc360 925 if (x->id.spi) {
98806f75 926 h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto,
6c44e6b7
MN		 927 x->props.family);
928
98806f75 929 hlist_add_head(&x->byspi, net->xfrm.state_byspi+h);
6c44e6b7
MN		 930 }
931
a47f0ce0
DM		 932 mod_timer(&x->timer, jiffies + HZ);
933 if (x->replay_maxage)
934 mod_timer(&x->rtimer, jiffies + x->replay_maxage);
f8cd5488 935
98806f75 936 wake_up(&net->xfrm.km_waitq);
f034b5d4 937
98806f75 938 net->xfrm.state_num++;
f034b5d4 939
98806f75 940 xfrm_hash_grow_check(net, x->bydst.next != NULL);
1da177e4
LT		 941}
942
c7f5ea3a
DM		 943/* xfrm_state_lock is held */
944static void __xfrm_state_bump_genids(struct xfrm_state *xnew)
945{
98806f75 946 struct net *net = xs_net(xnew);
c7f5ea3a
DM		 947 unsigned short family = xnew->props.family;
948 u32 reqid = xnew->props.reqid;
949 struct xfrm_state *x;
950 struct hlist_node *entry;
951 unsigned int h;
952
98806f75
AD		 953 h = xfrm_dst_hash(net, &xnew->id.daddr, &xnew->props.saddr, reqid, family);
954 hlist_for_each_entry(x, entry, net->xfrm.state_bydst+h, bydst) {
c7f5ea3a
DM		 955 if (x->props.family == family &&
956 x->props.reqid == reqid &&
c1969f29
DM		 957 !xfrm_addr_cmp(&x->id.daddr, &xnew->id.daddr, family) &&
958 !xfrm_addr_cmp(&x->props.saddr, &xnew->props.saddr, family))
c7f5ea3a
DM		 959 x->genid = xfrm_state_genid;
960 }
961}
962
1da177e4
LT		 963void xfrm_state_insert(struct xfrm_state *x)
964{
965 spin_lock_bh(&xfrm_state_lock);
c7f5ea3a 966 __xfrm_state_bump_genids(x);
1da177e4
LT		 967 __xfrm_state_insert(x);
968 spin_unlock_bh(&xfrm_state_lock);
969}
970EXPORT_SYMBOL(xfrm_state_insert);
971
2770834c
DM		 972/* xfrm_state_lock is held */
973static struct xfrm_state *__find_acq_core(unsigned short family, u8 mode, u32 reqid, u8 proto, xfrm_address_t *daddr, xfrm_address_t *saddr, int create)
974{
64d0cd00 975 unsigned int h = xfrm_dst_hash(&init_net, daddr, saddr, reqid, family);
8f126e37 976 struct hlist_node *entry;
2770834c
DM		 977 struct xfrm_state *x;
978
73d189dc 979 hlist_for_each_entry(x, entry, init_net.xfrm.state_bydst+h, bydst) {
2770834c
DM		 980 if (x->props.reqid != reqid ||
981 x->props.mode != mode ||
982 x->props.family != family ||
983 x->km.state != XFRM_STATE_ACQ ||
75e252d9
JL		 984 x->id.spi != 0 ||
985 x->id.proto != proto)
2770834c
DM		 986 continue;
987
988 switch (family) {
989 case AF_INET:
990 if (x->id.daddr.a4 != daddr->a4 ||
991 x->props.saddr.a4 != saddr->a4)
992 continue;
993 break;
994 case AF_INET6:
995 if (!ipv6_addr_equal((struct in6_addr *)x->id.daddr.a6,
996 (struct in6_addr *)daddr) ||
997 !ipv6_addr_equal((struct in6_addr *)
998 x->props.saddr.a6,
999 (struct in6_addr *)saddr))
1000 continue;
1001 break;
3ff50b79 1002 }
2770834c
DM		 1003
1004 xfrm_state_hold(x);
1005 return x;
1006 }
1007
1008 if (!create)
1009 return NULL;
1010
673c09be 1011 x = xfrm_state_alloc(&init_net);
2770834c
DM		 1012 if (likely(x)) {
1013 switch (family) {
1014 case AF_INET:
1015 x->sel.daddr.a4 = daddr->a4;
1016 x->sel.saddr.a4 = saddr->a4;
1017 x->sel.prefixlen_d = 32;
1018 x->sel.prefixlen_s = 32;
1019 x->props.saddr.a4 = saddr->a4;
1020 x->id.daddr.a4 = daddr->a4;
1021 break;
1022
1023 case AF_INET6:
1024 ipv6_addr_copy((struct in6_addr *)x->sel.daddr.a6,
1025 (struct in6_addr *)daddr);
1026 ipv6_addr_copy((struct in6_addr *)x->sel.saddr.a6,
1027 (struct in6_addr *)saddr);
1028 x->sel.prefixlen_d = 128;
1029 x->sel.prefixlen_s = 128;
1030 ipv6_addr_copy((struct in6_addr *)x->props.saddr.a6,
1031 (struct in6_addr *)saddr);
1032 ipv6_addr_copy((struct in6_addr *)x->id.daddr.a6,
1033 (struct in6_addr *)daddr);
1034 break;
3ff50b79 1035 }
2770834c
DM		 1036
1037 x->km.state = XFRM_STATE_ACQ;
1038 x->id.proto = proto;
1039 x->props.family = family;
1040 x->props.mode = mode;
1041 x->props.reqid = reqid;
01e67d08 1042 x->lft.hard_add_expires_seconds = sysctl_xfrm_acq_expires;
2770834c 1043 xfrm_state_hold(x);
01e67d08 1044 x->timer.expires = jiffies + sysctl_xfrm_acq_expires*HZ;
2770834c 1045 add_timer(&x->timer);
9d4139c7 1046 list_add(&x->km.all, &init_net.xfrm.state_all);
73d189dc 1047 hlist_add_head(&x->bydst, init_net.xfrm.state_bydst+h);
64d0cd00 1048 h = xfrm_src_hash(&init_net, daddr, saddr, family);
d320bbb3 1049 hlist_add_head(&x->bysrc, init_net.xfrm.state_bysrc+h);
918049f0 1050
0bf7c5b0 1051 init_net.xfrm.state_num++;
918049f0 1052
98806f75 1053 xfrm_hash_grow_check(&init_net, x->bydst.next != NULL);
2770834c
DM		 1054 }
1055
1056 return x;
1057}
1058
1da177e4
LT		 1059static struct xfrm_state *__xfrm_find_acq_byseq(u32 seq);
1060
1061int xfrm_state_add(struct xfrm_state *x)
1062{
37b08e34 1063 struct xfrm_state *x1, *to_put;
1da177e4
LT		 1064 int family;
1065 int err;
eb2971b6 1066 int use_spi = xfrm_id_proto_match(x->id.proto, IPSEC_PROTO_ANY);
1da177e4
LT		 1067
1068 family = x->props.family;
1da177e4 1069
37b08e34
DM		 1070 to_put = NULL;
1071
1da177e4
LT		 1072 spin_lock_bh(&xfrm_state_lock);
1073
edcd5821 1074 x1 = __xfrm_state_locate(x, use_spi, family);
1da177e4 1075 if (x1) {
37b08e34 1076 to_put = x1;
1da177e4
LT		 1077 x1 = NULL;
1078 err = -EEXIST;
1079 goto out;
1080 }
1081
eb2971b6 1082 if (use_spi && x->km.seq) {
1da177e4 1083 x1 = __xfrm_find_acq_byseq(x->km.seq);
75e252d9
JL		 1084 if (x1 && ((x1->id.proto != x->id.proto) ||
1085 xfrm_addr_cmp(&x1->id.daddr, &x->id.daddr, family))) {
37b08e34 1086 to_put = x1;
1da177e4
LT		 1087 x1 = NULL;
1088 }
1089 }
1090
eb2971b6 1091 if (use_spi && !x1)
2770834c
DM		 1092 x1 = __find_acq_core(family, x->props.mode, x->props.reqid,
1093 x->id.proto,
1094 &x->id.daddr, &x->props.saddr, 0);
1da177e4 1095
c7f5ea3a 1096 __xfrm_state_bump_genids(x);
1da177e4
LT		 1097 __xfrm_state_insert(x);
1098 err = 0;
1099
1100out:
1101 spin_unlock_bh(&xfrm_state_lock);
1da177e4
LT		 1102
1103 if (x1) {
1104 xfrm_state_delete(x1);
1105 xfrm_state_put(x1);
1106 }
1107
37b08e34
DM		 1108 if (to_put)
1109 xfrm_state_put(to_put);
1110
1da177e4
LT		 1111 return err;
1112}
1113EXPORT_SYMBOL(xfrm_state_add);
1114
80c9abaa 1115#ifdef CONFIG_XFRM_MIGRATE
6666351d 1116static struct xfrm_state *xfrm_state_clone(struct xfrm_state *orig, int *errp)
80c9abaa 1117{
98806f75 1118 struct net *net = xs_net(orig);
80c9abaa 1119 int err = -ENOMEM;
98806f75 1120 struct xfrm_state *x = xfrm_state_alloc(net);
80c9abaa
SS		 1121 if (!x)
1122 goto error;
1123
1124 memcpy(&x->id, &orig->id, sizeof(x->id));
1125 memcpy(&x->sel, &orig->sel, sizeof(x->sel));
1126 memcpy(&x->lft, &orig->lft, sizeof(x->lft));
1127 x->props.mode = orig->props.mode;
1128 x->props.replay_window = orig->props.replay_window;
1129 x->props.reqid = orig->props.reqid;
1130 x->props.family = orig->props.family;
1131 x->props.saddr = orig->props.saddr;
1132
1133 if (orig->aalg) {
1134 x->aalg = xfrm_algo_clone(orig->aalg);
1135 if (!x->aalg)
1136 goto error;
1137 }
1138 x->props.aalgo = orig->props.aalgo;
1139
1140 if (orig->ealg) {
1141 x->ealg = xfrm_algo_clone(orig->ealg);
1142 if (!x->ealg)
1143 goto error;
1144 }
1145 x->props.ealgo = orig->props.ealgo;
1146
1147 if (orig->calg) {
1148 x->calg = xfrm_algo_clone(orig->calg);
1149 if (!x->calg)
1150 goto error;
1151 }
1152 x->props.calgo = orig->props.calgo;
1153
a716c119 1154 if (orig->encap) {
80c9abaa
SS		 1155 x->encap = kmemdup(orig->encap, sizeof(*x->encap), GFP_KERNEL);
1156 if (!x->encap)
1157 goto error;
1158 }
1159
1160 if (orig->coaddr) {
1161 x->coaddr = kmemdup(orig->coaddr, sizeof(*x->coaddr),
1162 GFP_KERNEL);
1163 if (!x->coaddr)
1164 goto error;
1165 }
1166
1167 err = xfrm_init_state(x);
1168 if (err)
1169 goto error;
1170
1171 x->props.flags = orig->props.flags;
1172
1173 x->curlft.add_time = orig->curlft.add_time;
1174 x->km.state = orig->km.state;
1175 x->km.seq = orig->km.seq;
1176
1177 return x;
1178
1179 error:
1180 if (errp)
1181 *errp = err;
1182 if (x) {
1183 kfree(x->aalg);
1184 kfree(x->ealg);
1185 kfree(x->calg);
1186 kfree(x->encap);
1187 kfree(x->coaddr);
1188 }
1189 kfree(x);
1190 return NULL;
1191}
80c9abaa
SS		 1192
1193/* xfrm_state_lock is held */
1194struct xfrm_state * xfrm_migrate_state_find(struct xfrm_migrate *m)
1195{
1196 unsigned int h;
1197 struct xfrm_state *x;
1198 struct hlist_node *entry;
1199
1200 if (m->reqid) {
64d0cd00 1201 h = xfrm_dst_hash(&init_net, &m->old_daddr, &m->old_saddr,
80c9abaa 1202 m->reqid, m->old_family);
73d189dc 1203 hlist_for_each_entry(x, entry, init_net.xfrm.state_bydst+h, bydst) {
80c9abaa
SS		 1204 if (x->props.mode != m->mode ||
1205 x->id.proto != m->proto)
1206 continue;
1207 if (m->reqid && x->props.reqid != m->reqid)
1208 continue;
1209 if (xfrm_addr_cmp(&x->id.daddr, &m->old_daddr,
1210 m->old_family) ||
1211 xfrm_addr_cmp(&x->props.saddr, &m->old_saddr,
1212 m->old_family))
1213 continue;
1214 xfrm_state_hold(x);
1215 return x;
1216 }
1217 } else {
64d0cd00 1218 h = xfrm_src_hash(&init_net, &m->old_daddr, &m->old_saddr,
80c9abaa 1219 m->old_family);
d320bbb3 1220 hlist_for_each_entry(x, entry, init_net.xfrm.state_bysrc+h, bysrc) {
80c9abaa
SS		 1221 if (x->props.mode != m->mode ||
1222 x->id.proto != m->proto)
1223 continue;
1224 if (xfrm_addr_cmp(&x->id.daddr, &m->old_daddr,
1225 m->old_family) ||
1226 xfrm_addr_cmp(&x->props.saddr, &m->old_saddr,
1227 m->old_family))
1228 continue;
1229 xfrm_state_hold(x);
1230 return x;
1231 }
1232 }
1233
a716c119 1234 return NULL;
80c9abaa
SS		 1235}
1236EXPORT_SYMBOL(xfrm_migrate_state_find);
1237
1238struct xfrm_state * xfrm_state_migrate(struct xfrm_state *x,
1239 struct xfrm_migrate *m)
1240{
1241 struct xfrm_state *xc;
1242 int err;
1243
1244 xc = xfrm_state_clone(x, &err);
1245 if (!xc)
1246 return NULL;
1247
1248 memcpy(&xc->id.daddr, &m->new_daddr, sizeof(xc->id.daddr));
1249 memcpy(&xc->props.saddr, &m->new_saddr, sizeof(xc->props.saddr));
1250
1251 /* add state */
1252 if (!xfrm_addr_cmp(&x->id.daddr, &m->new_daddr, m->new_family)) {
1253 /* a care is needed when the destination address of the
1254 state is to be updated as it is a part of triplet */
1255 xfrm_state_insert(xc);
1256 } else {
1257 if ((err = xfrm_state_add(xc)) < 0)
1258 goto error;
1259 }
1260
1261 return xc;
1262error:
1263 kfree(xc);
1264 return NULL;
1265}
1266EXPORT_SYMBOL(xfrm_state_migrate);
1267#endif
1268
1da177e4
LT		 1269int xfrm_state_update(struct xfrm_state *x)
1270{
37b08e34 1271 struct xfrm_state *x1, *to_put;
1da177e4 1272 int err;
eb2971b6 1273 int use_spi = xfrm_id_proto_match(x->id.proto, IPSEC_PROTO_ANY);
1da177e4 1274
37b08e34
DM		 1275 to_put = NULL;
1276
1da177e4 1277 spin_lock_bh(&xfrm_state_lock);
edcd5821 1278 x1 = __xfrm_state_locate(x, use_spi, x->props.family);
1da177e4
LT		 1279
1280 err = -ESRCH;
1281 if (!x1)
1282 goto out;
1283
1284 if (xfrm_state_kern(x1)) {
37b08e34 1285 to_put = x1;
1da177e4
LT		 1286 err = -EEXIST;
1287 goto out;
1288 }
1289
1290 if (x1->km.state == XFRM_STATE_ACQ) {
1291 __xfrm_state_insert(x);
1292 x = NULL;
1293 }
1294 err = 0;
1295
1296out:
1297 spin_unlock_bh(&xfrm_state_lock);
1da177e4 1298
37b08e34
DM		 1299 if (to_put)
1300 xfrm_state_put(to_put);
1301
1da177e4
LT		 1302 if (err)
1303 return err;
1304
1305 if (!x) {
1306 xfrm_state_delete(x1);
1307 xfrm_state_put(x1);
1308 return 0;
1309 }
1310
1311 err = -EINVAL;
1312 spin_lock_bh(&x1->lock);
1313 if (likely(x1->km.state == XFRM_STATE_VALID)) {
1314 if (x->encap && x1->encap)
1315 memcpy(x1->encap, x->encap, sizeof(*x1->encap));
060f02a3
NT		 1316 if (x->coaddr && x1->coaddr) {
1317 memcpy(x1->coaddr, x->coaddr, sizeof(*x1->coaddr));
1318 }
1319 if (!use_spi && memcmp(&x1->sel, &x->sel, sizeof(x1->sel)))
1320 memcpy(&x1->sel, &x->sel, sizeof(x1->sel));
1da177e4
LT		 1321 memcpy(&x1->lft, &x->lft, sizeof(x1->lft));
1322 x1->km.dying = 0;
1323
a47f0ce0 1324 mod_timer(&x1->timer, jiffies + HZ);
1da177e4
LT		 1325 if (x1->curlft.use_time)
1326 xfrm_state_check_expire(x1);
1327
1328 err = 0;
1329 }
1330 spin_unlock_bh(&x1->lock);
1331
1332 xfrm_state_put(x1);
1333
1334 return err;
1335}
1336EXPORT_SYMBOL(xfrm_state_update);
1337
1338int xfrm_state_check_expire(struct xfrm_state *x)
1339{
1340 if (!x->curlft.use_time)
9d729f72 1341 x->curlft.use_time = get_seconds();
1da177e4
LT		 1342
1343 if (x->km.state != XFRM_STATE_VALID)
1344 return -EINVAL;
1345
1346 if (x->curlft.bytes >= x->lft.hard_byte_limit ||
1347 x->curlft.packets >= x->lft.hard_packet_limit) {
4666faab 1348 x->km.state = XFRM_STATE_EXPIRED;
a47f0ce0 1349 mod_timer(&x->timer, jiffies);
1da177e4
LT		 1350 return -EINVAL;
1351 }
1352
1353 if (!x->km.dying &&
1354 (x->curlft.bytes >= x->lft.soft_byte_limit ||
4666faab
HX		 1355 x->curlft.packets >= x->lft.soft_packet_limit)) {
1356 x->km.dying = 1;
53bc6b4d 1357 km_state_expired(x, 0, 0);
4666faab 1358 }
1da177e4
LT		 1359 return 0;
1360}
1361EXPORT_SYMBOL(xfrm_state_check_expire);
1362
1da177e4 1363struct xfrm_state *
a94cfd19 1364xfrm_state_lookup(xfrm_address_t *daddr, __be32 spi, u8 proto,
1da177e4
LT		 1365 unsigned short family)
1366{
1367 struct xfrm_state *x;
1da177e4
LT		 1368
1369 spin_lock_bh(&xfrm_state_lock);
edcd5821 1370 x = __xfrm_state_lookup(daddr, spi, proto, family);
1da177e4 1371 spin_unlock_bh(&xfrm_state_lock);
1da177e4
LT		 1372 return x;
1373}
1374EXPORT_SYMBOL(xfrm_state_lookup);
1375
1376struct xfrm_state *
eb2971b6
MN		 1377xfrm_state_lookup_byaddr(xfrm_address_t *daddr, xfrm_address_t *saddr,
1378 u8 proto, unsigned short family)
1379{
1380 struct xfrm_state *x;
eb2971b6
MN		 1381
1382 spin_lock_bh(&xfrm_state_lock);
edcd5821 1383 x = __xfrm_state_lookup_byaddr(daddr, saddr, proto, family);
eb2971b6 1384 spin_unlock_bh(&xfrm_state_lock);
eb2971b6
MN		 1385 return x;
1386}
1387EXPORT_SYMBOL(xfrm_state_lookup_byaddr);
1388
1389struct xfrm_state *
a716c119
YH		 1390xfrm_find_acq(u8 mode, u32 reqid, u8 proto,
1391 xfrm_address_t *daddr, xfrm_address_t *saddr,
1da177e4
LT		 1392 int create, unsigned short family)
1393{
1394 struct xfrm_state *x;
1da177e4
LT		 1395
1396 spin_lock_bh(&xfrm_state_lock);
2770834c 1397 x = __find_acq_core(family, mode, reqid, proto, daddr, saddr, create);
1da177e4 1398 spin_unlock_bh(&xfrm_state_lock);
2770834c 1399
1da177e4
LT		 1400 return x;
1401}
1402EXPORT_SYMBOL(xfrm_find_acq);
1403
41a49cc3
MN		 1404#ifdef CONFIG_XFRM_SUB_POLICY
1405int
1406xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,
1407 unsigned short family)
1408{
1409 int err = 0;
1410 struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
1411 if (!afinfo)
1412 return -EAFNOSUPPORT;
1413
1414 spin_lock_bh(&xfrm_state_lock);
1415 if (afinfo->tmpl_sort)
1416 err = afinfo->tmpl_sort(dst, src, n);
1417 spin_unlock_bh(&xfrm_state_lock);
1418 xfrm_state_put_afinfo(afinfo);
1419 return err;
1420}
1421EXPORT_SYMBOL(xfrm_tmpl_sort);
1422
1423int
1424xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src, int n,
1425 unsigned short family)
1426{
1427 int err = 0;
1428 struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
1429 if (!afinfo)
1430 return -EAFNOSUPPORT;
1431
1432 spin_lock_bh(&xfrm_state_lock);
1433 if (afinfo->state_sort)
1434 err = afinfo->state_sort(dst, src, n);
1435 spin_unlock_bh(&xfrm_state_lock);
1436 xfrm_state_put_afinfo(afinfo);
1437 return err;
1438}
1439EXPORT_SYMBOL(xfrm_state_sort);
1440#endif
1441
1da177e4
LT		 1442/* Silly enough, but I'm lazy to build resolution list */
1443
1444static struct xfrm_state *__xfrm_find_acq_byseq(u32 seq)
1445{
1446 int i;
1da177e4 1447
529983ec 1448 for (i = 0; i <= init_net.xfrm.state_hmask; i++) {
8f126e37
DM		 1449 struct hlist_node *entry;
1450 struct xfrm_state *x;
1451
73d189dc 1452 hlist_for_each_entry(x, entry, init_net.xfrm.state_bydst+i, bydst) {
8f126e37
DM		 1453 if (x->km.seq == seq &&
1454 x->km.state == XFRM_STATE_ACQ) {
1da177e4
LT		 1455 xfrm_state_hold(x);
1456 return x;
1457 }
1458 }
1459 }
1460 return NULL;
1461}
1462
1463struct xfrm_state *xfrm_find_acq_byseq(u32 seq)
1464{
1465 struct xfrm_state *x;
1466
1467 spin_lock_bh(&xfrm_state_lock);
1468 x = __xfrm_find_acq_byseq(seq);
1469 spin_unlock_bh(&xfrm_state_lock);
1470 return x;
1471}
1472EXPORT_SYMBOL(xfrm_find_acq_byseq);
1473
1474u32 xfrm_get_acqseq(void)
1475{
1476 u32 res;
1477 static u32 acqseq;
1478 static DEFINE_SPINLOCK(acqseq_lock);
1479
1480 spin_lock_bh(&acqseq_lock);
1481 res = (++acqseq ? : ++acqseq);
1482 spin_unlock_bh(&acqseq_lock);
1483 return res;
1484}
1485EXPORT_SYMBOL(xfrm_get_acqseq);
1486
658b219e 1487int xfrm_alloc_spi(struct xfrm_state *x, u32 low, u32 high)
1da177e4 1488{
f034b5d4 1489 unsigned int h;
1da177e4 1490 struct xfrm_state *x0;
658b219e
HX		 1491 int err = -ENOENT;
1492 __be32 minspi = htonl(low);
1493 __be32 maxspi = htonl(high);
1da177e4 1494
658b219e
HX		 1495 spin_lock_bh(&x->lock);
1496 if (x->km.state == XFRM_STATE_DEAD)
1497 goto unlock;
1498
1499 err = 0;
1da177e4 1500 if (x->id.spi)
658b219e
HX		 1501 goto unlock;
1502
1503 err = -ENOENT;
1da177e4
LT		 1504
1505 if (minspi == maxspi) {
1506 x0 = xfrm_state_lookup(&x->id.daddr, minspi, x->id.proto, x->props.family);
1507 if (x0) {
1508 xfrm_state_put(x0);
658b219e 1509 goto unlock;
1da177e4
LT		 1510 }
1511 x->id.spi = minspi;
1512 } else {
1513 u32 spi = 0;
26977b4e
AV		 1514 for (h=0; h<high-low+1; h++) {
1515 spi = low + net_random()%(high-low+1);
1da177e4
LT		 1516 x0 = xfrm_state_lookup(&x->id.daddr, htonl(spi), x->id.proto, x->props.family);
1517 if (x0 == NULL) {
1518 x->id.spi = htonl(spi);
1519 break;
1520 }
1521 xfrm_state_put(x0);
1522 }
1523 }
1524 if (x->id.spi) {
1525 spin_lock_bh(&xfrm_state_lock);
64d0cd00 1526 h = xfrm_spi_hash(&init_net, &x->id.daddr, x->id.spi, x->id.proto, x->props.family);
b754a4fd 1527 hlist_add_head(&x->byspi, init_net.xfrm.state_byspi+h);
1da177e4 1528 spin_unlock_bh(&xfrm_state_lock);
658b219e
HX		 1529
1530 err = 0;
1da177e4 1531 }
658b219e
HX		 1532
1533unlock:
1534 spin_unlock_bh(&x->lock);
1535
1536 return err;
1da177e4
LT		 1537}
1538EXPORT_SYMBOL(xfrm_alloc_spi);
1539
4c563f76
TT		 1540int xfrm_state_walk(struct xfrm_state_walk *walk,
1541 int (*func)(struct xfrm_state *, int, void*),
1da177e4
LT		 1542 void *data)
1543{
12a169e7
HX		 1544 struct xfrm_state *state;
1545 struct xfrm_state_walk *x;
1da177e4
LT		 1546 int err = 0;
1547
12a169e7 1548 if (walk->seq != 0 && list_empty(&walk->all))
4c563f76
TT		 1549 return 0;
1550
1da177e4 1551 spin_lock_bh(&xfrm_state_lock);
12a169e7 1552 if (list_empty(&walk->all))
9d4139c7 1553 x = list_first_entry(&init_net.xfrm.state_all, struct xfrm_state_walk, all);
12a169e7
HX		 1554 else
1555 x = list_entry(&walk->all, struct xfrm_state_walk, all);
9d4139c7 1556 list_for_each_entry_from(x, &init_net.xfrm.state_all, all) {
12a169e7 1557 if (x->state == XFRM_STATE_DEAD)
4c563f76 1558 continue;
12a169e7
HX		 1559 state = container_of(x, struct xfrm_state, km);
1560 if (!xfrm_id_proto_match(state->id.proto, walk->proto))
4c563f76 1561 continue;
12a169e7
HX		 1562 err = func(state, walk->seq, data);
1563 if (err) {
1564 list_move_tail(&walk->all, &x->all);
1565 goto out;
1da177e4 1566 }
12a169e7 1567 walk->seq++;
1da177e4 1568 }
12a169e7 1569 if (walk->seq == 0) {
1da177e4
LT		 1570 err = -ENOENT;
1571 goto out;
1572 }
12a169e7 1573 list_del_init(&walk->all);
1da177e4
LT		 1574out:
1575 spin_unlock_bh(&xfrm_state_lock);
1576 return err;
1577}
1578EXPORT_SYMBOL(xfrm_state_walk);
1579
5c182458
HX		 1580void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto)
1581{
12a169e7 1582 INIT_LIST_HEAD(&walk->all);
5c182458 1583 walk->proto = proto;
12a169e7
HX		 1584 walk->state = XFRM_STATE_DEAD;
1585 walk->seq = 0;
5c182458
HX		 1586}
1587EXPORT_SYMBOL(xfrm_state_walk_init);
1588
abb81c4f
HX		 1589void xfrm_state_walk_done(struct xfrm_state_walk *walk)
1590{
12a169e7 1591 if (list_empty(&walk->all))
5c182458 1592 return;
5c182458 1593
12a169e7
HX		 1594 spin_lock_bh(&xfrm_state_lock);
1595 list_del(&walk->all);
1596 spin_lock_bh(&xfrm_state_lock);
abb81c4f
HX		 1597}
1598EXPORT_SYMBOL(xfrm_state_walk_done);
1599
f8cd5488
JHS		 1600
1601void xfrm_replay_notify(struct xfrm_state *x, int event)
1602{
1603 struct km_event c;
1604 /* we send notify messages in case
1605 * 1. we updated on of the sequence numbers, and the seqno difference
1606 * is at least x->replay_maxdiff, in this case we also update the
1607 * timeout of our timer function
1608 * 2. if x->replay_maxage has elapsed since last update,
1609 * and there were changes
1610 *
1611 * The state structure must be locked!
1612 */
1613
1614 switch (event) {
1615 case XFRM_REPLAY_UPDATE:
1616 if (x->replay_maxdiff &&
1617 (x->replay.seq - x->preplay.seq < x->replay_maxdiff) &&
2717096a
JHS		 1618 (x->replay.oseq - x->preplay.oseq < x->replay_maxdiff)) {
1619 if (x->xflags & XFRM_TIME_DEFER)
1620 event = XFRM_REPLAY_TIMEOUT;
1621 else
1622 return;
1623 }
f8cd5488
JHS		 1624
1625 break;
1626
1627 case XFRM_REPLAY_TIMEOUT:
1628 if ((x->replay.seq == x->preplay.seq) &&
1629 (x->replay.bitmap == x->preplay.bitmap) &&
2717096a
JHS		 1630 (x->replay.oseq == x->preplay.oseq)) {
1631 x->xflags |= XFRM_TIME_DEFER;
f8cd5488 1632 return;
2717096a 1633 }
f8cd5488
JHS		 1634
1635 break;
1636 }
1637
1638 memcpy(&x->preplay, &x->replay, sizeof(struct xfrm_replay_state));
1639 c.event = XFRM_MSG_NEWAE;
1640 c.data.aevent = event;
1641 km_state_notify(x, &c);
1642
f8cd5488 1643 if (x->replay_maxage &&
a47f0ce0 1644 !mod_timer(&x->rtimer, jiffies + x->replay_maxage))
2717096a 1645 x->xflags &= ~XFRM_TIME_DEFER;
f8cd5488
JHS		 1646}
1647
1648static void xfrm_replay_timer_handler(unsigned long data)
1649{
1650 struct xfrm_state *x = (struct xfrm_state*)data;
1651
1652 spin_lock(&x->lock);
1653
2717096a
JHS		 1654 if (x->km.state == XFRM_STATE_VALID) {
1655 if (xfrm_aevent_is_on())
1656 xfrm_replay_notify(x, XFRM_REPLAY_TIMEOUT);
1657 else
1658 x->xflags |= XFRM_TIME_DEFER;
1659 }
f8cd5488
JHS		 1660
1661 spin_unlock(&x->lock);
1662}
1663
afeb14b4
PM		 1664int xfrm_replay_check(struct xfrm_state *x,
1665 struct sk_buff *skb, __be32 net_seq)
1da177e4
LT		 1666{
1667 u32 diff;
a252cc23 1668 u32 seq = ntohl(net_seq);
1da177e4
LT		 1669
1670 if (unlikely(seq == 0))
afeb14b4 1671 goto err;
1da177e4
LT		 1672
1673 if (likely(seq > x->replay.seq))
1674 return 0;
1675
1676 diff = x->replay.seq - seq;
4c4d51a7
HX		 1677 if (diff >= min_t(unsigned int, x->props.replay_window,
1678 sizeof(x->replay.bitmap) * 8)) {
1da177e4 1679 x->stats.replay_window++;
afeb14b4 1680 goto err;
1da177e4
LT		 1681 }
1682
1683 if (x->replay.bitmap & (1U << diff)) {
1684 x->stats.replay++;
afeb14b4 1685 goto err;
1da177e4
LT		 1686 }
1687 return 0;
afeb14b4
PM		 1688
1689err:
1690 xfrm_audit_state_replay(x, skb, net_seq);
1691 return -EINVAL;
1da177e4 1692}
1da177e4 1693
61f4627b 1694void xfrm_replay_advance(struct xfrm_state *x, __be32 net_seq)
1da177e4
LT		 1695{
1696 u32 diff;
61f4627b 1697 u32 seq = ntohl(net_seq);
1da177e4
LT		 1698
1699 if (seq > x->replay.seq) {
1700 diff = seq - x->replay.seq;
1701 if (diff < x->props.replay_window)
1702 x->replay.bitmap = ((x->replay.bitmap) << diff) | 1;
1703 else
1704 x->replay.bitmap = 1;
1705 x->replay.seq = seq;
1706 } else {
1707 diff = x->replay.seq - seq;
1708 x->replay.bitmap |= (1U << diff);
1709 }
f8cd5488
JHS		 1710
1711 if (xfrm_aevent_is_on())
1712 xfrm_replay_notify(x, XFRM_REPLAY_UPDATE);
1da177e4 1713}
1da177e4 1714
df01812e 1715static LIST_HEAD(xfrm_km_list);
1da177e4
LT		 1716static DEFINE_RWLOCK(xfrm_km_lock);
1717
26b15dad 1718void km_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c)
1da177e4
LT		 1719{
1720 struct xfrm_mgr *km;
1721
26b15dad
JHS		 1722 read_lock(&xfrm_km_lock);
1723 list_for_each_entry(km, &xfrm_km_list, list)
1724 if (km->notify_policy)
1725 km->notify_policy(xp, dir, c);
1726 read_unlock(&xfrm_km_lock);
1727}
1da177e4 1728
26b15dad
JHS		 1729void km_state_notify(struct xfrm_state *x, struct km_event *c)
1730{
1731 struct xfrm_mgr *km;
1da177e4
LT		 1732 read_lock(&xfrm_km_lock);
1733 list_for_each_entry(km, &xfrm_km_list, list)
26b15dad
JHS		 1734 if (km->notify)
1735 km->notify(x, c);
1da177e4 1736 read_unlock(&xfrm_km_lock);
26b15dad
JHS		 1737}
1738
1739EXPORT_SYMBOL(km_policy_notify);
1740EXPORT_SYMBOL(km_state_notify);
1741
53bc6b4d 1742void km_state_expired(struct xfrm_state *x, int hard, u32 pid)
26b15dad 1743{
98806f75 1744 struct net *net = xs_net(x);
26b15dad
JHS		 1745 struct km_event c;
1746
bf08867f 1747 c.data.hard = hard;
53bc6b4d 1748 c.pid = pid;
f60f6b8f 1749 c.event = XFRM_MSG_EXPIRE;
26b15dad 1750 km_state_notify(x, &c);
1da177e4
LT		 1751
1752 if (hard)
98806f75 1753 wake_up(&net->xfrm.km_waitq);
1da177e4
LT		 1754}
1755
53bc6b4d 1756EXPORT_SYMBOL(km_state_expired);
26b15dad
JHS		 1757/*
1758 * We send to all registered managers regardless of failure
1759 * We are happy with one success
1760*/
980ebd25 1761int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol)
1da177e4 1762{
26b15dad 1763 int err = -EINVAL, acqret;
1da177e4
LT		 1764 struct xfrm_mgr *km;
1765
1766 read_lock(&xfrm_km_lock);
1767 list_for_each_entry(km, &xfrm_km_list, list) {
26b15dad
JHS		 1768 acqret = km->acquire(x, t, pol, XFRM_POLICY_OUT);
1769 if (!acqret)
1770 err = acqret;
1da177e4
LT		 1771 }
1772 read_unlock(&xfrm_km_lock);
1773 return err;
1774}
980ebd25 1775EXPORT_SYMBOL(km_query);
1da177e4 1776
5d36b180 1777int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport)
1da177e4
LT		 1778{
1779 int err = -EINVAL;
1780 struct xfrm_mgr *km;
1781
1782 read_lock(&xfrm_km_lock);
1783 list_for_each_entry(km, &xfrm_km_list, list) {
1784 if (km->new_mapping)
1785 err = km->new_mapping(x, ipaddr, sport);
1786 if (!err)
1787 break;
1788 }
1789 read_unlock(&xfrm_km_lock);
1790 return err;
1791}
1792EXPORT_SYMBOL(km_new_mapping);
1793
6c5c8ca7 1794void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 pid)
1da177e4 1795{
98806f75 1796 struct net *net = xp_net(pol);
26b15dad 1797 struct km_event c;
1da177e4 1798
bf08867f 1799 c.data.hard = hard;
6c5c8ca7 1800 c.pid = pid;
f60f6b8f 1801 c.event = XFRM_MSG_POLEXPIRE;
26b15dad 1802 km_policy_notify(pol, dir, &c);
1da177e4
LT		 1803
1804 if (hard)
98806f75 1805 wake_up(&net->xfrm.km_waitq);
1da177e4 1806}
a70fcb0b 1807EXPORT_SYMBOL(km_policy_expired);
1da177e4 1808
2d60abc2 1809#ifdef CONFIG_XFRM_MIGRATE
80c9abaa 1810int km_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
13c1d189
AE		 1811 struct xfrm_migrate *m, int num_migrate,
1812 struct xfrm_kmaddress *k)
80c9abaa
SS		 1813{
1814 int err = -EINVAL;
1815 int ret;
1816 struct xfrm_mgr *km;
1817
1818 read_lock(&xfrm_km_lock);
1819 list_for_each_entry(km, &xfrm_km_list, list) {
1820 if (km->migrate) {
13c1d189 1821 ret = km->migrate(sel, dir, type, m, num_migrate, k);
80c9abaa
SS		 1822 if (!ret)
1823 err = ret;
1824 }
1825 }
1826 read_unlock(&xfrm_km_lock);
1827 return err;
1828}
1829EXPORT_SYMBOL(km_migrate);
2d60abc2 1830#endif
80c9abaa 1831
97a64b45
MN		 1832int km_report(u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr)
1833{
1834 int err = -EINVAL;
1835 int ret;
1836 struct xfrm_mgr *km;
1837
1838 read_lock(&xfrm_km_lock);
1839 list_for_each_entry(km, &xfrm_km_list, list) {
1840 if (km->report) {
1841 ret = km->report(proto, sel, addr);
1842 if (!ret)
1843 err = ret;
1844 }
1845 }
1846 read_unlock(&xfrm_km_lock);
1847 return err;
1848}
1849EXPORT_SYMBOL(km_report);
1850
1da177e4
LT		 1851int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
1852{
1853 int err;
1854 u8 *data;
1855 struct xfrm_mgr *km;
1856 struct xfrm_policy *pol = NULL;
1857
1858 if (optlen <= 0 || optlen > PAGE_SIZE)
1859 return -EMSGSIZE;
1860
1861 data = kmalloc(optlen, GFP_KERNEL);
1862 if (!data)
1863 return -ENOMEM;
1864
1865 err = -EFAULT;
1866 if (copy_from_user(data, optval, optlen))
1867 goto out;
1868
1869 err = -EINVAL;
1870 read_lock(&xfrm_km_lock);
1871 list_for_each_entry(km, &xfrm_km_list, list) {
cb969f07 1872 pol = km->compile_policy(sk, optname, data,
1da177e4
LT		 1873 optlen, &err);
1874 if (err >= 0)
1875 break;
1876 }
1877 read_unlock(&xfrm_km_lock);
1878
1879 if (err >= 0) {
1880 xfrm_sk_policy_insert(sk, err, pol);
1881 xfrm_pol_put(pol);
1882 err = 0;
1883 }
1884
1885out:
1886 kfree(data);
1887 return err;
1888}
1889EXPORT_SYMBOL(xfrm_user_policy);
1890
1891int xfrm_register_km(struct xfrm_mgr *km)
1892{
1893 write_lock_bh(&xfrm_km_lock);
1894 list_add_tail(&km->list, &xfrm_km_list);
1895 write_unlock_bh(&xfrm_km_lock);
1896 return 0;
1897}
1898EXPORT_SYMBOL(xfrm_register_km);
1899
1900int xfrm_unregister_km(struct xfrm_mgr *km)
1901{
1902 write_lock_bh(&xfrm_km_lock);
1903 list_del(&km->list);
1904 write_unlock_bh(&xfrm_km_lock);
1905 return 0;
1906}
1907EXPORT_SYMBOL(xfrm_unregister_km);
1908
1909int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo)
1910{
1911 int err = 0;
1912 if (unlikely(afinfo == NULL))
1913 return -EINVAL;
1914 if (unlikely(afinfo->family >= NPROTO))
1915 return -EAFNOSUPPORT;
f3111502 1916 write_lock_bh(&xfrm_state_afinfo_lock);
1da177e4
LT		 1917 if (unlikely(xfrm_state_afinfo[afinfo->family] != NULL))
1918 err = -ENOBUFS;
edcd5821 1919 else
1da177e4 1920 xfrm_state_afinfo[afinfo->family] = afinfo;
f3111502 1921 write_unlock_bh(&xfrm_state_afinfo_lock);
1da177e4
LT		 1922 return err;
1923}
1924EXPORT_SYMBOL(xfrm_state_register_afinfo);
1925
1926int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo)
1927{
1928 int err = 0;
1929 if (unlikely(afinfo == NULL))
1930 return -EINVAL;
1931 if (unlikely(afinfo->family >= NPROTO))
1932 return -EAFNOSUPPORT;
f3111502 1933 write_lock_bh(&xfrm_state_afinfo_lock);
1da177e4
LT		 1934 if (likely(xfrm_state_afinfo[afinfo->family] != NULL)) {
1935 if (unlikely(xfrm_state_afinfo[afinfo->family] != afinfo))
1936 err = -EINVAL;
edcd5821 1937 else
1da177e4 1938 xfrm_state_afinfo[afinfo->family] = NULL;
1da177e4 1939 }
f3111502 1940 write_unlock_bh(&xfrm_state_afinfo_lock);
1da177e4
LT		 1941 return err;
1942}
1943EXPORT_SYMBOL(xfrm_state_unregister_afinfo);
1944
17c2a42a 1945static struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned int family)
1da177e4
LT		 1946{
1947 struct xfrm_state_afinfo *afinfo;
1948 if (unlikely(family >= NPROTO))
1949 return NULL;
1950 read_lock(&xfrm_state_afinfo_lock);
1951 afinfo = xfrm_state_afinfo[family];
546be240
HX		 1952 if (unlikely(!afinfo))
1953 read_unlock(&xfrm_state_afinfo_lock);
1da177e4
LT		 1954 return afinfo;
1955}
1956
17c2a42a 1957static void xfrm_state_put_afinfo(struct xfrm_state_afinfo *afinfo)
9a429c49 1958 __releases(xfrm_state_afinfo_lock)
1da177e4 1959{
546be240 1960 read_unlock(&xfrm_state_afinfo_lock);
1da177e4
LT		 1961}
1962
1963/* Temporarily located here until net/xfrm/xfrm_tunnel.c is created */
1964void xfrm_state_delete_tunnel(struct xfrm_state *x)
1965{
1966 if (x->tunnel) {
1967 struct xfrm_state *t = x->tunnel;
1968
1969 if (atomic_read(&t->tunnel_users) == 2)
1970 xfrm_state_delete(t);
1971 atomic_dec(&t->tunnel_users);
1972 xfrm_state_put(t);
1973 x->tunnel = NULL;
1974 }
1975}
1976EXPORT_SYMBOL(xfrm_state_delete_tunnel);
1977
1978int xfrm_state_mtu(struct xfrm_state *x, int mtu)
1979{
c5c25238 1980 int res;
1da177e4 1981
c5c25238
PM		 1982 spin_lock_bh(&x->lock);
1983 if (x->km.state == XFRM_STATE_VALID &&
1984 x->type && x->type->get_mtu)
1985 res = x->type->get_mtu(x, mtu);
1986 else
28121617 1987 res = mtu - x->props.header_len;
c5c25238 1988 spin_unlock_bh(&x->lock);
1da177e4
LT		 1989 return res;
1990}
1991
72cb6962
HX		 1992int xfrm_init_state(struct xfrm_state *x)
1993{
d094cd83 1994 struct xfrm_state_afinfo *afinfo;
df9dcb45 1995 struct xfrm_mode *inner_mode;
d094cd83 1996 int family = x->props.family;
72cb6962
HX		 1997 int err;
1998
d094cd83
HX		 1999 err = -EAFNOSUPPORT;
2000 afinfo = xfrm_state_get_afinfo(family);
2001 if (!afinfo)
2002 goto error;
2003
2004 err = 0;
2005 if (afinfo->init_flags)
2006 err = afinfo->init_flags(x);
2007
2008 xfrm_state_put_afinfo(afinfo);
2009
2010 if (err)
2011 goto error;
2012
2013 err = -EPROTONOSUPPORT;
13996378 2014
df9dcb45
KM		 2015 if (x->sel.family != AF_UNSPEC) {
2016 inner_mode = xfrm_get_mode(x->props.mode, x->sel.family);
2017 if (inner_mode == NULL)
2018 goto error;
2019
2020 if (!(inner_mode->flags & XFRM_MODE_FLAG_TUNNEL) &&
2021 family != x->sel.family) {
2022 xfrm_put_mode(inner_mode);
2023 goto error;
2024 }
2025
2026 x->inner_mode = inner_mode;
2027 } else {
2028 struct xfrm_mode *inner_mode_iaf;
2029
2030 inner_mode = xfrm_get_mode(x->props.mode, AF_INET);
2031 if (inner_mode == NULL)
2032 goto error;
2033
2034 if (!(inner_mode->flags & XFRM_MODE_FLAG_TUNNEL)) {
2035 xfrm_put_mode(inner_mode);
2036 goto error;
2037 }
2038
2039 inner_mode_iaf = xfrm_get_mode(x->props.mode, AF_INET6);
2040 if (inner_mode_iaf == NULL)
2041 goto error;
2042
2043 if (!(inner_mode_iaf->flags & XFRM_MODE_FLAG_TUNNEL)) {
2044 xfrm_put_mode(inner_mode_iaf);
2045 goto error;
2046 }
2047
2048 if (x->props.family == AF_INET) {
2049 x->inner_mode = inner_mode;
2050 x->inner_mode_iaf = inner_mode_iaf;
2051 } else {
2052 x->inner_mode = inner_mode_iaf;
2053 x->inner_mode_iaf = inner_mode;
2054 }
2055 }
13996378 2056
d094cd83 2057 x->type = xfrm_get_type(x->id.proto, family);
72cb6962
HX		 2058 if (x->type == NULL)
2059 goto error;
2060
2061 err = x->type->init_state(x);
2062 if (err)
2063 goto error;
2064
13996378
HX		 2065 x->outer_mode = xfrm_get_mode(x->props.mode, family);
2066 if (x->outer_mode == NULL)
b59f45d0
HX		 2067 goto error;
2068
72cb6962
HX		 2069 x->km.state = XFRM_STATE_VALID;
2070
2071error:
2072 return err;
2073}
2074
2075EXPORT_SYMBOL(xfrm_init_state);
a716c119 2076
d62ddc21 2077int __net_init xfrm_state_init(struct net *net)
1da177e4 2078{
f034b5d4
DM		 2079 unsigned int sz;
2080
9d4139c7
AD		 2081 INIT_LIST_HEAD(&net->xfrm.state_all);
2082
f034b5d4
DM		 2083 sz = sizeof(struct hlist_head) * 8;
2084
73d189dc
AD		 2085 net->xfrm.state_bydst = xfrm_hash_alloc(sz);
2086 if (!net->xfrm.state_bydst)
2087 goto out_bydst;
d320bbb3
AD		 2088 net->xfrm.state_bysrc = xfrm_hash_alloc(sz);
2089 if (!net->xfrm.state_bysrc)
2090 goto out_bysrc;
b754a4fd
AD		 2091 net->xfrm.state_byspi = xfrm_hash_alloc(sz);
2092 if (!net->xfrm.state_byspi)
2093 goto out_byspi;
529983ec 2094 net->xfrm.state_hmask = ((sz / sizeof(struct hlist_head)) - 1);
1da177e4 2095
0bf7c5b0 2096 net->xfrm.state_num = 0;
63082733 2097 INIT_WORK(&net->xfrm.state_hash_work, xfrm_hash_resize);
b8a0ae20 2098 INIT_HLIST_HEAD(&net->xfrm.state_gc_list);
c7837144 2099 INIT_WORK(&net->xfrm.state_gc_work, xfrm_state_gc_task);
50a30657 2100 init_waitqueue_head(&net->xfrm.km_waitq);
d62ddc21 2101 return 0;
73d189dc 2102
b754a4fd
AD		 2103out_byspi:
2104 xfrm_hash_free(net->xfrm.state_bysrc, sz);
d320bbb3
AD		 2105out_bysrc:
2106 xfrm_hash_free(net->xfrm.state_bydst, sz);
73d189dc
AD		 2107out_bydst:
2108 return -ENOMEM;
d62ddc21
AD		 2109}
2110
2111void xfrm_state_fini(struct net *net)
2112{
73d189dc
AD		 2113 unsigned int sz;
2114
9d4139c7 2115 WARN_ON(!list_empty(&net->xfrm.state_all));
73d189dc 2116
529983ec 2117 sz = (net->xfrm.state_hmask + 1) * sizeof(struct hlist_head);
b754a4fd
AD		 2118 WARN_ON(!hlist_empty(net->xfrm.state_byspi));
2119 xfrm_hash_free(net->xfrm.state_byspi, sz);
d320bbb3
AD		 2120 WARN_ON(!hlist_empty(net->xfrm.state_bysrc));
2121 xfrm_hash_free(net->xfrm.state_bysrc, sz);
73d189dc
AD		 2122 WARN_ON(!hlist_empty(net->xfrm.state_bydst));
2123 xfrm_hash_free(net->xfrm.state_bydst, sz);
1da177e4
LT		 2124}
2125
ab5f5e8b 2126#ifdef CONFIG_AUDITSYSCALL
cf35f43e
IJ		 2127static void xfrm_audit_helper_sainfo(struct xfrm_state *x,
2128 struct audit_buffer *audit_buf)
ab5f5e8b 2129{
68277acc
PM		 2130 struct xfrm_sec_ctx *ctx = x->security;
2131 u32 spi = ntohl(x->id.spi);
2132
2133 if (ctx)
ab5f5e8b 2134 audit_log_format(audit_buf, " sec_alg=%u sec_doi=%u sec_obj=%s",
68277acc 2135 ctx->ctx_alg, ctx->ctx_doi, ctx->ctx_str);
ab5f5e8b
JL		 2136
2137 switch(x->props.family) {
2138 case AF_INET:
21454aaa
HH		 2139 audit_log_format(audit_buf, " src=%pI4 dst=%pI4",
2140 &x->props.saddr.a4, &x->id.daddr.a4);
ab5f5e8b
JL		 2141 break;
2142 case AF_INET6:
5b095d98 2143 audit_log_format(audit_buf, " src=%pI6 dst=%pI6",
fdb46ee7 2144 x->props.saddr.a6, x->id.daddr.a6);
ab5f5e8b
JL		 2145 break;
2146 }
68277acc
PM		 2147
2148 audit_log_format(audit_buf, " spi=%u(0x%x)", spi, spi);
ab5f5e8b
JL		 2149}
2150
cf35f43e
IJ		 2151static void xfrm_audit_helper_pktinfo(struct sk_buff *skb, u16 family,
2152 struct audit_buffer *audit_buf)
afeb14b4
PM		 2153{
2154 struct iphdr *iph4;
2155 struct ipv6hdr *iph6;
2156
2157 switch (family) {
2158 case AF_INET:
2159 iph4 = ip_hdr(skb);
21454aaa
HH		 2160 audit_log_format(audit_buf, " src=%pI4 dst=%pI4",
2161 &iph4->saddr, &iph4->daddr);
afeb14b4
PM		 2162 break;
2163 case AF_INET6:
2164 iph6 = ipv6_hdr(skb);
2165 audit_log_format(audit_buf,
5b095d98 2166 " src=%pI6 dst=%pI6 flowlbl=0x%x%02x%02x",
fdb46ee7 2167 &iph6->saddr,&iph6->daddr,
afeb14b4
PM		 2168 iph6->flow_lbl[0] & 0x0f,
2169 iph6->flow_lbl[1],
2170 iph6->flow_lbl[2]);
2171 break;
2172 }
2173}
2174
68277acc 2175void xfrm_audit_state_add(struct xfrm_state *x, int result,
2532386f 2176 uid_t auid, u32 sessionid, u32 secid)
ab5f5e8b
JL		 2177{
2178 struct audit_buffer *audit_buf;
ab5f5e8b 2179
afeb14b4 2180 audit_buf = xfrm_audit_start("SAD-add");
ab5f5e8b
JL		 2181 if (audit_buf == NULL)
2182 return;
2532386f 2183 xfrm_audit_helper_usrinfo(auid, sessionid, secid, audit_buf);
afeb14b4
PM		 2184 xfrm_audit_helper_sainfo(x, audit_buf);
2185 audit_log_format(audit_buf, " res=%u", result);
ab5f5e8b
JL		 2186 audit_log_end(audit_buf);
2187}
2188EXPORT_SYMBOL_GPL(xfrm_audit_state_add);
2189
68277acc 2190void xfrm_audit_state_delete(struct xfrm_state *x, int result,
2532386f 2191 uid_t auid, u32 sessionid, u32 secid)
ab5f5e8b
JL		 2192{
2193 struct audit_buffer *audit_buf;
ab5f5e8b 2194
afeb14b4 2195 audit_buf = xfrm_audit_start("SAD-delete");
ab5f5e8b
JL		 2196 if (audit_buf == NULL)
2197 return;
2532386f 2198 xfrm_audit_helper_usrinfo(auid, sessionid, secid, audit_buf);
afeb14b4
PM		 2199 xfrm_audit_helper_sainfo(x, audit_buf);
2200 audit_log_format(audit_buf, " res=%u", result);
ab5f5e8b
JL		 2201 audit_log_end(audit_buf);
2202}
2203EXPORT_SYMBOL_GPL(xfrm_audit_state_delete);
afeb14b4
PM		 2204
2205void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
2206 struct sk_buff *skb)
2207{
2208 struct audit_buffer *audit_buf;
2209 u32 spi;
2210
2211 audit_buf = xfrm_audit_start("SA-replay-overflow");
2212 if (audit_buf == NULL)
2213 return;
2214 xfrm_audit_helper_pktinfo(skb, x->props.family, audit_buf);
2215 /* don't record the sequence number because it's inherent in this kind
2216 * of audit message */
2217 spi = ntohl(x->id.spi);
2218 audit_log_format(audit_buf, " spi=%u(0x%x)", spi, spi);
2219 audit_log_end(audit_buf);
2220}
2221EXPORT_SYMBOL_GPL(xfrm_audit_state_replay_overflow);
2222
2223static void xfrm_audit_state_replay(struct xfrm_state *x,
2224 struct sk_buff *skb, __be32 net_seq)
2225{
2226 struct audit_buffer *audit_buf;
2227 u32 spi;
2228
2229 audit_buf = xfrm_audit_start("SA-replayed-pkt");
2230 if (audit_buf == NULL)
2231 return;
2232 xfrm_audit_helper_pktinfo(skb, x->props.family, audit_buf);
2233 spi = ntohl(x->id.spi);
2234 audit_log_format(audit_buf, " spi=%u(0x%x) seqno=%u",
2235 spi, spi, ntohl(net_seq));
2236 audit_log_end(audit_buf);
2237}
2238
2239void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family)
2240{
2241 struct audit_buffer *audit_buf;
2242
2243 audit_buf = xfrm_audit_start("SA-notfound");
2244 if (audit_buf == NULL)
2245 return;
2246 xfrm_audit_helper_pktinfo(skb, family, audit_buf);
2247 audit_log_end(audit_buf);
2248}
2249EXPORT_SYMBOL_GPL(xfrm_audit_state_notfound_simple);
2250
2251void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
2252 __be32 net_spi, __be32 net_seq)
2253{
2254 struct audit_buffer *audit_buf;
2255 u32 spi;
2256
2257 audit_buf = xfrm_audit_start("SA-notfound");
2258 if (audit_buf == NULL)
2259 return;
2260 xfrm_audit_helper_pktinfo(skb, family, audit_buf);
2261 spi = ntohl(net_spi);
2262 audit_log_format(audit_buf, " spi=%u(0x%x) seqno=%u",
2263 spi, spi, ntohl(net_seq));
2264 audit_log_end(audit_buf);
2265}
2266EXPORT_SYMBOL_GPL(xfrm_audit_state_notfound);
2267
2268void xfrm_audit_state_icvfail(struct xfrm_state *x,
2269 struct sk_buff *skb, u8 proto)
2270{
2271 struct audit_buffer *audit_buf;
2272 __be32 net_spi;
2273 __be32 net_seq;
2274
2275 audit_buf = xfrm_audit_start("SA-icv-failure");
2276 if (audit_buf == NULL)
2277 return;
2278 xfrm_audit_helper_pktinfo(skb, x->props.family, audit_buf);
2279 if (xfrm_parse_spi(skb, proto, &net_spi, &net_seq) == 0) {
2280 u32 spi = ntohl(net_spi);
2281 audit_log_format(audit_buf, " spi=%u(0x%x) seqno=%u",
2282 spi, spi, ntohl(net_seq));
2283 }
2284 audit_log_end(audit_buf);
2285}
2286EXPORT_SYMBOL_GPL(xfrm_audit_state_icvfail);
ab5f5e8b 2287#endif /* CONFIG_AUDITSYSCALL */
Ubuntu Artful kernel mirror