?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[XFRM] MIP6: Fix address keys for routing search.
[linux-2.6/mini2440.git] / net / xfrm / xfrm_policy.c
blob8e588f20c60c5988238043afcc446a1888cc0772
1 /*
2 * xfrm_policy.c
3 *
4 * Changes:
5 * Mitsuru KANDA @USAGI
6 * Kazunori MIYAZAWA @USAGI
7 * Kunihiro Ishiguro <kunihiro@ipinfusion.com>
8 * IPv6 support
9 * Kazunori MIYAZAWA @USAGI
10 * YOSHIFUJI Hideaki
11 * Split up af-specific portion
12 * Derek Atkins <derek@ihtfp.com> Add the post_input processor
13 *
14 */
15
16 #include <linux/err.h>
17 #include <linux/slab.h>
18 #include <linux/kmod.h>
19 #include <linux/list.h>
20 #include <linux/spinlock.h>
21 #include <linux/workqueue.h>
22 #include <linux/notifier.h>
23 #include <linux/netdevice.h>
24 #include <linux/netfilter.h>
25 #include <linux/module.h>
26 #include <linux/cache.h>
27 #include <linux/audit.h>
28 #include <net/dst.h>
29 #include <net/xfrm.h>
30 #include <net/ip.h>
31 #ifdef CONFIG_XFRM_STATISTICS
32 #include <net/snmp.h>
33 #endif
34
35 #include "xfrm_hash.h"
36
37 int sysctl_xfrm_larval_drop __read_mostly;
38
39 #ifdef CONFIG_XFRM_STATISTICS
40 DEFINE_SNMP_STAT(struct linux_xfrm_mib, xfrm_statistics) __read_mostly;
41 EXPORT_SYMBOL(xfrm_statistics);
42 #endif
43
44 DEFINE_MUTEX(xfrm_cfg_mutex);
45 EXPORT_SYMBOL(xfrm_cfg_mutex);
46
47 static DEFINE_RWLOCK(xfrm_policy_lock);
48
49 static struct list_head xfrm_policy_bytype[XFRM_POLICY_TYPE_MAX];
50 unsigned int xfrm_policy_count[XFRM_POLICY_MAX*2];
51 EXPORT_SYMBOL(xfrm_policy_count);
52
53 static DEFINE_RWLOCK(xfrm_policy_afinfo_lock);
54 static struct xfrm_policy_afinfo *xfrm_policy_afinfo[NPROTO];
55
56 static struct kmem_cache *xfrm_dst_cache __read_mostly;
57
58 static struct work_struct xfrm_policy_gc_work;
59 static HLIST_HEAD(xfrm_policy_gc_list);
60 static DEFINE_SPINLOCK(xfrm_policy_gc_lock);
61
62 static struct xfrm_policy_afinfo *xfrm_policy_get_afinfo(unsigned short family);
63 static void xfrm_policy_put_afinfo(struct xfrm_policy_afinfo *afinfo);
64 static void xfrm_init_pmtu(struct dst_entry *dst);
65
66 static inline int
67 __xfrm4_selector_match(struct xfrm_selector *sel, struct flowi *fl)
68 {
69 return addr_match(&fl->fl4_dst, &sel->daddr, sel->prefixlen_d) &&
70 addr_match(&fl->fl4_src, &sel->saddr, sel->prefixlen_s) &&
71 !((xfrm_flowi_dport(fl) ^ sel->dport) & sel->dport_mask) &&
72 !((xfrm_flowi_sport(fl) ^ sel->sport) & sel->sport_mask) &&
73 (fl->proto == sel->proto || !sel->proto) &&
74 (fl->oif == sel->ifindex || !sel->ifindex);
75 }
76
77 static inline int
78 __xfrm6_selector_match(struct xfrm_selector *sel, struct flowi *fl)
79 {
80 return addr_match(&fl->fl6_dst, &sel->daddr, sel->prefixlen_d) &&
81 addr_match(&fl->fl6_src, &sel->saddr, sel->prefixlen_s) &&
82 !((xfrm_flowi_dport(fl) ^ sel->dport) & sel->dport_mask) &&
83 !((xfrm_flowi_sport(fl) ^ sel->sport) & sel->sport_mask) &&
84 (fl->proto == sel->proto || !sel->proto) &&
85 (fl->oif == sel->ifindex || !sel->ifindex);
86 }
87
88 int xfrm_selector_match(struct xfrm_selector *sel, struct flowi *fl,
89 unsigned short family)
90 {
91 switch (family) {
92 case AF_INET:
93 return __xfrm4_selector_match(sel, fl);
94 case AF_INET6:
95 return __xfrm6_selector_match(sel, fl);
96 }
97 return 0;
98 }
99
100 static inline struct dst_entry *__xfrm_dst_lookup(int tos,
101 xfrm_address_t *saddr,
102 xfrm_address_t *daddr,
103 int family)
104 {
105 struct xfrm_policy_afinfo *afinfo;
106 struct dst_entry *dst;
107
108 afinfo = xfrm_policy_get_afinfo(family);
109 if (unlikely(afinfo == NULL))
110 return ERR_PTR(-EAFNOSUPPORT);
111
112 dst = afinfo->dst_lookup(tos, saddr, daddr);
113
114 xfrm_policy_put_afinfo(afinfo);
115
116 return dst;
117 }
118
119 static inline struct dst_entry *xfrm_dst_lookup(struct xfrm_state *x, int tos,
120 xfrm_address_t *prev_saddr,
121 xfrm_address_t *prev_daddr,
122 int family)
123 {
124 xfrm_address_t *saddr = &x->props.saddr;
125 xfrm_address_t *daddr = &x->id.daddr;
126 struct dst_entry *dst;
127
128 if (x->type->flags & XFRM_TYPE_LOCAL_COADDR) {
129 saddr = x->coaddr;
130 daddr = prev_daddr;
131 }
132 if (x->type->flags & XFRM_TYPE_REMOTE_COADDR) {
133 saddr = prev_saddr;
134 daddr = x->coaddr;
135 }
136
137 dst = __xfrm_dst_lookup(tos, saddr, daddr, family);
138
139 if (!IS_ERR(dst)) {
140 if (prev_saddr != saddr)
141 memcpy(prev_saddr, saddr, sizeof(*prev_saddr));
142 if (prev_daddr != daddr)
143 memcpy(prev_daddr, daddr, sizeof(*prev_daddr));
144 }
145
146 return dst;
147 }
148
149 static inline unsigned long make_jiffies(long secs)
150 {
151 if (secs >= (MAX_SCHEDULE_TIMEOUT-1)/HZ)
152 return MAX_SCHEDULE_TIMEOUT-1;
153 else
154 return secs*HZ;
155 }
156
157 static void xfrm_policy_timer(unsigned long data)
158 {
159 struct xfrm_policy *xp = (struct xfrm_policy*)data;
160 unsigned long now = get_seconds();
161 long next = LONG_MAX;
162 int warn = 0;
163 int dir;
164
165 read_lock(&xp->lock);
166
167 if (xp->dead)
168 goto out;
169
170 dir = xfrm_policy_id2dir(xp->index);
171
172 if (xp->lft.hard_add_expires_seconds) {
173 long tmo = xp->lft.hard_add_expires_seconds +
174 xp->curlft.add_time - now;
175 if (tmo <= 0)
176 goto expired;
177 if (tmo < next)
178 next = tmo;
179 }
180 if (xp->lft.hard_use_expires_seconds) {
181 long tmo = xp->lft.hard_use_expires_seconds +
182 (xp->curlft.use_time ? : xp->curlft.add_time) - now;
183 if (tmo <= 0)
184 goto expired;
185 if (tmo < next)
186 next = tmo;
187 }
188 if (xp->lft.soft_add_expires_seconds) {
189 long tmo = xp->lft.soft_add_expires_seconds +
190 xp->curlft.add_time - now;
191 if (tmo <= 0) {
192 warn = 1;
193 tmo = XFRM_KM_TIMEOUT;
194 }
195 if (tmo < next)
196 next = tmo;
197 }
198 if (xp->lft.soft_use_expires_seconds) {
199 long tmo = xp->lft.soft_use_expires_seconds +
200 (xp->curlft.use_time ? : xp->curlft.add_time) - now;
201 if (tmo <= 0) {
202 warn = 1;
203 tmo = XFRM_KM_TIMEOUT;
204 }
205 if (tmo < next)
206 next = tmo;
207 }
208
209 if (warn)
210 km_policy_expired(xp, dir, 0, 0);
211 if (next != LONG_MAX &&
212 !mod_timer(&xp->timer, jiffies + make_jiffies(next)))
213 xfrm_pol_hold(xp);
214
215 out:
216 read_unlock(&xp->lock);
217 xfrm_pol_put(xp);
218 return;
219
220 expired:
221 read_unlock(&xp->lock);
222 if (!xfrm_policy_delete(xp, dir))
223 km_policy_expired(xp, dir, 1, 0);
224 xfrm_pol_put(xp);
225 }
226
227
228 /* Allocate xfrm_policy. Not used here, it is supposed to be used by pfkeyv2
229 * SPD calls.
230 */
231
232 struct xfrm_policy *xfrm_policy_alloc(gfp_t gfp)
233 {
234 struct xfrm_policy *policy;
235
236 policy = kzalloc(sizeof(struct xfrm_policy), gfp);
237
238 if (policy) {
239 INIT_LIST_HEAD(&policy->bytype);
240 INIT_HLIST_NODE(&policy->bydst);
241 INIT_HLIST_NODE(&policy->byidx);
242 rwlock_init(&policy->lock);
243 atomic_set(&policy->refcnt, 1);
244 setup_timer(&policy->timer, xfrm_policy_timer,
245 (unsigned long)policy);
246 }
247 return policy;
248 }
249 EXPORT_SYMBOL(xfrm_policy_alloc);
250
251 /* Destroy xfrm_policy: descendant resources must be released to this moment. */
252
253 void xfrm_policy_destroy(struct xfrm_policy *policy)
254 {
255 BUG_ON(!policy->dead);
256
257 BUG_ON(policy->bundles);
258
259 if (del_timer(&policy->timer))
260 BUG();
261
262 write_lock_bh(&xfrm_policy_lock);
263 list_del(&policy->bytype);
264 write_unlock_bh(&xfrm_policy_lock);
265
266 security_xfrm_policy_free(policy);
267 kfree(policy);
268 }
269 EXPORT_SYMBOL(xfrm_policy_destroy);
270
271 static void xfrm_policy_gc_kill(struct xfrm_policy *policy)
272 {
273 struct dst_entry *dst;
274
275 while ((dst = policy->bundles) != NULL) {
276 policy->bundles = dst->next;
277 dst_free(dst);
278 }
279
280 if (del_timer(&policy->timer))
281 atomic_dec(&policy->refcnt);
282
283 if (atomic_read(&policy->refcnt) > 1)
284 flow_cache_flush();
285
286 xfrm_pol_put(policy);
287 }
288
289 static void xfrm_policy_gc_task(struct work_struct *work)
290 {
291 struct xfrm_policy *policy;
292 struct hlist_node *entry, *tmp;
293 struct hlist_head gc_list;
294
295 spin_lock_bh(&xfrm_policy_gc_lock);
296 gc_list.first = xfrm_policy_gc_list.first;
297 INIT_HLIST_HEAD(&xfrm_policy_gc_list);
298 spin_unlock_bh(&xfrm_policy_gc_lock);
299
300 hlist_for_each_entry_safe(policy, entry, tmp, &gc_list, bydst)
301 xfrm_policy_gc_kill(policy);
302 }
303
304 /* Rule must be locked. Release descentant resources, announce
305 * entry dead. The rule must be unlinked from lists to the moment.
306 */
307
308 static void xfrm_policy_kill(struct xfrm_policy *policy)
309 {
310 int dead;
311
312 write_lock_bh(&policy->lock);
313 dead = policy->dead;
314 policy->dead = 1;
315 write_unlock_bh(&policy->lock);
316
317 if (unlikely(dead)) {
318 WARN_ON(1);
319 return;
320 }
321
322 spin_lock(&xfrm_policy_gc_lock);
323 hlist_add_head(&policy->bydst, &xfrm_policy_gc_list);
324 spin_unlock(&xfrm_policy_gc_lock);
325
326 schedule_work(&xfrm_policy_gc_work);
327 }
328
329 struct xfrm_policy_hash {
330 struct hlist_head *table;
331 unsigned int hmask;
332 };
333
334 static struct hlist_head xfrm_policy_inexact[XFRM_POLICY_MAX*2];
335 static struct xfrm_policy_hash xfrm_policy_bydst[XFRM_POLICY_MAX*2] __read_mostly;
336 static struct hlist_head *xfrm_policy_byidx __read_mostly;
337 static unsigned int xfrm_idx_hmask __read_mostly;
338 static unsigned int xfrm_policy_hashmax __read_mostly = 1 * 1024 * 1024;
339
340 static inline unsigned int idx_hash(u32 index)
341 {
342 return __idx_hash(index, xfrm_idx_hmask);
343 }
344
345 static struct hlist_head *policy_hash_bysel(struct xfrm_selector *sel, unsigned short family, int dir)
346 {
347 unsigned int hmask = xfrm_policy_bydst[dir].hmask;
348 unsigned int hash = __sel_hash(sel, family, hmask);
349
350 return (hash == hmask + 1 ?
351 &xfrm_policy_inexact[dir] :
352 xfrm_policy_bydst[dir].table + hash);
353 }
354
355 static struct hlist_head *policy_hash_direct(xfrm_address_t *daddr, xfrm_address_t *saddr, unsigned short family, int dir)
356 {
357 unsigned int hmask = xfrm_policy_bydst[dir].hmask;
358 unsigned int hash = __addr_hash(daddr, saddr, family, hmask);
359
360 return xfrm_policy_bydst[dir].table + hash;
361 }
362
363 static void xfrm_dst_hash_transfer(struct hlist_head *list,
364 struct hlist_head *ndsttable,
365 unsigned int nhashmask)
366 {
367 struct hlist_node *entry, *tmp, *entry0 = NULL;
368 struct xfrm_policy *pol;
369 unsigned int h0 = 0;
370
371 redo:
372 hlist_for_each_entry_safe(pol, entry, tmp, list, bydst) {
373 unsigned int h;
374
375 h = __addr_hash(&pol->selector.daddr, &pol->selector.saddr,
376 pol->family, nhashmask);
377 if (!entry0) {
378 hlist_del(entry);
379 hlist_add_head(&pol->bydst, ndsttable+h);
380 h0 = h;
381 } else {
382 if (h != h0)
383 continue;
384 hlist_del(entry);
385 hlist_add_after(entry0, &pol->bydst);
386 }
387 entry0 = entry;
388 }
389 if (!hlist_empty(list)) {
390 entry0 = NULL;
391 goto redo;
392 }
393 }
394
395 static void xfrm_idx_hash_transfer(struct hlist_head *list,
396 struct hlist_head *nidxtable,
397 unsigned int nhashmask)
398 {
399 struct hlist_node *entry, *tmp;
400 struct xfrm_policy *pol;
401
402 hlist_for_each_entry_safe(pol, entry, tmp, list, byidx) {
403 unsigned int h;
404
405 h = __idx_hash(pol->index, nhashmask);
406 hlist_add_head(&pol->byidx, nidxtable+h);
407 }
408 }
409
410 static unsigned long xfrm_new_hash_mask(unsigned int old_hmask)
411 {
412 return ((old_hmask + 1) << 1) - 1;
413 }
414
415 static void xfrm_bydst_resize(int dir)
416 {
417 unsigned int hmask = xfrm_policy_bydst[dir].hmask;
418 unsigned int nhashmask = xfrm_new_hash_mask(hmask);
419 unsigned int nsize = (nhashmask + 1) * sizeof(struct hlist_head);
420 struct hlist_head *odst = xfrm_policy_bydst[dir].table;
421 struct hlist_head *ndst = xfrm_hash_alloc(nsize);
422 int i;
423
424 if (!ndst)
425 return;
426
427 write_lock_bh(&xfrm_policy_lock);
428
429 for (i = hmask; i >= 0; i--)
430 xfrm_dst_hash_transfer(odst + i, ndst, nhashmask);
431
432 xfrm_policy_bydst[dir].table = ndst;
433 xfrm_policy_bydst[dir].hmask = nhashmask;
434
435 write_unlock_bh(&xfrm_policy_lock);
436
437 xfrm_hash_free(odst, (hmask + 1) * sizeof(struct hlist_head));
438 }
439
440 static void xfrm_byidx_resize(int total)
441 {
442 unsigned int hmask = xfrm_idx_hmask;
443 unsigned int nhashmask = xfrm_new_hash_mask(hmask);
444 unsigned int nsize = (nhashmask + 1) * sizeof(struct hlist_head);
445 struct hlist_head *oidx = xfrm_policy_byidx;
446 struct hlist_head *nidx = xfrm_hash_alloc(nsize);
447 int i;
448
449 if (!nidx)
450 return;
451
452 write_lock_bh(&xfrm_policy_lock);
453
454 for (i = hmask; i >= 0; i--)
455 xfrm_idx_hash_transfer(oidx + i, nidx, nhashmask);
456
457 xfrm_policy_byidx = nidx;
458 xfrm_idx_hmask = nhashmask;
459
460 write_unlock_bh(&xfrm_policy_lock);
461
462 xfrm_hash_free(oidx, (hmask + 1) * sizeof(struct hlist_head));
463 }
464
465 static inline int xfrm_bydst_should_resize(int dir, int *total)
466 {
467 unsigned int cnt = xfrm_policy_count[dir];
468 unsigned int hmask = xfrm_policy_bydst[dir].hmask;
469
470 if (total)
471 *total += cnt;
472
473 if ((hmask + 1) < xfrm_policy_hashmax &&
474 cnt > hmask)
475 return 1;
476
477 return 0;
478 }
479
480 static inline int xfrm_byidx_should_resize(int total)
481 {
482 unsigned int hmask = xfrm_idx_hmask;
483
484 if ((hmask + 1) < xfrm_policy_hashmax &&
485 total > hmask)
486 return 1;
487
488 return 0;
489 }
490
491 void xfrm_spd_getinfo(struct xfrmk_spdinfo *si)
492 {
493 read_lock_bh(&xfrm_policy_lock);
494 si->incnt = xfrm_policy_count[XFRM_POLICY_IN];
495 si->outcnt = xfrm_policy_count[XFRM_POLICY_OUT];
496 si->fwdcnt = xfrm_policy_count[XFRM_POLICY_FWD];
497 si->inscnt = xfrm_policy_count[XFRM_POLICY_IN+XFRM_POLICY_MAX];
498 si->outscnt = xfrm_policy_count[XFRM_POLICY_OUT+XFRM_POLICY_MAX];
499 si->fwdscnt = xfrm_policy_count[XFRM_POLICY_FWD+XFRM_POLICY_MAX];
500 si->spdhcnt = xfrm_idx_hmask;
501 si->spdhmcnt = xfrm_policy_hashmax;
502 read_unlock_bh(&xfrm_policy_lock);
503 }
504 EXPORT_SYMBOL(xfrm_spd_getinfo);
505
506 static DEFINE_MUTEX(hash_resize_mutex);
507 static void xfrm_hash_resize(struct work_struct *__unused)
508 {
509 int dir, total;
510
511 mutex_lock(&hash_resize_mutex);
512
513 total = 0;
514 for (dir = 0; dir < XFRM_POLICY_MAX * 2; dir++) {
515 if (xfrm_bydst_should_resize(dir, &total))
516 xfrm_bydst_resize(dir);
517 }
518 if (xfrm_byidx_should_resize(total))
519 xfrm_byidx_resize(total);
520
521 mutex_unlock(&hash_resize_mutex);
522 }
523
524 static DECLARE_WORK(xfrm_hash_work, xfrm_hash_resize);
525
526 /* Generate new index... KAME seems to generate them ordered by cost
527 * of an absolute inpredictability of ordering of rules. This will not pass. */
528 static u32 xfrm_gen_index(u8 type, int dir)
529 {
530 static u32 idx_generator;
531
532 for (;;) {
533 struct hlist_node *entry;
534 struct hlist_head *list;
535 struct xfrm_policy *p;
536 u32 idx;
537 int found;
538
539 idx = (idx_generator | dir);
540 idx_generator += 8;
541 if (idx == 0)
542 idx = 8;
543 list = xfrm_policy_byidx + idx_hash(idx);
544 found = 0;
545 hlist_for_each_entry(p, entry, list, byidx) {
546 if (p->index == idx) {
547 found = 1;
548 break;
549 }
550 }
551 if (!found)
552 return idx;
553 }
554 }
555
556 static inline int selector_cmp(struct xfrm_selector *s1, struct xfrm_selector *s2)
557 {
558 u32 *p1 = (u32 *) s1;
559 u32 *p2 = (u32 *) s2;
560 int len = sizeof(struct xfrm_selector) / sizeof(u32);
561 int i;
562
563 for (i = 0; i < len; i++) {
564 if (p1[i] != p2[i])
565 return 1;
566 }
567
568 return 0;
569 }
570
571 int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl)
572 {
573 struct xfrm_policy *pol;
574 struct xfrm_policy *delpol;
575 struct hlist_head *chain;
576 struct hlist_node *entry, *newpos;
577 struct dst_entry *gc_list;
578
579 write_lock_bh(&xfrm_policy_lock);
580 chain = policy_hash_bysel(&policy->selector, policy->family, dir);
581 delpol = NULL;
582 newpos = NULL;
583 hlist_for_each_entry(pol, entry, chain, bydst) {
584 if (pol->type == policy->type &&
585 !selector_cmp(&pol->selector, &policy->selector) &&
586 xfrm_sec_ctx_match(pol->security, policy->security) &&
587 !WARN_ON(delpol)) {
588 if (excl) {
589 write_unlock_bh(&xfrm_policy_lock);
590 return -EEXIST;
591 }
592 delpol = pol;
593 if (policy->priority > pol->priority)
594 continue;
595 } else if (policy->priority >= pol->priority) {
596 newpos = &pol->bydst;
597 continue;
598 }
599 if (delpol)
600 break;
601 }
602 if (newpos)
603 hlist_add_after(newpos, &policy->bydst);
604 else
605 hlist_add_head(&policy->bydst, chain);
606 xfrm_pol_hold(policy);
607 xfrm_policy_count[dir]++;
608 atomic_inc(&flow_cache_genid);
609 if (delpol) {
610 hlist_del(&delpol->bydst);
611 hlist_del(&delpol->byidx);
612 xfrm_policy_count[dir]--;
613 }
614 policy->index = delpol ? delpol->index : xfrm_gen_index(policy->type, dir);
615 hlist_add_head(&policy->byidx, xfrm_policy_byidx+idx_hash(policy->index));
616 policy->curlft.add_time = get_seconds();
617 policy->curlft.use_time = 0;
618 if (!mod_timer(&policy->timer, jiffies + HZ))
619 xfrm_pol_hold(policy);
620 list_add_tail(&policy->bytype, &xfrm_policy_bytype[policy->type]);
621 write_unlock_bh(&xfrm_policy_lock);
622
623 if (delpol)
624 xfrm_policy_kill(delpol);
625 else if (xfrm_bydst_should_resize(dir, NULL))
626 schedule_work(&xfrm_hash_work);
627
628 read_lock_bh(&xfrm_policy_lock);
629 gc_list = NULL;
630 entry = &policy->bydst;
631 hlist_for_each_entry_continue(policy, entry, bydst) {
632 struct dst_entry *dst;
633
634 write_lock(&policy->lock);
635 dst = policy->bundles;
636 if (dst) {
637 struct dst_entry *tail = dst;
638 while (tail->next)
639 tail = tail->next;
640 tail->next = gc_list;
641 gc_list = dst;
642
643 policy->bundles = NULL;
644 }
645 write_unlock(&policy->lock);
646 }
647 read_unlock_bh(&xfrm_policy_lock);
648
649 while (gc_list) {
650 struct dst_entry *dst = gc_list;
651
652 gc_list = dst->next;
653 dst_free(dst);
654 }
655
656 return 0;
657 }
658 EXPORT_SYMBOL(xfrm_policy_insert);
659
660 struct xfrm_policy *xfrm_policy_bysel_ctx(u8 type, int dir,
661 struct xfrm_selector *sel,
662 struct xfrm_sec_ctx *ctx, int delete,
663 int *err)
664 {
665 struct xfrm_policy *pol, *ret;
666 struct hlist_head *chain;
667 struct hlist_node *entry;
668
669 *err = 0;
670 write_lock_bh(&xfrm_policy_lock);
671 chain = policy_hash_bysel(sel, sel->family, dir);
672 ret = NULL;
673 hlist_for_each_entry(pol, entry, chain, bydst) {
674 if (pol->type == type &&
675 !selector_cmp(sel, &pol->selector) &&
676 xfrm_sec_ctx_match(ctx, pol->security)) {
677 xfrm_pol_hold(pol);
678 if (delete) {
679 *err = security_xfrm_policy_delete(pol);
680 if (*err) {
681 write_unlock_bh(&xfrm_policy_lock);
682 return pol;
683 }
684 hlist_del(&pol->bydst);
685 hlist_del(&pol->byidx);
686 xfrm_policy_count[dir]--;
687 }
688 ret = pol;
689 break;
690 }
691 }
692 write_unlock_bh(&xfrm_policy_lock);
693
694 if (ret && delete) {
695 atomic_inc(&flow_cache_genid);
696 xfrm_policy_kill(ret);
697 }
698 return ret;
699 }
700 EXPORT_SYMBOL(xfrm_policy_bysel_ctx);
701
702 struct xfrm_policy *xfrm_policy_byid(u8 type, int dir, u32 id, int delete,
703 int *err)
704 {
705 struct xfrm_policy *pol, *ret;
706 struct hlist_head *chain;
707 struct hlist_node *entry;
708
709 *err = -ENOENT;
710 if (xfrm_policy_id2dir(id) != dir)
711 return NULL;
712
713 *err = 0;
714 write_lock_bh(&xfrm_policy_lock);
715 chain = xfrm_policy_byidx + idx_hash(id);
716 ret = NULL;
717 hlist_for_each_entry(pol, entry, chain, byidx) {
718 if (pol->type == type && pol->index == id) {
719 xfrm_pol_hold(pol);
720 if (delete) {
721 *err = security_xfrm_policy_delete(pol);
722 if (*err) {
723 write_unlock_bh(&xfrm_policy_lock);
724 return pol;
725 }
726 hlist_del(&pol->bydst);
727 hlist_del(&pol->byidx);
728 xfrm_policy_count[dir]--;
729 }
730 ret = pol;
731 break;
732 }
733 }
734 write_unlock_bh(&xfrm_policy_lock);
735
736 if (ret && delete) {
737 atomic_inc(&flow_cache_genid);
738 xfrm_policy_kill(ret);
739 }
740 return ret;
741 }
742 EXPORT_SYMBOL(xfrm_policy_byid);
743
744 #ifdef CONFIG_SECURITY_NETWORK_XFRM
745 static inline int
746 xfrm_policy_flush_secctx_check(u8 type, struct xfrm_audit *audit_info)
747 {
748 int dir, err = 0;
749
750 for (dir = 0; dir < XFRM_POLICY_MAX; dir++) {
751 struct xfrm_policy *pol;
752 struct hlist_node *entry;
753 int i;
754
755 hlist_for_each_entry(pol, entry,
756 &xfrm_policy_inexact[dir], bydst) {
757 if (pol->type != type)
758 continue;
759 err = security_xfrm_policy_delete(pol);
760 if (err) {
761 xfrm_audit_policy_delete(pol, 0,
762 audit_info->loginuid,
763 audit_info->secid);
764 return err;
765 }
766 }
767 for (i = xfrm_policy_bydst[dir].hmask; i >= 0; i--) {
768 hlist_for_each_entry(pol, entry,
769 xfrm_policy_bydst[dir].table + i,
770 bydst) {
771 if (pol->type != type)
772 continue;
773 err = security_xfrm_policy_delete(pol);
774 if (err) {
775 xfrm_audit_policy_delete(pol, 0,
776 audit_info->loginuid,
777 audit_info->secid);
778 return err;
779 }
780 }
781 }
782 }
783 return err;
784 }
785 #else
786 static inline int
787 xfrm_policy_flush_secctx_check(u8 type, struct xfrm_audit *audit_info)
788 {
789 return 0;
790 }
791 #endif
792
793 int xfrm_policy_flush(u8 type, struct xfrm_audit *audit_info)
794 {
795 int dir, err = 0;
796
797 write_lock_bh(&xfrm_policy_lock);
798
799 err = xfrm_policy_flush_secctx_check(type, audit_info);
800 if (err)
801 goto out;
802
803 for (dir = 0; dir < XFRM_POLICY_MAX; dir++) {
804 struct xfrm_policy *pol;
805 struct hlist_node *entry;
806 int i, killed;
807
808 killed = 0;
809 again1:
810 hlist_for_each_entry(pol, entry,
811 &xfrm_policy_inexact[dir], bydst) {
812 if (pol->type != type)
813 continue;
814 hlist_del(&pol->bydst);
815 hlist_del(&pol->byidx);
816 write_unlock_bh(&xfrm_policy_lock);
817
818 xfrm_audit_policy_delete(pol, 1, audit_info->loginuid,
819 audit_info->secid);
820
821 xfrm_policy_kill(pol);
822 killed++;
823
824 write_lock_bh(&xfrm_policy_lock);
825 goto again1;
826 }
827
828 for (i = xfrm_policy_bydst[dir].hmask; i >= 0; i--) {
829 again2:
830 hlist_for_each_entry(pol, entry,
831 xfrm_policy_bydst[dir].table + i,
832 bydst) {
833 if (pol->type != type)
834 continue;
835 hlist_del(&pol->bydst);
836 hlist_del(&pol->byidx);
837 write_unlock_bh(&xfrm_policy_lock);
838
839 xfrm_audit_policy_delete(pol, 1,
840 audit_info->loginuid,
841 audit_info->secid);
842 xfrm_policy_kill(pol);
843 killed++;
844
845 write_lock_bh(&xfrm_policy_lock);
846 goto again2;
847 }
848 }
849
850 xfrm_policy_count[dir] -= killed;
851 }
852 atomic_inc(&flow_cache_genid);
853 out:
854 write_unlock_bh(&xfrm_policy_lock);
855 return err;
856 }
857 EXPORT_SYMBOL(xfrm_policy_flush);
858
859 int xfrm_policy_walk(struct xfrm_policy_walk *walk,
860 int (*func)(struct xfrm_policy *, int, int, void*),
861 void *data)
862 {
863 struct xfrm_policy *old, *pol, *last = NULL;
864 int error = 0;
865
866 if (walk->type >= XFRM_POLICY_TYPE_MAX &&
867 walk->type != XFRM_POLICY_TYPE_ANY)
868 return -EINVAL;
869
870 if (walk->policy == NULL && walk->count != 0)
871 return 0;
872
873 old = pol = walk->policy;
874 walk->policy = NULL;
875 read_lock_bh(&xfrm_policy_lock);
876
877 for (; walk->cur_type < XFRM_POLICY_TYPE_MAX; walk->cur_type++) {
878 if (walk->type != walk->cur_type &&
879 walk->type != XFRM_POLICY_TYPE_ANY)
880 continue;
881
882 if (pol == NULL) {
883 pol = list_first_entry(&xfrm_policy_bytype[walk->cur_type],
884 struct xfrm_policy, bytype);
885 }
886 list_for_each_entry_from(pol, &xfrm_policy_bytype[walk->cur_type], bytype) {
887 if (pol->dead)
888 continue;
889 if (last) {
890 error = func(last, xfrm_policy_id2dir(last->index),
891 walk->count, data);
892 if (error) {
893 xfrm_pol_hold(last);
894 walk->policy = last;
895 goto out;
896 }
897 }
898 last = pol;
899 walk->count++;
900 }
901 pol = NULL;
902 }
903 if (walk->count == 0) {
904 error = -ENOENT;
905 goto out;
906 }
907 if (last)
908 error = func(last, xfrm_policy_id2dir(last->index), 0, data);
909 out:
910 read_unlock_bh(&xfrm_policy_lock);
911 if (old != NULL)
912 xfrm_pol_put(old);
913 return error;
914 }
915 EXPORT_SYMBOL(xfrm_policy_walk);
916
917 /*
918 * Find policy to apply to this flow.
919 *
920 * Returns 0 if policy found, else an -errno.
921 */
922 static int xfrm_policy_match(struct xfrm_policy *pol, struct flowi *fl,
923 u8 type, u16 family, int dir)
924 {
925 struct xfrm_selector *sel = &pol->selector;
926 int match, ret = -ESRCH;
927
928 if (pol->family != family ||
929 pol->type != type)
930 return ret;
931
932 match = xfrm_selector_match(sel, fl, family);
933 if (match)
934 ret = security_xfrm_policy_lookup(pol, fl->secid, dir);
935
936 return ret;
937 }
938
939 static struct xfrm_policy *xfrm_policy_lookup_bytype(u8 type, struct flowi *fl,
940 u16 family, u8 dir)
941 {
942 int err;
943 struct xfrm_policy *pol, *ret;
944 xfrm_address_t *daddr, *saddr;
945 struct hlist_node *entry;
946 struct hlist_head *chain;
947 u32 priority = ~0U;
948
949 daddr = xfrm_flowi_daddr(fl, family);
950 saddr = xfrm_flowi_saddr(fl, family);
951 if (unlikely(!daddr || !saddr))
952 return NULL;
953
954 read_lock_bh(&xfrm_policy_lock);
955 chain = policy_hash_direct(daddr, saddr, family, dir);
956 ret = NULL;
957 hlist_for_each_entry(pol, entry, chain, bydst) {
958 err = xfrm_policy_match(pol, fl, type, family, dir);
959 if (err) {
960 if (err == -ESRCH)
961 continue;
962 else {
963 ret = ERR_PTR(err);
964 goto fail;
965 }
966 } else {
967 ret = pol;
968 priority = ret->priority;
969 break;
970 }
971 }
972 chain = &xfrm_policy_inexact[dir];
973 hlist_for_each_entry(pol, entry, chain, bydst) {
974 err = xfrm_policy_match(pol, fl, type, family, dir);
975 if (err) {
976 if (err == -ESRCH)
977 continue;
978 else {
979 ret = ERR_PTR(err);
980 goto fail;
981 }
982 } else if (pol->priority < priority) {
983 ret = pol;
984 break;
985 }
986 }
987 if (ret)
988 xfrm_pol_hold(ret);
989 fail:
990 read_unlock_bh(&xfrm_policy_lock);
991
992 return ret;
993 }
994
995 static int xfrm_policy_lookup(struct flowi *fl, u16 family, u8 dir,
996 void **objp, atomic_t **obj_refp)
997 {
998 struct xfrm_policy *pol;
999 int err = 0;
1000
1001 #ifdef CONFIG_XFRM_SUB_POLICY
1002 pol = xfrm_policy_lookup_bytype(XFRM_POLICY_TYPE_SUB, fl, family, dir);
1003 if (IS_ERR(pol)) {
1004 err = PTR_ERR(pol);
1005 pol = NULL;
1006 }
1007 if (pol || err)
1008 goto end;
1009 #endif
1010 pol = xfrm_policy_lookup_bytype(XFRM_POLICY_TYPE_MAIN, fl, family, dir);
1011 if (IS_ERR(pol)) {
1012 err = PTR_ERR(pol);
1013 pol = NULL;
1014 }
1015 #ifdef CONFIG_XFRM_SUB_POLICY
1016 end:
1017 #endif
1018 if ((*objp = (void *) pol) != NULL)
1019 *obj_refp = &pol->refcnt;
1020 return err;
1021 }
1022
1023 static inline int policy_to_flow_dir(int dir)
1024 {
1025 if (XFRM_POLICY_IN == FLOW_DIR_IN &&
1026 XFRM_POLICY_OUT == FLOW_DIR_OUT &&
1027 XFRM_POLICY_FWD == FLOW_DIR_FWD)
1028 return dir;
1029 switch (dir) {
1030 default:
1031 case XFRM_POLICY_IN:
1032 return FLOW_DIR_IN;
1033 case XFRM_POLICY_OUT:
1034 return FLOW_DIR_OUT;
1035 case XFRM_POLICY_FWD:
1036 return FLOW_DIR_FWD;
1037 }
1038 }
1039
1040 static struct xfrm_policy *xfrm_sk_policy_lookup(struct sock *sk, int dir, struct flowi *fl)
1041 {
1042 struct xfrm_policy *pol;
1043
1044 read_lock_bh(&xfrm_policy_lock);
1045 if ((pol = sk->sk_policy[dir]) != NULL) {
1046 int match = xfrm_selector_match(&pol->selector, fl,
1047 sk->sk_family);
1048 int err = 0;
1049
1050 if (match) {
1051 err = security_xfrm_policy_lookup(pol, fl->secid,
1052 policy_to_flow_dir(dir));
1053 if (!err)
1054 xfrm_pol_hold(pol);
1055 else if (err == -ESRCH)
1056 pol = NULL;
1057 else
1058 pol = ERR_PTR(err);
1059 } else
1060 pol = NULL;
1061 }
1062 read_unlock_bh(&xfrm_policy_lock);
1063 return pol;
1064 }
1065
1066 static void __xfrm_policy_link(struct xfrm_policy *pol, int dir)
1067 {
1068 struct hlist_head *chain = policy_hash_bysel(&pol->selector,
1069 pol->family, dir);
1070
1071 hlist_add_head(&pol->bydst, chain);
1072 hlist_add_head(&pol->byidx, xfrm_policy_byidx+idx_hash(pol->index));
1073 xfrm_policy_count[dir]++;
1074 xfrm_pol_hold(pol);
1075
1076 if (xfrm_bydst_should_resize(dir, NULL))
1077 schedule_work(&xfrm_hash_work);
1078 }
1079
1080 static struct xfrm_policy *__xfrm_policy_unlink(struct xfrm_policy *pol,
1081 int dir)
1082 {
1083 if (hlist_unhashed(&pol->bydst))
1084 return NULL;
1085
1086 hlist_del(&pol->bydst);
1087 hlist_del(&pol->byidx);
1088 xfrm_policy_count[dir]--;
1089
1090 return pol;
1091 }
1092
1093 int xfrm_policy_delete(struct xfrm_policy *pol, int dir)
1094 {
1095 write_lock_bh(&xfrm_policy_lock);
1096 pol = __xfrm_policy_unlink(pol, dir);
1097 write_unlock_bh(&xfrm_policy_lock);
1098 if (pol) {
1099 if (dir < XFRM_POLICY_MAX)
1100 atomic_inc(&flow_cache_genid);
1101 xfrm_policy_kill(pol);
1102 return 0;
1103 }
1104 return -ENOENT;
1105 }
1106 EXPORT_SYMBOL(xfrm_policy_delete);
1107
1108 int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol)
1109 {
1110 struct xfrm_policy *old_pol;
1111
1112 #ifdef CONFIG_XFRM_SUB_POLICY
1113 if (pol && pol->type != XFRM_POLICY_TYPE_MAIN)
1114 return -EINVAL;
1115 #endif
1116
1117 write_lock_bh(&xfrm_policy_lock);
1118 old_pol = sk->sk_policy[dir];
1119 sk->sk_policy[dir] = pol;
1120 if (pol) {
1121 pol->curlft.add_time = get_seconds();
1122 pol->index = xfrm_gen_index(pol->type, XFRM_POLICY_MAX+dir);
1123 __xfrm_policy_link(pol, XFRM_POLICY_MAX+dir);
1124 }
1125 if (old_pol)
1126 __xfrm_policy_unlink(old_pol, XFRM_POLICY_MAX+dir);
1127 write_unlock_bh(&xfrm_policy_lock);
1128
1129 if (old_pol) {
1130 xfrm_policy_kill(old_pol);
1131 }
1132 return 0;
1133 }
1134
1135 static struct xfrm_policy *clone_policy(struct xfrm_policy *old, int dir)
1136 {
1137 struct xfrm_policy *newp = xfrm_policy_alloc(GFP_ATOMIC);
1138
1139 if (newp) {
1140 newp->selector = old->selector;
1141 if (security_xfrm_policy_clone(old, newp)) {
1142 kfree(newp);
1143 return NULL; /* ENOMEM */
1144 }
1145 newp->lft = old->lft;
1146 newp->curlft = old->curlft;
1147 newp->action = old->action;
1148 newp->flags = old->flags;
1149 newp->xfrm_nr = old->xfrm_nr;
1150 newp->index = old->index;
1151 newp->type = old->type;
1152 memcpy(newp->xfrm_vec, old->xfrm_vec,
1153 newp->xfrm_nr*sizeof(struct xfrm_tmpl));
1154 write_lock_bh(&xfrm_policy_lock);
1155 __xfrm_policy_link(newp, XFRM_POLICY_MAX+dir);
1156 write_unlock_bh(&xfrm_policy_lock);
1157 xfrm_pol_put(newp);
1158 }
1159 return newp;
1160 }
1161
1162 int __xfrm_sk_clone_policy(struct sock *sk)
1163 {
1164 struct xfrm_policy *p0 = sk->sk_policy[0],
1165 *p1 = sk->sk_policy[1];
1166
1167 sk->sk_policy[0] = sk->sk_policy[1] = NULL;
1168 if (p0 && (sk->sk_policy[0] = clone_policy(p0, 0)) == NULL)
1169 return -ENOMEM;
1170 if (p1 && (sk->sk_policy[1] = clone_policy(p1, 1)) == NULL)
1171 return -ENOMEM;
1172 return 0;
1173 }
1174
1175 static int
1176 xfrm_get_saddr(xfrm_address_t *local, xfrm_address_t *remote,
1177 unsigned short family)
1178 {
1179 int err;
1180 struct xfrm_policy_afinfo *afinfo = xfrm_policy_get_afinfo(family);
1181
1182 if (unlikely(afinfo == NULL))
1183 return -EINVAL;
1184 err = afinfo->get_saddr(local, remote);
1185 xfrm_policy_put_afinfo(afinfo);
1186 return err;
1187 }
1188
1189 /* Resolve list of templates for the flow, given policy. */
1190
1191 static int
1192 xfrm_tmpl_resolve_one(struct xfrm_policy *policy, struct flowi *fl,
1193 struct xfrm_state **xfrm,
1194 unsigned short family)
1195 {
1196 int nx;
1197 int i, error;
1198 xfrm_address_t *daddr = xfrm_flowi_daddr(fl, family);
1199 xfrm_address_t *saddr = xfrm_flowi_saddr(fl, family);
1200 xfrm_address_t tmp;
1201
1202 for (nx=0, i = 0; i < policy->xfrm_nr; i++) {
1203 struct xfrm_state *x;
1204 xfrm_address_t *remote = daddr;
1205 xfrm_address_t *local = saddr;
1206 struct xfrm_tmpl *tmpl = &policy->xfrm_vec[i];
1207
1208 if (tmpl->mode == XFRM_MODE_TUNNEL ||
1209 tmpl->mode == XFRM_MODE_BEET) {
1210 remote = &tmpl->id.daddr;
1211 local = &tmpl->saddr;
1212 family = tmpl->encap_family;
1213 if (xfrm_addr_any(local, family)) {
1214 error = xfrm_get_saddr(&tmp, remote, family);
1215 if (error)
1216 goto fail;
1217 local = &tmp;
1218 }
1219 }
1220
1221 x = xfrm_state_find(remote, local, fl, tmpl, policy, &error, family);
1222
1223 if (x && x->km.state == XFRM_STATE_VALID) {
1224 xfrm[nx++] = x;
1225 daddr = remote;
1226 saddr = local;
1227 continue;
1228 }
1229 if (x) {
1230 error = (x->km.state == XFRM_STATE_ERROR ?
1231 -EINVAL : -EAGAIN);
1232 xfrm_state_put(x);
1233 }
1234
1235 if (!tmpl->optional)
1236 goto fail;
1237 }
1238 return nx;
1239
1240 fail:
1241 for (nx--; nx>=0; nx--)
1242 xfrm_state_put(xfrm[nx]);
1243 return error;
1244 }
1245
1246 static int
1247 xfrm_tmpl_resolve(struct xfrm_policy **pols, int npols, struct flowi *fl,
1248 struct xfrm_state **xfrm,
1249 unsigned short family)
1250 {
1251 struct xfrm_state *tp[XFRM_MAX_DEPTH];
1252 struct xfrm_state **tpp = (npols > 1) ? tp : xfrm;
1253 int cnx = 0;
1254 int error;
1255 int ret;
1256 int i;
1257
1258 for (i = 0; i < npols; i++) {
1259 if (cnx + pols[i]->xfrm_nr >= XFRM_MAX_DEPTH) {
1260 error = -ENOBUFS;
1261 goto fail;
1262 }
1263
1264 ret = xfrm_tmpl_resolve_one(pols[i], fl, &tpp[cnx], family);
1265 if (ret < 0) {
1266 error = ret;
1267 goto fail;
1268 } else
1269 cnx += ret;
1270 }
1271
1272 /* found states are sorted for outbound processing */
1273 if (npols > 1)
1274 xfrm_state_sort(xfrm, tpp, cnx, family);
1275
1276 return cnx;
1277
1278 fail:
1279 for (cnx--; cnx>=0; cnx--)
1280 xfrm_state_put(tpp[cnx]);
1281 return error;
1282
1283 }
1284
1285 /* Check that the bundle accepts the flow and its components are
1286 * still valid.
1287 */
1288
1289 static struct dst_entry *
1290 xfrm_find_bundle(struct flowi *fl, struct xfrm_policy *policy, unsigned short family)
1291 {
1292 struct dst_entry *x;
1293 struct xfrm_policy_afinfo *afinfo = xfrm_policy_get_afinfo(family);
1294 if (unlikely(afinfo == NULL))
1295 return ERR_PTR(-EINVAL);
1296 x = afinfo->find_bundle(fl, policy);
1297 xfrm_policy_put_afinfo(afinfo);
1298 return x;
1299 }
1300
1301 static inline int xfrm_get_tos(struct flowi *fl, int family)
1302 {
1303 struct xfrm_policy_afinfo *afinfo = xfrm_policy_get_afinfo(family);
1304 int tos;
1305
1306 if (!afinfo)
1307 return -EINVAL;
1308
1309 tos = afinfo->get_tos(fl);
1310
1311 xfrm_policy_put_afinfo(afinfo);
1312
1313 return tos;
1314 }
1315
1316 static inline struct xfrm_dst *xfrm_alloc_dst(int family)
1317 {
1318 struct xfrm_policy_afinfo *afinfo = xfrm_policy_get_afinfo(family);
1319 struct xfrm_dst *xdst;
1320
1321 if (!afinfo)
1322 return ERR_PTR(-EINVAL);
1323
1324 xdst = dst_alloc(afinfo->dst_ops) ?: ERR_PTR(-ENOBUFS);
1325
1326 xfrm_policy_put_afinfo(afinfo);
1327
1328 return xdst;
1329 }
1330
1331 static inline int xfrm_init_path(struct xfrm_dst *path, struct dst_entry *dst,
1332 int nfheader_len)
1333 {
1334 struct xfrm_policy_afinfo *afinfo =
1335 xfrm_policy_get_afinfo(dst->ops->family);
1336 int err;
1337
1338 if (!afinfo)
1339 return -EINVAL;
1340
1341 err = afinfo->init_path(path, dst, nfheader_len);
1342
1343 xfrm_policy_put_afinfo(afinfo);
1344
1345 return err;
1346 }
1347
1348 static inline int xfrm_fill_dst(struct xfrm_dst *xdst, struct net_device *dev)
1349 {
1350 struct xfrm_policy_afinfo *afinfo =
1351 xfrm_policy_get_afinfo(xdst->u.dst.ops->family);
1352 int err;
1353
1354 if (!afinfo)
1355 return -EINVAL;
1356
1357 err = afinfo->fill_dst(xdst, dev);
1358
1359 xfrm_policy_put_afinfo(afinfo);
1360
1361 return err;
1362 }
1363
1364 /* Allocate chain of dst_entry's, attach known xfrm's, calculate
1365 * all the metrics... Shortly, bundle a bundle.
1366 */
1367
1368 static struct dst_entry *xfrm_bundle_create(struct xfrm_policy *policy,
1369 struct xfrm_state **xfrm, int nx,
1370 struct flowi *fl,
1371 struct dst_entry *dst)
1372 {
1373 unsigned long now = jiffies;
1374 struct net_device *dev;
1375 struct dst_entry *dst_prev = NULL;
1376 struct dst_entry *dst0 = NULL;
1377 int i = 0;
1378 int err;
1379 int header_len = 0;
1380 int nfheader_len = 0;
1381 int trailer_len = 0;
1382 int tos;
1383 int family = policy->selector.family;
1384 xfrm_address_t saddr, daddr;
1385
1386 xfrm_flowi_addr_get(fl, &saddr, &daddr, family);
1387
1388 tos = xfrm_get_tos(fl, family);
1389 err = tos;
1390 if (tos < 0)
1391 goto put_states;
1392
1393 dst_hold(dst);
1394
1395 for (; i < nx; i++) {
1396 struct xfrm_dst *xdst = xfrm_alloc_dst(family);
1397 struct dst_entry *dst1 = &xdst->u.dst;
1398
1399 err = PTR_ERR(xdst);
1400 if (IS_ERR(xdst)) {
1401 dst_release(dst);
1402 goto put_states;
1403 }
1404
1405 if (!dst_prev)
1406 dst0 = dst1;
1407 else {
1408 dst_prev->child = dst_clone(dst1);
1409 dst1->flags |= DST_NOHASH;
1410 }
1411
1412 xdst->route = dst;
1413 memcpy(&dst1->metrics, &dst->metrics, sizeof(dst->metrics));
1414
1415 if (xfrm[i]->props.mode != XFRM_MODE_TRANSPORT) {
1416 family = xfrm[i]->props.family;
1417 dst = xfrm_dst_lookup(xfrm[i], tos, &saddr, &daddr,
1418 family);
1419 err = PTR_ERR(dst);
1420 if (IS_ERR(dst))
1421 goto put_states;
1422 } else
1423 dst_hold(dst);
1424
1425 dst1->xfrm = xfrm[i];
1426 xdst->genid = xfrm[i]->genid;
1427
1428 dst1->obsolete = -1;
1429 dst1->flags |= DST_HOST;
1430 dst1->lastuse = now;
1431
1432 dst1->input = dst_discard;
1433 dst1->output = xfrm[i]->outer_mode->afinfo->output;
1434
1435 dst1->next = dst_prev;
1436 dst_prev = dst1;
1437
1438 header_len += xfrm[i]->props.header_len;
1439 if (xfrm[i]->type->flags & XFRM_TYPE_NON_FRAGMENT)
1440 nfheader_len += xfrm[i]->props.header_len;
1441 trailer_len += xfrm[i]->props.trailer_len;
1442 }
1443
1444 dst_prev->child = dst;
1445 dst0->path = dst;
1446
1447 err = -ENODEV;
1448 dev = dst->dev;
1449 if (!dev)
1450 goto free_dst;
1451
1452 /* Copy neighbout for reachability confirmation */
1453 dst0->neighbour = neigh_clone(dst->neighbour);
1454
1455 xfrm_init_path((struct xfrm_dst *)dst0, dst, nfheader_len);
1456 xfrm_init_pmtu(dst_prev);
1457
1458 for (dst_prev = dst0; dst_prev != dst; dst_prev = dst_prev->child) {
1459 struct xfrm_dst *xdst = (struct xfrm_dst *)dst_prev;
1460
1461 err = xfrm_fill_dst(xdst, dev);
1462 if (err)
1463 goto free_dst;
1464
1465 dst_prev->header_len = header_len;
1466 dst_prev->trailer_len = trailer_len;
1467 header_len -= xdst->u.dst.xfrm->props.header_len;
1468 trailer_len -= xdst->u.dst.xfrm->props.trailer_len;
1469 }
1470
1471 out:
1472 return dst0;
1473
1474 put_states:
1475 for (; i < nx; i++)
1476 xfrm_state_put(xfrm[i]);
1477 free_dst:
1478 if (dst0)
1479 dst_free(dst0);
1480 dst0 = ERR_PTR(err);
1481 goto out;
1482 }
1483
1484 static int inline
1485 xfrm_dst_alloc_copy(void **target, void *src, int size)
1486 {
1487 if (!*target) {
1488 *target = kmalloc(size, GFP_ATOMIC);
1489 if (!*target)
1490 return -ENOMEM;
1491 }
1492 memcpy(*target, src, size);
1493 return 0;
1494 }
1495
1496 static int inline
1497 xfrm_dst_update_parent(struct dst_entry *dst, struct xfrm_selector *sel)
1498 {
1499 #ifdef CONFIG_XFRM_SUB_POLICY
1500 struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
1501 return xfrm_dst_alloc_copy((void **)&(xdst->partner),
1502 sel, sizeof(*sel));
1503 #else
1504 return 0;
1505 #endif
1506 }
1507
1508 static int inline
1509 xfrm_dst_update_origin(struct dst_entry *dst, struct flowi *fl)
1510 {
1511 #ifdef CONFIG_XFRM_SUB_POLICY
1512 struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
1513 return xfrm_dst_alloc_copy((void **)&(xdst->origin), fl, sizeof(*fl));
1514 #else
1515 return 0;
1516 #endif
1517 }
1518
1519 static int stale_bundle(struct dst_entry *dst);
1520
1521 /* Main function: finds/creates a bundle for given flow.
1522 *
1523 * At the moment we eat a raw IP route. Mostly to speed up lookups
1524 * on interfaces with disabled IPsec.
1525 */
1526 int __xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
1527 struct sock *sk, int flags)
1528 {
1529 struct xfrm_policy *policy;
1530 struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX];
1531 int npols;
1532 int pol_dead;
1533 int xfrm_nr;
1534 int pi;
1535 struct xfrm_state *xfrm[XFRM_MAX_DEPTH];
1536 struct dst_entry *dst, *dst_orig = *dst_p;
1537 int nx = 0;
1538 int err;
1539 u32 genid;
1540 u16 family;
1541 u8 dir = policy_to_flow_dir(XFRM_POLICY_OUT);
1542
1543 restart:
1544 genid = atomic_read(&flow_cache_genid);
1545 policy = NULL;
1546 for (pi = 0; pi < ARRAY_SIZE(pols); pi++)
1547 pols[pi] = NULL;
1548 npols = 0;
1549 pol_dead = 0;
1550 xfrm_nr = 0;
1551
1552 if (sk && sk->sk_policy[XFRM_POLICY_OUT]) {
1553 policy = xfrm_sk_policy_lookup(sk, XFRM_POLICY_OUT, fl);
1554 err = PTR_ERR(policy);
1555 if (IS_ERR(policy)) {
1556 XFRM_INC_STATS(LINUX_MIB_XFRMOUTPOLERROR);
1557 goto dropdst;
1558 }
1559 }
1560
1561 if (!policy) {
1562 /* To accelerate a bit... */
1563 if ((dst_orig->flags & DST_NOXFRM) ||
1564 !xfrm_policy_count[XFRM_POLICY_OUT])
1565 goto nopol;
1566
1567 policy = flow_cache_lookup(fl, dst_orig->ops->family,
1568 dir, xfrm_policy_lookup);
1569 err = PTR_ERR(policy);
1570 if (IS_ERR(policy)) {
1571 XFRM_INC_STATS(LINUX_MIB_XFRMOUTPOLERROR);
1572 goto dropdst;
1573 }
1574 }
1575
1576 if (!policy)
1577 goto nopol;
1578
1579 family = dst_orig->ops->family;
1580 pols[0] = policy;
1581 npols ++;
1582 xfrm_nr += pols[0]->xfrm_nr;
1583
1584 err = -ENOENT;
1585 if ((flags & XFRM_LOOKUP_ICMP) && !(policy->flags & XFRM_POLICY_ICMP))
1586 goto error;
1587
1588 policy->curlft.use_time = get_seconds();
1589
1590 switch (policy->action) {
1591 default:
1592 case XFRM_POLICY_BLOCK:
1593 /* Prohibit the flow */
1594 XFRM_INC_STATS(LINUX_MIB_XFRMOUTPOLBLOCK);
1595 err = -EPERM;
1596 goto error;
1597
1598 case XFRM_POLICY_ALLOW:
1599 #ifndef CONFIG_XFRM_SUB_POLICY
1600 if (policy->xfrm_nr == 0) {
1601 /* Flow passes not transformed. */
1602 xfrm_pol_put(policy);
1603 return 0;
1604 }
1605 #endif
1606
1607 /* Try to find matching bundle.
1608 *
1609 * LATER: help from flow cache. It is optional, this
1610 * is required only for output policy.
1611 */
1612 dst = xfrm_find_bundle(fl, policy, family);
1613 if (IS_ERR(dst)) {
1614 XFRM_INC_STATS(LINUX_MIB_XFRMOUTBUNDLECHECKERROR);
1615 err = PTR_ERR(dst);
1616 goto error;
1617 }
1618
1619 if (dst)
1620 break;
1621
1622 #ifdef CONFIG_XFRM_SUB_POLICY
1623 if (pols[0]->type != XFRM_POLICY_TYPE_MAIN) {
1624 pols[1] = xfrm_policy_lookup_bytype(XFRM_POLICY_TYPE_MAIN,
1625 fl, family,
1626 XFRM_POLICY_OUT);
1627 if (pols[1]) {
1628 if (IS_ERR(pols[1])) {
1629 XFRM_INC_STATS(LINUX_MIB_XFRMOUTPOLERROR);
1630 err = PTR_ERR(pols[1]);
1631 goto error;
1632 }
1633 if (pols[1]->action == XFRM_POLICY_BLOCK) {
1634 XFRM_INC_STATS(LINUX_MIB_XFRMOUTPOLBLOCK);
1635 err = -EPERM;
1636 goto error;
1637 }
1638 npols ++;
1639 xfrm_nr += pols[1]->xfrm_nr;
1640 }
1641 }
1642
1643 /*
1644 * Because neither flowi nor bundle information knows about
1645 * transformation template size. On more than one policy usage
1646 * we can realize whether all of them is bypass or not after
1647 * they are searched. See above not-transformed bypass
1648 * is surrounded by non-sub policy configuration, too.
1649 */
1650 if (xfrm_nr == 0) {
1651 /* Flow passes not transformed. */
1652 xfrm_pols_put(pols, npols);
1653 return 0;
1654 }
1655
1656 #endif
1657 nx = xfrm_tmpl_resolve(pols, npols, fl, xfrm, family);
1658
1659 if (unlikely(nx<0)) {
1660 err = nx;
1661 if (err == -EAGAIN && sysctl_xfrm_larval_drop) {
1662 /* EREMOTE tells the caller to generate
1663 * a one-shot blackhole route.
1664 */
1665 XFRM_INC_STATS(LINUX_MIB_XFRMOUTNOSTATES);
1666 xfrm_pol_put(policy);
1667 return -EREMOTE;
1668 }
1669 if (err == -EAGAIN && (flags & XFRM_LOOKUP_WAIT)) {
1670 DECLARE_WAITQUEUE(wait, current);
1671
1672 add_wait_queue(&km_waitq, &wait);
1673 set_current_state(TASK_INTERRUPTIBLE);
1674 schedule();
1675 set_current_state(TASK_RUNNING);
1676 remove_wait_queue(&km_waitq, &wait);
1677
1678 nx = xfrm_tmpl_resolve(pols, npols, fl, xfrm, family);
1679
1680 if (nx == -EAGAIN && signal_pending(current)) {
1681 XFRM_INC_STATS(LINUX_MIB_XFRMOUTNOSTATES);
1682 err = -ERESTART;
1683 goto error;
1684 }
1685 if (nx == -EAGAIN ||
1686 genid != atomic_read(&flow_cache_genid)) {
1687 xfrm_pols_put(pols, npols);
1688 goto restart;
1689 }
1690 err = nx;
1691 }
1692 if (err < 0) {
1693 XFRM_INC_STATS(LINUX_MIB_XFRMOUTNOSTATES);
1694 goto error;
1695 }
1696 }
1697 if (nx == 0) {
1698 /* Flow passes not transformed. */
1699 xfrm_pols_put(pols, npols);
1700 return 0;
1701 }
1702
1703 dst = xfrm_bundle_create(policy, xfrm, nx, fl, dst_orig);
1704 err = PTR_ERR(dst);
1705 if (IS_ERR(dst)) {
1706 XFRM_INC_STATS(LINUX_MIB_XFRMOUTBUNDLEGENERROR);
1707 goto error;
1708 }
1709
1710 for (pi = 0; pi < npols; pi++) {
1711 read_lock_bh(&pols[pi]->lock);
1712 pol_dead |= pols[pi]->dead;
1713 read_unlock_bh(&pols[pi]->lock);
1714 }
1715
1716 write_lock_bh(&policy->lock);
1717 if (unlikely(pol_dead || stale_bundle(dst))) {
1718 /* Wow! While we worked on resolving, this
1719 * policy has gone. Retry. It is not paranoia,
1720 * we just cannot enlist new bundle to dead object.
1721 * We can't enlist stable bundles either.
1722 */
1723 write_unlock_bh(&policy->lock);
1724 if (dst)
1725 dst_free(dst);
1726
1727 if (pol_dead)
1728 XFRM_INC_STATS(LINUX_MIB_XFRMOUTPOLDEAD);
1729 else
1730 XFRM_INC_STATS(LINUX_MIB_XFRMOUTBUNDLECHECKERROR);
1731 err = -EHOSTUNREACH;
1732 goto error;
1733 }
1734
1735 if (npols > 1)
1736 err = xfrm_dst_update_parent(dst, &pols[1]->selector);
1737 else
1738 err = xfrm_dst_update_origin(dst, fl);
1739 if (unlikely(err)) {
1740 write_unlock_bh(&policy->lock);
1741 if (dst)
1742 dst_free(dst);
1743 XFRM_INC_STATS(LINUX_MIB_XFRMOUTBUNDLECHECKERROR);
1744 goto error;
1745 }
1746
1747 dst->next = policy->bundles;
1748 policy->bundles = dst;
1749 dst_hold(dst);
1750 write_unlock_bh(&policy->lock);
1751 }
1752 *dst_p = dst;
1753 dst_release(dst_orig);
1754 xfrm_pols_put(pols, npols);
1755 return 0;
1756
1757 error:
1758 xfrm_pols_put(pols, npols);
1759 dropdst:
1760 dst_release(dst_orig);
1761 *dst_p = NULL;
1762 return err;
1763
1764 nopol:
1765 err = -ENOENT;
1766 if (flags & XFRM_LOOKUP_ICMP)
1767 goto dropdst;
1768 return 0;
1769 }
1770 EXPORT_SYMBOL(__xfrm_lookup);
1771
1772 int xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
1773 struct sock *sk, int flags)
1774 {
1775 int err = __xfrm_lookup(dst_p, fl, sk, flags);
1776
1777 if (err == -EREMOTE) {
1778 dst_release(*dst_p);
1779 *dst_p = NULL;
1780 err = -EAGAIN;
1781 }
1782
1783 return err;
1784 }
1785 EXPORT_SYMBOL(xfrm_lookup);
1786
1787 static inline int
1788 xfrm_secpath_reject(int idx, struct sk_buff *skb, struct flowi *fl)
1789 {
1790 struct xfrm_state *x;
1791
1792 if (!skb->sp || idx < 0 || idx >= skb->sp->len)
1793 return 0;
1794 x = skb->sp->xvec[idx];
1795 if (!x->type->reject)
1796 return 0;
1797 return x->type->reject(x, skb, fl);
1798 }
1799
1800 /* When skb is transformed back to its "native" form, we have to
1801 * check policy restrictions. At the moment we make this in maximally
1802 * stupid way. Shame on me. :-) Of course, connected sockets must
1803 * have policy cached at them.
1804 */
1805
1806 static inline int
1807 xfrm_state_ok(struct xfrm_tmpl *tmpl, struct xfrm_state *x,
1808 unsigned short family)
1809 {
1810 if (xfrm_state_kern(x))
1811 return tmpl->optional && !xfrm_state_addr_cmp(tmpl, x, tmpl->encap_family);
1812 return x->id.proto == tmpl->id.proto &&
1813 (x->id.spi == tmpl->id.spi || !tmpl->id.spi) &&
1814 (x->props.reqid == tmpl->reqid || !tmpl->reqid) &&
1815 x->props.mode == tmpl->mode &&
1816 ((tmpl->aalgos & (1<<x->props.aalgo)) ||
1817 !(xfrm_id_proto_match(tmpl->id.proto, IPSEC_PROTO_ANY))) &&
1818 !(x->props.mode != XFRM_MODE_TRANSPORT &&
1819 xfrm_state_addr_cmp(tmpl, x, family));
1820 }
1821
1822 /*
1823 * 0 or more than 0 is returned when validation is succeeded (either bypass
1824 * because of optional transport mode, or next index of the mathced secpath
1825 * state with the template.
1826 * -1 is returned when no matching template is found.
1827 * Otherwise "-2 - errored_index" is returned.
1828 */
1829 static inline int
1830 xfrm_policy_ok(struct xfrm_tmpl *tmpl, struct sec_path *sp, int start,
1831 unsigned short family)
1832 {
1833 int idx = start;
1834
1835 if (tmpl->optional) {
1836 if (tmpl->mode == XFRM_MODE_TRANSPORT)
1837 return start;
1838 } else
1839 start = -1;
1840 for (; idx < sp->len; idx++) {
1841 if (xfrm_state_ok(tmpl, sp->xvec[idx], family))
1842 return ++idx;
1843 if (sp->xvec[idx]->props.mode != XFRM_MODE_TRANSPORT) {
1844 if (start == -1)
1845 start = -2-idx;
1846 break;
1847 }
1848 }
1849 return start;
1850 }
1851
1852 int __xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
1853 unsigned int family, int reverse)
1854 {
1855 struct xfrm_policy_afinfo *afinfo = xfrm_policy_get_afinfo(family);
1856 int err;
1857
1858 if (unlikely(afinfo == NULL))
1859 return -EAFNOSUPPORT;
1860
1861 afinfo->decode_session(skb, fl, reverse);
1862 err = security_xfrm_decode_session(skb, &fl->secid);
1863 xfrm_policy_put_afinfo(afinfo);
1864 return err;
1865 }
1866 EXPORT_SYMBOL(__xfrm_decode_session);
1867
1868 static inline int secpath_has_nontransport(struct sec_path *sp, int k, int *idxp)
1869 {
1870 for (; k < sp->len; k++) {
1871 if (sp->xvec[k]->props.mode != XFRM_MODE_TRANSPORT) {
1872 *idxp = k;
1873 return 1;
1874 }
1875 }
1876
1877 return 0;
1878 }
1879
1880 int __xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb,
1881 unsigned short family)
1882 {
1883 struct xfrm_policy *pol;
1884 struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX];
1885 int npols = 0;
1886 int xfrm_nr;
1887 int pi;
1888 int reverse;
1889 struct flowi fl;
1890 u8 fl_dir;
1891 int xerr_idx = -1;
1892
1893 reverse = dir & ~XFRM_POLICY_MASK;
1894 dir &= XFRM_POLICY_MASK;
1895 fl_dir = policy_to_flow_dir(dir);
1896
1897 if (__xfrm_decode_session(skb, &fl, family, reverse) < 0) {
1898 XFRM_INC_STATS(LINUX_MIB_XFRMINHDRERROR);
1899 return 0;
1900 }
1901
1902 nf_nat_decode_session(skb, &fl, family);
1903
1904 /* First, check used SA against their selectors. */
1905 if (skb->sp) {
1906 int i;
1907
1908 for (i=skb->sp->len-1; i>=0; i--) {
1909 struct xfrm_state *x = skb->sp->xvec[i];
1910 if (!xfrm_selector_match(&x->sel, &fl, family)) {
1911 XFRM_INC_STATS(LINUX_MIB_XFRMINSTATEMISMATCH);
1912 return 0;
1913 }
1914 }
1915 }
1916
1917 pol = NULL;
1918 if (sk && sk->sk_policy[dir]) {
1919 pol = xfrm_sk_policy_lookup(sk, dir, &fl);
1920 if (IS_ERR(pol)) {
1921 XFRM_INC_STATS(LINUX_MIB_XFRMINPOLERROR);
1922 return 0;
1923 }
1924 }
1925
1926 if (!pol)
1927 pol = flow_cache_lookup(&fl, family, fl_dir,
1928 xfrm_policy_lookup);
1929
1930 if (IS_ERR(pol)) {
1931 XFRM_INC_STATS(LINUX_MIB_XFRMINPOLERROR);
1932 return 0;
1933 }
1934
1935 if (!pol) {
1936 if (skb->sp && secpath_has_nontransport(skb->sp, 0, &xerr_idx)) {
1937 xfrm_secpath_reject(xerr_idx, skb, &fl);
1938 XFRM_INC_STATS(LINUX_MIB_XFRMINNOPOLS);
1939 return 0;
1940 }
1941 return 1;
1942 }
1943
1944 pol->curlft.use_time = get_seconds();
1945
1946 pols[0] = pol;
1947 npols ++;
1948 #ifdef CONFIG_XFRM_SUB_POLICY
1949 if (pols[0]->type != XFRM_POLICY_TYPE_MAIN) {
1950 pols[1] = xfrm_policy_lookup_bytype(XFRM_POLICY_TYPE_MAIN,
1951 &fl, family,
1952 XFRM_POLICY_IN);
1953 if (pols[1]) {
1954 if (IS_ERR(pols[1])) {
1955 XFRM_INC_STATS(LINUX_MIB_XFRMINPOLERROR);
1956 return 0;
1957 }
1958 pols[1]->curlft.use_time = get_seconds();
1959 npols ++;
1960 }
1961 }
1962 #endif
1963
1964 if (pol->action == XFRM_POLICY_ALLOW) {
1965 struct sec_path *sp;
1966 static struct sec_path dummy;
1967 struct xfrm_tmpl *tp[XFRM_MAX_DEPTH];
1968 struct xfrm_tmpl *stp[XFRM_MAX_DEPTH];
1969 struct xfrm_tmpl **tpp = tp;
1970 int ti = 0;
1971 int i, k;
1972
1973 if ((sp = skb->sp) == NULL)
1974 sp = &dummy;
1975
1976 for (pi = 0; pi < npols; pi++) {
1977 if (pols[pi] != pol &&
1978 pols[pi]->action != XFRM_POLICY_ALLOW) {
1979 XFRM_INC_STATS(LINUX_MIB_XFRMINPOLBLOCK);
1980 goto reject;
1981 }
1982 if (ti + pols[pi]->xfrm_nr >= XFRM_MAX_DEPTH) {
1983 XFRM_INC_STATS(LINUX_MIB_XFRMINBUFFERERROR);
1984 goto reject_error;
1985 }
1986 for (i = 0; i < pols[pi]->xfrm_nr; i++)
1987 tpp[ti++] = &pols[pi]->xfrm_vec[i];
1988 }
1989 xfrm_nr = ti;
1990 if (npols > 1) {
1991 xfrm_tmpl_sort(stp, tpp, xfrm_nr, family);
1992 tpp = stp;
1993 }
1994
1995 /* For each tunnel xfrm, find the first matching tmpl.
1996 * For each tmpl before that, find corresponding xfrm.
1997 * Order is _important_. Later we will implement
1998 * some barriers, but at the moment barriers
1999 * are implied between each two transformations.
2000 */
2001 for (i = xfrm_nr-1, k = 0; i >= 0; i--) {
2002 k = xfrm_policy_ok(tpp[i], sp, k, family);
2003 if (k < 0) {
2004 if (k < -1)
2005 /* "-2 - errored_index" returned */
2006 xerr_idx = -(2+k);
2007 XFRM_INC_STATS(LINUX_MIB_XFRMINTMPLMISMATCH);
2008 goto reject;
2009 }
2010 }
2011
2012 if (secpath_has_nontransport(sp, k, &xerr_idx)) {
2013 XFRM_INC_STATS(LINUX_MIB_XFRMINTMPLMISMATCH);
2014 goto reject;
2015 }
2016
2017 xfrm_pols_put(pols, npols);
2018 return 1;
2019 }
2020 XFRM_INC_STATS(LINUX_MIB_XFRMINPOLBLOCK);
2021
2022 reject:
2023 xfrm_secpath_reject(xerr_idx, skb, &fl);
2024 reject_error:
2025 xfrm_pols_put(pols, npols);
2026 return 0;
2027 }
2028 EXPORT_SYMBOL(__xfrm_policy_check);
2029
2030 int __xfrm_route_forward(struct sk_buff *skb, unsigned short family)
2031 {
2032 struct flowi fl;
2033
2034 if (xfrm_decode_session(skb, &fl, family) < 0) {
2035 /* XXX: we should have something like FWDHDRERROR here. */
2036 XFRM_INC_STATS(LINUX_MIB_XFRMINHDRERROR);
2037 return 0;
2038 }
2039
2040 return xfrm_lookup(&skb->dst, &fl, NULL, 0) == 0;
2041 }
2042 EXPORT_SYMBOL(__xfrm_route_forward);
2043
2044 /* Optimize later using cookies and generation ids. */
2045
2046 static struct dst_entry *xfrm_dst_check(struct dst_entry *dst, u32 cookie)
2047 {
2048 /* Code (such as __xfrm4_bundle_create()) sets dst->obsolete
2049 * to "-1" to force all XFRM destinations to get validated by
2050 * dst_ops->check on every use. We do this because when a
2051 * normal route referenced by an XFRM dst is obsoleted we do
2052 * not go looking around for all parent referencing XFRM dsts
2053 * so that we can invalidate them. It is just too much work.
2054 * Instead we make the checks here on every use. For example:
2055 *
2056 * XFRM dst A --> IPv4 dst X
2057 *
2058 * X is the "xdst->route" of A (X is also the "dst->path" of A
2059 * in this example). If X is marked obsolete, "A" will not
2060 * notice. That's what we are validating here via the
2061 * stale_bundle() check.
2062 *
2063 * When a policy's bundle is pruned, we dst_free() the XFRM
2064 * dst which causes it's ->obsolete field to be set to a
2065 * positive non-zero integer. If an XFRM dst has been pruned
2066 * like this, we want to force a new route lookup.
2067 */
2068 if (dst->obsolete < 0 && !stale_bundle(dst))
2069 return dst;
2070
2071 return NULL;
2072 }
2073
2074 static int stale_bundle(struct dst_entry *dst)
2075 {
2076 return !xfrm_bundle_ok(NULL, (struct xfrm_dst *)dst, NULL, AF_UNSPEC, 0);
2077 }
2078
2079 void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev)
2080 {
2081 while ((dst = dst->child) && dst->xfrm && dst->dev == dev) {
2082 dst->dev = dev->nd_net->loopback_dev;
2083 dev_hold(dst->dev);
2084 dev_put(dev);
2085 }
2086 }
2087 EXPORT_SYMBOL(xfrm_dst_ifdown);
2088
2089 static void xfrm_link_failure(struct sk_buff *skb)
2090 {
2091 /* Impossible. Such dst must be popped before reaches point of failure. */
2092 return;
2093 }
2094
2095 static struct dst_entry *xfrm_negative_advice(struct dst_entry *dst)
2096 {
2097 if (dst) {
2098 if (dst->obsolete) {
2099 dst_release(dst);
2100 dst = NULL;
2101 }
2102 }
2103 return dst;
2104 }
2105
2106 static void prune_one_bundle(struct xfrm_policy *pol, int (*func)(struct dst_entry *), struct dst_entry **gc_list_p)
2107 {
2108 struct dst_entry *dst, **dstp;
2109
2110 write_lock(&pol->lock);
2111 dstp = &pol->bundles;
2112 while ((dst=*dstp) != NULL) {
2113 if (func(dst)) {
2114 *dstp = dst->next;
2115 dst->next = *gc_list_p;
2116 *gc_list_p = dst;
2117 } else {
2118 dstp = &dst->next;
2119 }
2120 }
2121 write_unlock(&pol->lock);
2122 }
2123
2124 static void xfrm_prune_bundles(int (*func)(struct dst_entry *))
2125 {
2126 struct dst_entry *gc_list = NULL;
2127 int dir;
2128
2129 read_lock_bh(&xfrm_policy_lock);
2130 for (dir = 0; dir < XFRM_POLICY_MAX * 2; dir++) {
2131 struct xfrm_policy *pol;
2132 struct hlist_node *entry;
2133 struct hlist_head *table;
2134 int i;
2135
2136 hlist_for_each_entry(pol, entry,
2137 &xfrm_policy_inexact[dir], bydst)
2138 prune_one_bundle(pol, func, &gc_list);
2139
2140 table = xfrm_policy_bydst[dir].table;
2141 for (i = xfrm_policy_bydst[dir].hmask; i >= 0; i--) {
2142 hlist_for_each_entry(pol, entry, table + i, bydst)
2143 prune_one_bundle(pol, func, &gc_list);
2144 }
2145 }
2146 read_unlock_bh(&xfrm_policy_lock);
2147
2148 while (gc_list) {
2149 struct dst_entry *dst = gc_list;
2150 gc_list = dst->next;
2151 dst_free(dst);
2152 }
2153 }
2154
2155 static int unused_bundle(struct dst_entry *dst)
2156 {
2157 return !atomic_read(&dst->__refcnt);
2158 }
2159
2160 static void __xfrm_garbage_collect(void)
2161 {
2162 xfrm_prune_bundles(unused_bundle);
2163 }
2164
2165 static int xfrm_flush_bundles(void)
2166 {
2167 xfrm_prune_bundles(stale_bundle);
2168 return 0;
2169 }
2170
2171 static void xfrm_init_pmtu(struct dst_entry *dst)
2172 {
2173 do {
2174 struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
2175 u32 pmtu, route_mtu_cached;
2176
2177 pmtu = dst_mtu(dst->child);
2178 xdst->child_mtu_cached = pmtu;
2179
2180 pmtu = xfrm_state_mtu(dst->xfrm, pmtu);
2181
2182 route_mtu_cached = dst_mtu(xdst->route);
2183 xdst->route_mtu_cached = route_mtu_cached;
2184
2185 if (pmtu > route_mtu_cached)
2186 pmtu = route_mtu_cached;
2187
2188 dst->metrics[RTAX_MTU-1] = pmtu;
2189 } while ((dst = dst->next));
2190 }
2191
2192 /* Check that the bundle accepts the flow and its components are
2193 * still valid.
2194 */
2195
2196 int xfrm_bundle_ok(struct xfrm_policy *pol, struct xfrm_dst *first,
2197 struct flowi *fl, int family, int strict)
2198 {
2199 struct dst_entry *dst = &first->u.dst;
2200 struct xfrm_dst *last;
2201 u32 mtu;
2202
2203 if (!dst_check(dst->path, ((struct xfrm_dst *)dst)->path_cookie) ||
2204 (dst->dev && !netif_running(dst->dev)))
2205 return 0;
2206 #ifdef CONFIG_XFRM_SUB_POLICY
2207 if (fl) {
2208 if (first->origin && !flow_cache_uli_match(first->origin, fl))
2209 return 0;
2210 if (first->partner &&
2211 !xfrm_selector_match(first->partner, fl, family))
2212 return 0;
2213 }
2214 #endif
2215
2216 last = NULL;
2217
2218 do {
2219 struct xfrm_dst *xdst = (struct xfrm_dst *)dst;
2220
2221 if (fl && !xfrm_selector_match(&dst->xfrm->sel, fl, family))
2222 return 0;
2223 if (fl && pol &&
2224 !security_xfrm_state_pol_flow_match(dst->xfrm, pol, fl))
2225 return 0;
2226 if (dst->xfrm->km.state != XFRM_STATE_VALID)
2227 return 0;
2228 if (xdst->genid != dst->xfrm->genid)
2229 return 0;
2230
2231 if (strict && fl &&
2232 !(dst->xfrm->outer_mode->flags & XFRM_MODE_FLAG_TUNNEL) &&
2233 !xfrm_state_addr_flow_check(dst->xfrm, fl, family))
2234 return 0;
2235
2236 mtu = dst_mtu(dst->child);
2237 if (xdst->child_mtu_cached != mtu) {
2238 last = xdst;
2239 xdst->child_mtu_cached = mtu;
2240 }
2241
2242 if (!dst_check(xdst->route, xdst->route_cookie))
2243 return 0;
2244 mtu = dst_mtu(xdst->route);
2245 if (xdst->route_mtu_cached != mtu) {
2246 last = xdst;
2247 xdst->route_mtu_cached = mtu;
2248 }
2249
2250 dst = dst->child;
2251 } while (dst->xfrm);
2252
2253 if (likely(!last))
2254 return 1;
2255
2256 mtu = last->child_mtu_cached;
2257 for (;;) {
2258 dst = &last->u.dst;
2259
2260 mtu = xfrm_state_mtu(dst->xfrm, mtu);
2261 if (mtu > last->route_mtu_cached)
2262 mtu = last->route_mtu_cached;
2263 dst->metrics[RTAX_MTU-1] = mtu;
2264
2265 if (last == first)
2266 break;
2267
2268 last = (struct xfrm_dst *)last->u.dst.next;
2269 last->child_mtu_cached = mtu;
2270 }
2271
2272 return 1;
2273 }
2274
2275 EXPORT_SYMBOL(xfrm_bundle_ok);
2276
2277 int xfrm_policy_register_afinfo(struct xfrm_policy_afinfo *afinfo)
2278 {
2279 int err = 0;
2280 if (unlikely(afinfo == NULL))
2281 return -EINVAL;
2282 if (unlikely(afinfo->family >= NPROTO))
2283 return -EAFNOSUPPORT;
2284 write_lock_bh(&xfrm_policy_afinfo_lock);
2285 if (unlikely(xfrm_policy_afinfo[afinfo->family] != NULL))
2286 err = -ENOBUFS;
2287 else {
2288 struct dst_ops *dst_ops = afinfo->dst_ops;
2289 if (likely(dst_ops->kmem_cachep == NULL))
2290 dst_ops->kmem_cachep = xfrm_dst_cache;
2291 if (likely(dst_ops->check == NULL))
2292 dst_ops->check = xfrm_dst_check;
2293 if (likely(dst_ops->negative_advice == NULL))
2294 dst_ops->negative_advice = xfrm_negative_advice;
2295 if (likely(dst_ops->link_failure == NULL))
2296 dst_ops->link_failure = xfrm_link_failure;
2297 if (likely(afinfo->garbage_collect == NULL))
2298 afinfo->garbage_collect = __xfrm_garbage_collect;
2299 xfrm_policy_afinfo[afinfo->family] = afinfo;
2300 }
2301 write_unlock_bh(&xfrm_policy_afinfo_lock);
2302 return err;
2303 }
2304 EXPORT_SYMBOL(xfrm_policy_register_afinfo);
2305
2306 int xfrm_policy_unregister_afinfo(struct xfrm_policy_afinfo *afinfo)
2307 {
2308 int err = 0;
2309 if (unlikely(afinfo == NULL))
2310 return -EINVAL;
2311 if (unlikely(afinfo->family >= NPROTO))
2312 return -EAFNOSUPPORT;
2313 write_lock_bh(&xfrm_policy_afinfo_lock);
2314 if (likely(xfrm_policy_afinfo[afinfo->family] != NULL)) {
2315 if (unlikely(xfrm_policy_afinfo[afinfo->family] != afinfo))
2316 err = -EINVAL;
2317 else {
2318 struct dst_ops *dst_ops = afinfo->dst_ops;
2319 xfrm_policy_afinfo[afinfo->family] = NULL;
2320 dst_ops->kmem_cachep = NULL;
2321 dst_ops->check = NULL;
2322 dst_ops->negative_advice = NULL;
2323 dst_ops->link_failure = NULL;
2324 afinfo->garbage_collect = NULL;
2325 }
2326 }
2327 write_unlock_bh(&xfrm_policy_afinfo_lock);
2328 return err;
2329 }
2330 EXPORT_SYMBOL(xfrm_policy_unregister_afinfo);
2331
2332 static struct xfrm_policy_afinfo *xfrm_policy_get_afinfo(unsigned short family)
2333 {
2334 struct xfrm_policy_afinfo *afinfo;
2335 if (unlikely(family >= NPROTO))
2336 return NULL;
2337 read_lock(&xfrm_policy_afinfo_lock);
2338 afinfo = xfrm_policy_afinfo[family];
2339 if (unlikely(!afinfo))
2340 read_unlock(&xfrm_policy_afinfo_lock);
2341 return afinfo;
2342 }
2343
2344 static void xfrm_policy_put_afinfo(struct xfrm_policy_afinfo *afinfo)
2345 {
2346 read_unlock(&xfrm_policy_afinfo_lock);
2347 }
2348
2349 static int xfrm_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
2350 {
2351 struct net_device *dev = ptr;
2352
2353 if (dev->nd_net != &init_net)
2354 return NOTIFY_DONE;
2355
2356 switch (event) {
2357 case NETDEV_DOWN:
2358 xfrm_flush_bundles();
2359 }
2360 return NOTIFY_DONE;
2361 }
2362
2363 static struct notifier_block xfrm_dev_notifier = {
2364 xfrm_dev_event,
2365 NULL,
2366 0
2367 };
2368
2369 #ifdef CONFIG_XFRM_STATISTICS
2370 static int __init xfrm_statistics_init(void)
2371 {
2372 if (snmp_mib_init((void **)xfrm_statistics,
2373 sizeof(struct linux_xfrm_mib)) < 0)
2374 return -ENOMEM;
2375 return 0;
2376 }
2377 #endif
2378
2379 static void __init xfrm_policy_init(void)
2380 {
2381 unsigned int hmask, sz;
2382 int dir;
2383
2384 xfrm_dst_cache = kmem_cache_create("xfrm_dst_cache",
2385 sizeof(struct xfrm_dst),
2386 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
2387 NULL);
2388
2389 hmask = 8 - 1;
2390 sz = (hmask+1) * sizeof(struct hlist_head);
2391
2392 xfrm_policy_byidx = xfrm_hash_alloc(sz);
2393 xfrm_idx_hmask = hmask;
2394 if (!xfrm_policy_byidx)
2395 panic("XFRM: failed to allocate byidx hash\n");
2396
2397 for (dir = 0; dir < XFRM_POLICY_MAX * 2; dir++) {
2398 struct xfrm_policy_hash *htab;
2399
2400 INIT_HLIST_HEAD(&xfrm_policy_inexact[dir]);
2401
2402 htab = &xfrm_policy_bydst[dir];
2403 htab->table = xfrm_hash_alloc(sz);
2404 htab->hmask = hmask;
2405 if (!htab->table)
2406 panic("XFRM: failed to allocate bydst hash\n");
2407 }
2408
2409 for (dir = 0; dir < XFRM_POLICY_TYPE_MAX; dir++)
2410 INIT_LIST_HEAD(&xfrm_policy_bytype[dir]);
2411
2412 INIT_WORK(&xfrm_policy_gc_work, xfrm_policy_gc_task);
2413 register_netdevice_notifier(&xfrm_dev_notifier);
2414 }
2415
2416 void __init xfrm_init(void)
2417 {
2418 #ifdef CONFIG_XFRM_STATISTICS
2419 xfrm_statistics_init();
2420 #endif
2421 xfrm_state_init();
2422 xfrm_policy_init();
2423 xfrm_input_init();
2424 #ifdef CONFIG_XFRM_STATISTICS
2425 xfrm_proc_init();
2426 #endif
2427 }
2428
2429 #ifdef CONFIG_AUDITSYSCALL
2430 static void xfrm_audit_common_policyinfo(struct xfrm_policy *xp,
2431 struct audit_buffer *audit_buf)
2432 {
2433 struct xfrm_sec_ctx *ctx = xp->security;
2434 struct xfrm_selector *sel = &xp->selector;
2435
2436 if (ctx)
2437 audit_log_format(audit_buf, " sec_alg=%u sec_doi=%u sec_obj=%s",
2438 ctx->ctx_alg, ctx->ctx_doi, ctx->ctx_str);
2439
2440 switch(sel->family) {
2441 case AF_INET:
2442 audit_log_format(audit_buf, " src=" NIPQUAD_FMT,
2443 NIPQUAD(sel->saddr.a4));
2444 if (sel->prefixlen_s != 32)
2445 audit_log_format(audit_buf, " src_prefixlen=%d",
2446 sel->prefixlen_s);
2447 audit_log_format(audit_buf, " dst=" NIPQUAD_FMT,
2448 NIPQUAD(sel->daddr.a4));
2449 if (sel->prefixlen_d != 32)
2450 audit_log_format(audit_buf, " dst_prefixlen=%d",
2451 sel->prefixlen_d);
2452 break;
2453 case AF_INET6:
2454 audit_log_format(audit_buf, " src=" NIP6_FMT,
2455 NIP6(*(struct in6_addr *)sel->saddr.a6));
2456 if (sel->prefixlen_s != 128)
2457 audit_log_format(audit_buf, " src_prefixlen=%d",
2458 sel->prefixlen_s);
2459 audit_log_format(audit_buf, " dst=" NIP6_FMT,
2460 NIP6(*(struct in6_addr *)sel->daddr.a6));
2461 if (sel->prefixlen_d != 128)
2462 audit_log_format(audit_buf, " dst_prefixlen=%d",
2463 sel->prefixlen_d);
2464 break;
2465 }
2466 }
2467
2468 void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
2469 u32 auid, u32 secid)
2470 {
2471 struct audit_buffer *audit_buf;
2472
2473 audit_buf = xfrm_audit_start("SPD-add");
2474 if (audit_buf == NULL)
2475 return;
2476 xfrm_audit_helper_usrinfo(auid, secid, audit_buf);
2477 audit_log_format(audit_buf, " res=%u", result);
2478 xfrm_audit_common_policyinfo(xp, audit_buf);
2479 audit_log_end(audit_buf);
2480 }
2481 EXPORT_SYMBOL_GPL(xfrm_audit_policy_add);
2482
2483 void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
2484 u32 auid, u32 secid)
2485 {
2486 struct audit_buffer *audit_buf;
2487
2488 audit_buf = xfrm_audit_start("SPD-delete");
2489 if (audit_buf == NULL)
2490 return;
2491 xfrm_audit_helper_usrinfo(auid, secid, audit_buf);
2492 audit_log_format(audit_buf, " res=%u", result);
2493 xfrm_audit_common_policyinfo(xp, audit_buf);
2494 audit_log_end(audit_buf);
2495 }
2496 EXPORT_SYMBOL_GPL(xfrm_audit_policy_delete);
2497 #endif
2498
2499 #ifdef CONFIG_XFRM_MIGRATE
2500 static int xfrm_migrate_selector_match(struct xfrm_selector *sel_cmp,
2501 struct xfrm_selector *sel_tgt)
2502 {
2503 if (sel_cmp->proto == IPSEC_ULPROTO_ANY) {
2504 if (sel_tgt->family == sel_cmp->family &&
2505 xfrm_addr_cmp(&sel_tgt->daddr, &sel_cmp->daddr,
2506 sel_cmp->family) == 0 &&
2507 xfrm_addr_cmp(&sel_tgt->saddr, &sel_cmp->saddr,
2508 sel_cmp->family) == 0 &&
2509 sel_tgt->prefixlen_d == sel_cmp->prefixlen_d &&
2510 sel_tgt->prefixlen_s == sel_cmp->prefixlen_s) {
2511 return 1;
2512 }
2513 } else {
2514 if (memcmp(sel_tgt, sel_cmp, sizeof(*sel_tgt)) == 0) {
2515 return 1;
2516 }
2517 }
2518 return 0;
2519 }
2520
2521 static struct xfrm_policy * xfrm_migrate_policy_find(struct xfrm_selector *sel,
2522 u8 dir, u8 type)
2523 {
2524 struct xfrm_policy *pol, *ret = NULL;
2525 struct hlist_node *entry;
2526 struct hlist_head *chain;
2527 u32 priority = ~0U;
2528
2529 read_lock_bh(&xfrm_policy_lock);
2530 chain = policy_hash_direct(&sel->daddr, &sel->saddr, sel->family, dir);
2531 hlist_for_each_entry(pol, entry, chain, bydst) {
2532 if (xfrm_migrate_selector_match(sel, &pol->selector) &&
2533 pol->type == type) {
2534 ret = pol;
2535 priority = ret->priority;
2536 break;
2537 }
2538 }
2539 chain = &xfrm_policy_inexact[dir];
2540 hlist_for_each_entry(pol, entry, chain, bydst) {
2541 if (xfrm_migrate_selector_match(sel, &pol->selector) &&
2542 pol->type == type &&
2543 pol->priority < priority) {
2544 ret = pol;
2545 break;
2546 }
2547 }
2548
2549 if (ret)
2550 xfrm_pol_hold(ret);
2551
2552 read_unlock_bh(&xfrm_policy_lock);
2553
2554 return ret;
2555 }
2556
2557 static int migrate_tmpl_match(struct xfrm_migrate *m, struct xfrm_tmpl *t)
2558 {
2559 int match = 0;
2560
2561 if (t->mode == m->mode && t->id.proto == m->proto &&
2562 (m->reqid == 0 || t->reqid == m->reqid)) {
2563 switch (t->mode) {
2564 case XFRM_MODE_TUNNEL:
2565 case XFRM_MODE_BEET:
2566 if (xfrm_addr_cmp(&t->id.daddr, &m->old_daddr,
2567 m->old_family) == 0 &&
2568 xfrm_addr_cmp(&t->saddr, &m->old_saddr,
2569 m->old_family) == 0) {
2570 match = 1;
2571 }
2572 break;
2573 case XFRM_MODE_TRANSPORT:
2574 /* in case of transport mode, template does not store
2575 any IP addresses, hence we just compare mode and
2576 protocol */
2577 match = 1;
2578 break;
2579 default:
2580 break;
2581 }
2582 }
2583 return match;
2584 }
2585
2586 /* update endpoint address(es) of template(s) */
2587 static int xfrm_policy_migrate(struct xfrm_policy *pol,
2588 struct xfrm_migrate *m, int num_migrate)
2589 {
2590 struct xfrm_migrate *mp;
2591 struct dst_entry *dst;
2592 int i, j, n = 0;
2593
2594 write_lock_bh(&pol->lock);
2595 if (unlikely(pol->dead)) {
2596 /* target policy has been deleted */
2597 write_unlock_bh(&pol->lock);
2598 return -ENOENT;
2599 }
2600
2601 for (i = 0; i < pol->xfrm_nr; i++) {
2602 for (j = 0, mp = m; j < num_migrate; j++, mp++) {
2603 if (!migrate_tmpl_match(mp, &pol->xfrm_vec[i]))
2604 continue;
2605 n++;
2606 if (pol->xfrm_vec[i].mode != XFRM_MODE_TUNNEL &&
2607 pol->xfrm_vec[i].mode != XFRM_MODE_BEET)
2608 continue;
2609 /* update endpoints */
2610 memcpy(&pol->xfrm_vec[i].id.daddr, &mp->new_daddr,
2611 sizeof(pol->xfrm_vec[i].id.daddr));
2612 memcpy(&pol->xfrm_vec[i].saddr, &mp->new_saddr,
2613 sizeof(pol->xfrm_vec[i].saddr));
2614 pol->xfrm_vec[i].encap_family = mp->new_family;
2615 /* flush bundles */
2616 while ((dst = pol->bundles) != NULL) {
2617 pol->bundles = dst->next;
2618 dst_free(dst);
2619 }
2620 }
2621 }
2622
2623 write_unlock_bh(&pol->lock);
2624
2625 if (!n)
2626 return -ENODATA;
2627
2628 return 0;
2629 }
2630
2631 static int xfrm_migrate_check(struct xfrm_migrate *m, int num_migrate)
2632 {
2633 int i, j;
2634
2635 if (num_migrate < 1 || num_migrate > XFRM_MAX_DEPTH)
2636 return -EINVAL;
2637
2638 for (i = 0; i < num_migrate; i++) {
2639 if ((xfrm_addr_cmp(&m[i].old_daddr, &m[i].new_daddr,
2640 m[i].old_family) == 0) &&
2641 (xfrm_addr_cmp(&m[i].old_saddr, &m[i].new_saddr,
2642 m[i].old_family) == 0))
2643 return -EINVAL;
2644 if (xfrm_addr_any(&m[i].new_daddr, m[i].new_family) ||
2645 xfrm_addr_any(&m[i].new_saddr, m[i].new_family))
2646 return -EINVAL;
2647
2648 /* check if there is any duplicated entry */
2649 for (j = i + 1; j < num_migrate; j++) {
2650 if (!memcmp(&m[i].old_daddr, &m[j].old_daddr,
2651 sizeof(m[i].old_daddr)) &&
2652 !memcmp(&m[i].old_saddr, &m[j].old_saddr,
2653 sizeof(m[i].old_saddr)) &&
2654 m[i].proto == m[j].proto &&
2655 m[i].mode == m[j].mode &&
2656 m[i].reqid == m[j].reqid &&
2657 m[i].old_family == m[j].old_family)
2658 return -EINVAL;
2659 }
2660 }
2661
2662 return 0;
2663 }
2664
2665 int xfrm_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
2666 struct xfrm_migrate *m, int num_migrate)
2667 {
2668 int i, err, nx_cur = 0, nx_new = 0;
2669 struct xfrm_policy *pol = NULL;
2670 struct xfrm_state *x, *xc;
2671 struct xfrm_state *x_cur[XFRM_MAX_DEPTH];
2672 struct xfrm_state *x_new[XFRM_MAX_DEPTH];
2673 struct xfrm_migrate *mp;
2674
2675 if ((err = xfrm_migrate_check(m, num_migrate)) < 0)
2676 goto out;
2677
2678 /* Stage 1 - find policy */
2679 if ((pol = xfrm_migrate_policy_find(sel, dir, type)) == NULL) {
2680 err = -ENOENT;
2681 goto out;
2682 }
2683
2684 /* Stage 2 - find and update state(s) */
2685 for (i = 0, mp = m; i < num_migrate; i++, mp++) {
2686 if ((x = xfrm_migrate_state_find(mp))) {
2687 x_cur[nx_cur] = x;
2688 nx_cur++;
2689 if ((xc = xfrm_state_migrate(x, mp))) {
2690 x_new[nx_new] = xc;
2691 nx_new++;
2692 } else {
2693 err = -ENODATA;
2694 goto restore_state;
2695 }
2696 }
2697 }
2698
2699 /* Stage 3 - update policy */
2700 if ((err = xfrm_policy_migrate(pol, m, num_migrate)) < 0)
2701 goto restore_state;
2702
2703 /* Stage 4 - delete old state(s) */
2704 if (nx_cur) {
2705 xfrm_states_put(x_cur, nx_cur);
2706 xfrm_states_delete(x_cur, nx_cur);
2707 }
2708
2709 /* Stage 5 - announce */
2710 km_migrate(sel, dir, type, m, num_migrate);
2711
2712 xfrm_pol_put(pol);
2713
2714 return 0;
2715 out:
2716 return err;
2717
2718 restore_state:
2719 if (pol)
2720 xfrm_pol_put(pol);
2721 if (nx_cur)
2722 xfrm_states_put(x_cur, nx_cur);
2723 if (nx_new)
2724 xfrm_states_delete(x_new, nx_new);
2725
2726 return err;
2727 }
2728 EXPORT_SYMBOL(xfrm_migrate);
2729 #endif
Support for the Chinese Samsung S3C2440 based development boards