Merge tag 'acpi-5.1-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael...
[sfrench/cifs-2.6.git] / net / xfrm / xfrm_replay.c
1 /*
2  * xfrm_replay.c - xfrm replay detection, derived from xfrm_state.c.
3  *
4  * Copyright (C) 2010 secunet Security Networks AG
5  * Copyright (C) 2010 Steffen Klassert <steffen.klassert@secunet.com>
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms and conditions of the GNU General Public License,
9  * version 2, as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along with
17  * this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
19  */
20
21 #include <linux/export.h>
22 #include <net/xfrm.h>
23
24 u32 xfrm_replay_seqhi(struct xfrm_state *x, __be32 net_seq)
25 {
26         u32 seq, seq_hi, bottom;
27         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
28
29         if (!(x->props.flags & XFRM_STATE_ESN))
30                 return 0;
31
32         seq = ntohl(net_seq);
33         seq_hi = replay_esn->seq_hi;
34         bottom = replay_esn->seq - replay_esn->replay_window + 1;
35
36         if (likely(replay_esn->seq >= replay_esn->replay_window - 1)) {
37                 /* A. same subspace */
38                 if (unlikely(seq < bottom))
39                         seq_hi++;
40         } else {
41                 /* B. window spans two subspaces */
42                 if (unlikely(seq >= bottom))
43                         seq_hi--;
44         }
45
46         return seq_hi;
47 }
48 EXPORT_SYMBOL(xfrm_replay_seqhi);
49 ;
50 static void xfrm_replay_notify(struct xfrm_state *x, int event)
51 {
52         struct km_event c;
53         /* we send notify messages in case
54          *  1. we updated on of the sequence numbers, and the seqno difference
55          *     is at least x->replay_maxdiff, in this case we also update the
56          *     timeout of our timer function
57          *  2. if x->replay_maxage has elapsed since last update,
58          *     and there were changes
59          *
60          *  The state structure must be locked!
61          */
62
63         switch (event) {
64         case XFRM_REPLAY_UPDATE:
65                 if (!x->replay_maxdiff ||
66                     ((x->replay.seq - x->preplay.seq < x->replay_maxdiff) &&
67                     (x->replay.oseq - x->preplay.oseq < x->replay_maxdiff))) {
68                         if (x->xflags & XFRM_TIME_DEFER)
69                                 event = XFRM_REPLAY_TIMEOUT;
70                         else
71                                 return;
72                 }
73
74                 break;
75
76         case XFRM_REPLAY_TIMEOUT:
77                 if (memcmp(&x->replay, &x->preplay,
78                            sizeof(struct xfrm_replay_state)) == 0) {
79                         x->xflags |= XFRM_TIME_DEFER;
80                         return;
81                 }
82
83                 break;
84         }
85
86         memcpy(&x->preplay, &x->replay, sizeof(struct xfrm_replay_state));
87         c.event = XFRM_MSG_NEWAE;
88         c.data.aevent = event;
89         km_state_notify(x, &c);
90
91         if (x->replay_maxage &&
92             !mod_timer(&x->rtimer, jiffies + x->replay_maxage))
93                 x->xflags &= ~XFRM_TIME_DEFER;
94 }
95
96 static int xfrm_replay_overflow(struct xfrm_state *x, struct sk_buff *skb)
97 {
98         int err = 0;
99         struct net *net = xs_net(x);
100
101         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
102                 XFRM_SKB_CB(skb)->seq.output.low = ++x->replay.oseq;
103                 XFRM_SKB_CB(skb)->seq.output.hi = 0;
104                 if (unlikely(x->replay.oseq == 0)) {
105                         x->replay.oseq--;
106                         xfrm_audit_state_replay_overflow(x, skb);
107                         err = -EOVERFLOW;
108
109                         return err;
110                 }
111                 if (xfrm_aevent_is_on(net))
112                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
113         }
114
115         return err;
116 }
117
118 static int xfrm_replay_check(struct xfrm_state *x,
119                       struct sk_buff *skb, __be32 net_seq)
120 {
121         u32 diff;
122         u32 seq = ntohl(net_seq);
123
124         if (!x->props.replay_window)
125                 return 0;
126
127         if (unlikely(seq == 0))
128                 goto err;
129
130         if (likely(seq > x->replay.seq))
131                 return 0;
132
133         diff = x->replay.seq - seq;
134         if (diff >= x->props.replay_window) {
135                 x->stats.replay_window++;
136                 goto err;
137         }
138
139         if (x->replay.bitmap & (1U << diff)) {
140                 x->stats.replay++;
141                 goto err;
142         }
143         return 0;
144
145 err:
146         xfrm_audit_state_replay(x, skb, net_seq);
147         return -EINVAL;
148 }
149
150 static void xfrm_replay_advance(struct xfrm_state *x, __be32 net_seq)
151 {
152         u32 diff;
153         u32 seq = ntohl(net_seq);
154
155         if (!x->props.replay_window)
156                 return;
157
158         if (seq > x->replay.seq) {
159                 diff = seq - x->replay.seq;
160                 if (diff < x->props.replay_window)
161                         x->replay.bitmap = ((x->replay.bitmap) << diff) | 1;
162                 else
163                         x->replay.bitmap = 1;
164                 x->replay.seq = seq;
165         } else {
166                 diff = x->replay.seq - seq;
167                 x->replay.bitmap |= (1U << diff);
168         }
169
170         if (xfrm_aevent_is_on(xs_net(x)))
171                 x->repl->notify(x, XFRM_REPLAY_UPDATE);
172 }
173
174 static int xfrm_replay_overflow_bmp(struct xfrm_state *x, struct sk_buff *skb)
175 {
176         int err = 0;
177         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
178         struct net *net = xs_net(x);
179
180         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
181                 XFRM_SKB_CB(skb)->seq.output.low = ++replay_esn->oseq;
182                 XFRM_SKB_CB(skb)->seq.output.hi = 0;
183                 if (unlikely(replay_esn->oseq == 0)) {
184                         replay_esn->oseq--;
185                         xfrm_audit_state_replay_overflow(x, skb);
186                         err = -EOVERFLOW;
187
188                         return err;
189                 }
190                 if (xfrm_aevent_is_on(net))
191                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
192         }
193
194         return err;
195 }
196
197 static int xfrm_replay_check_bmp(struct xfrm_state *x,
198                                  struct sk_buff *skb, __be32 net_seq)
199 {
200         unsigned int bitnr, nr;
201         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
202         u32 pos;
203         u32 seq = ntohl(net_seq);
204         u32 diff =  replay_esn->seq - seq;
205
206         if (!replay_esn->replay_window)
207                 return 0;
208
209         if (unlikely(seq == 0))
210                 goto err;
211
212         if (likely(seq > replay_esn->seq))
213                 return 0;
214
215         if (diff >= replay_esn->replay_window) {
216                 x->stats.replay_window++;
217                 goto err;
218         }
219
220         pos = (replay_esn->seq - 1) % replay_esn->replay_window;
221
222         if (pos >= diff)
223                 bitnr = (pos - diff) % replay_esn->replay_window;
224         else
225                 bitnr = replay_esn->replay_window - (diff - pos);
226
227         nr = bitnr >> 5;
228         bitnr = bitnr & 0x1F;
229         if (replay_esn->bmp[nr] & (1U << bitnr))
230                 goto err_replay;
231
232         return 0;
233
234 err_replay:
235         x->stats.replay++;
236 err:
237         xfrm_audit_state_replay(x, skb, net_seq);
238         return -EINVAL;
239 }
240
241 static void xfrm_replay_advance_bmp(struct xfrm_state *x, __be32 net_seq)
242 {
243         unsigned int bitnr, nr, i;
244         u32 diff;
245         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
246         u32 seq = ntohl(net_seq);
247         u32 pos;
248
249         if (!replay_esn->replay_window)
250                 return;
251
252         pos = (replay_esn->seq - 1) % replay_esn->replay_window;
253
254         if (seq > replay_esn->seq) {
255                 diff = seq - replay_esn->seq;
256
257                 if (diff < replay_esn->replay_window) {
258                         for (i = 1; i < diff; i++) {
259                                 bitnr = (pos + i) % replay_esn->replay_window;
260                                 nr = bitnr >> 5;
261                                 bitnr = bitnr & 0x1F;
262                                 replay_esn->bmp[nr] &=  ~(1U << bitnr);
263                         }
264                 } else {
265                         nr = (replay_esn->replay_window - 1) >> 5;
266                         for (i = 0; i <= nr; i++)
267                                 replay_esn->bmp[i] = 0;
268                 }
269
270                 bitnr = (pos + diff) % replay_esn->replay_window;
271                 replay_esn->seq = seq;
272         } else {
273                 diff = replay_esn->seq - seq;
274
275                 if (pos >= diff)
276                         bitnr = (pos - diff) % replay_esn->replay_window;
277                 else
278                         bitnr = replay_esn->replay_window - (diff - pos);
279         }
280
281         nr = bitnr >> 5;
282         bitnr = bitnr & 0x1F;
283         replay_esn->bmp[nr] |= (1U << bitnr);
284
285         if (xfrm_aevent_is_on(xs_net(x)))
286                 x->repl->notify(x, XFRM_REPLAY_UPDATE);
287 }
288
289 static void xfrm_replay_notify_bmp(struct xfrm_state *x, int event)
290 {
291         struct km_event c;
292         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
293         struct xfrm_replay_state_esn *preplay_esn = x->preplay_esn;
294
295         /* we send notify messages in case
296          *  1. we updated on of the sequence numbers, and the seqno difference
297          *     is at least x->replay_maxdiff, in this case we also update the
298          *     timeout of our timer function
299          *  2. if x->replay_maxage has elapsed since last update,
300          *     and there were changes
301          *
302          *  The state structure must be locked!
303          */
304
305         switch (event) {
306         case XFRM_REPLAY_UPDATE:
307                 if (!x->replay_maxdiff ||
308                     ((replay_esn->seq - preplay_esn->seq < x->replay_maxdiff) &&
309                     (replay_esn->oseq - preplay_esn->oseq
310                      < x->replay_maxdiff))) {
311                         if (x->xflags & XFRM_TIME_DEFER)
312                                 event = XFRM_REPLAY_TIMEOUT;
313                         else
314                                 return;
315                 }
316
317                 break;
318
319         case XFRM_REPLAY_TIMEOUT:
320                 if (memcmp(x->replay_esn, x->preplay_esn,
321                            xfrm_replay_state_esn_len(replay_esn)) == 0) {
322                         x->xflags |= XFRM_TIME_DEFER;
323                         return;
324                 }
325
326                 break;
327         }
328
329         memcpy(x->preplay_esn, x->replay_esn,
330                xfrm_replay_state_esn_len(replay_esn));
331         c.event = XFRM_MSG_NEWAE;
332         c.data.aevent = event;
333         km_state_notify(x, &c);
334
335         if (x->replay_maxage &&
336             !mod_timer(&x->rtimer, jiffies + x->replay_maxage))
337                 x->xflags &= ~XFRM_TIME_DEFER;
338 }
339
340 static void xfrm_replay_notify_esn(struct xfrm_state *x, int event)
341 {
342         u32 seq_diff, oseq_diff;
343         struct km_event c;
344         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
345         struct xfrm_replay_state_esn *preplay_esn = x->preplay_esn;
346
347         /* we send notify messages in case
348          *  1. we updated on of the sequence numbers, and the seqno difference
349          *     is at least x->replay_maxdiff, in this case we also update the
350          *     timeout of our timer function
351          *  2. if x->replay_maxage has elapsed since last update,
352          *     and there were changes
353          *
354          *  The state structure must be locked!
355          */
356
357         switch (event) {
358         case XFRM_REPLAY_UPDATE:
359                 if (x->replay_maxdiff) {
360                         if (replay_esn->seq_hi == preplay_esn->seq_hi)
361                                 seq_diff = replay_esn->seq - preplay_esn->seq;
362                         else
363                                 seq_diff = ~preplay_esn->seq + replay_esn->seq
364                                            + 1;
365
366                         if (replay_esn->oseq_hi == preplay_esn->oseq_hi)
367                                 oseq_diff = replay_esn->oseq
368                                             - preplay_esn->oseq;
369                         else
370                                 oseq_diff = ~preplay_esn->oseq
371                                             + replay_esn->oseq + 1;
372
373                         if (seq_diff >= x->replay_maxdiff ||
374                             oseq_diff >= x->replay_maxdiff)
375                                 break;
376                 }
377
378                 if (x->xflags & XFRM_TIME_DEFER)
379                         event = XFRM_REPLAY_TIMEOUT;
380                 else
381                         return;
382
383                 break;
384
385         case XFRM_REPLAY_TIMEOUT:
386                 if (memcmp(x->replay_esn, x->preplay_esn,
387                            xfrm_replay_state_esn_len(replay_esn)) == 0) {
388                         x->xflags |= XFRM_TIME_DEFER;
389                         return;
390                 }
391
392                 break;
393         }
394
395         memcpy(x->preplay_esn, x->replay_esn,
396                xfrm_replay_state_esn_len(replay_esn));
397         c.event = XFRM_MSG_NEWAE;
398         c.data.aevent = event;
399         km_state_notify(x, &c);
400
401         if (x->replay_maxage &&
402             !mod_timer(&x->rtimer, jiffies + x->replay_maxage))
403                 x->xflags &= ~XFRM_TIME_DEFER;
404 }
405
406 static int xfrm_replay_overflow_esn(struct xfrm_state *x, struct sk_buff *skb)
407 {
408         int err = 0;
409         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
410         struct net *net = xs_net(x);
411
412         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
413                 XFRM_SKB_CB(skb)->seq.output.low = ++replay_esn->oseq;
414                 XFRM_SKB_CB(skb)->seq.output.hi = replay_esn->oseq_hi;
415
416                 if (unlikely(replay_esn->oseq == 0)) {
417                         XFRM_SKB_CB(skb)->seq.output.hi = ++replay_esn->oseq_hi;
418
419                         if (replay_esn->oseq_hi == 0) {
420                                 replay_esn->oseq--;
421                                 replay_esn->oseq_hi--;
422                                 xfrm_audit_state_replay_overflow(x, skb);
423                                 err = -EOVERFLOW;
424
425                                 return err;
426                         }
427                 }
428                 if (xfrm_aevent_is_on(net))
429                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
430         }
431
432         return err;
433 }
434
435 static int xfrm_replay_check_esn(struct xfrm_state *x,
436                                  struct sk_buff *skb, __be32 net_seq)
437 {
438         unsigned int bitnr, nr;
439         u32 diff;
440         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
441         u32 pos;
442         u32 seq = ntohl(net_seq);
443         u32 wsize = replay_esn->replay_window;
444         u32 top = replay_esn->seq;
445         u32 bottom = top - wsize + 1;
446
447         if (!wsize)
448                 return 0;
449
450         if (unlikely(seq == 0 && replay_esn->seq_hi == 0 &&
451                      (replay_esn->seq < replay_esn->replay_window - 1)))
452                 goto err;
453
454         diff = top - seq;
455
456         if (likely(top >= wsize - 1)) {
457                 /* A. same subspace */
458                 if (likely(seq > top) || seq < bottom)
459                         return 0;
460         } else {
461                 /* B. window spans two subspaces */
462                 if (likely(seq > top && seq < bottom))
463                         return 0;
464                 if (seq >= bottom)
465                         diff = ~seq + top + 1;
466         }
467
468         if (diff >= replay_esn->replay_window) {
469                 x->stats.replay_window++;
470                 goto err;
471         }
472
473         pos = (replay_esn->seq - 1) % replay_esn->replay_window;
474
475         if (pos >= diff)
476                 bitnr = (pos - diff) % replay_esn->replay_window;
477         else
478                 bitnr = replay_esn->replay_window - (diff - pos);
479
480         nr = bitnr >> 5;
481         bitnr = bitnr & 0x1F;
482         if (replay_esn->bmp[nr] & (1U << bitnr))
483                 goto err_replay;
484
485         return 0;
486
487 err_replay:
488         x->stats.replay++;
489 err:
490         xfrm_audit_state_replay(x, skb, net_seq);
491         return -EINVAL;
492 }
493
494 static int xfrm_replay_recheck_esn(struct xfrm_state *x,
495                                    struct sk_buff *skb, __be32 net_seq)
496 {
497         if (unlikely(XFRM_SKB_CB(skb)->seq.input.hi !=
498                      htonl(xfrm_replay_seqhi(x, net_seq)))) {
499                         x->stats.replay_window++;
500                         return -EINVAL;
501         }
502
503         return xfrm_replay_check_esn(x, skb, net_seq);
504 }
505
506 static void xfrm_replay_advance_esn(struct xfrm_state *x, __be32 net_seq)
507 {
508         unsigned int bitnr, nr, i;
509         int wrap;
510         u32 diff, pos, seq, seq_hi;
511         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
512
513         if (!replay_esn->replay_window)
514                 return;
515
516         seq = ntohl(net_seq);
517         pos = (replay_esn->seq - 1) % replay_esn->replay_window;
518         seq_hi = xfrm_replay_seqhi(x, net_seq);
519         wrap = seq_hi - replay_esn->seq_hi;
520
521         if ((!wrap && seq > replay_esn->seq) || wrap > 0) {
522                 if (likely(!wrap))
523                         diff = seq - replay_esn->seq;
524                 else
525                         diff = ~replay_esn->seq + seq + 1;
526
527                 if (diff < replay_esn->replay_window) {
528                         for (i = 1; i < diff; i++) {
529                                 bitnr = (pos + i) % replay_esn->replay_window;
530                                 nr = bitnr >> 5;
531                                 bitnr = bitnr & 0x1F;
532                                 replay_esn->bmp[nr] &=  ~(1U << bitnr);
533                         }
534                 } else {
535                         nr = (replay_esn->replay_window - 1) >> 5;
536                         for (i = 0; i <= nr; i++)
537                                 replay_esn->bmp[i] = 0;
538                 }
539
540                 bitnr = (pos + diff) % replay_esn->replay_window;
541                 replay_esn->seq = seq;
542
543                 if (unlikely(wrap > 0))
544                         replay_esn->seq_hi++;
545         } else {
546                 diff = replay_esn->seq - seq;
547
548                 if (pos >= diff)
549                         bitnr = (pos - diff) % replay_esn->replay_window;
550                 else
551                         bitnr = replay_esn->replay_window - (diff - pos);
552         }
553
554         xfrm_dev_state_advance_esn(x);
555
556         nr = bitnr >> 5;
557         bitnr = bitnr & 0x1F;
558         replay_esn->bmp[nr] |= (1U << bitnr);
559
560         if (xfrm_aevent_is_on(xs_net(x)))
561                 x->repl->notify(x, XFRM_REPLAY_UPDATE);
562 }
563
564 #ifdef CONFIG_XFRM_OFFLOAD
565 static int xfrm_replay_overflow_offload(struct xfrm_state *x, struct sk_buff *skb)
566 {
567         int err = 0;
568         struct net *net = xs_net(x);
569         struct xfrm_offload *xo = xfrm_offload(skb);
570         __u32 oseq = x->replay.oseq;
571
572         if (!xo)
573                 return xfrm_replay_overflow(x, skb);
574
575         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
576                 if (!skb_is_gso(skb)) {
577                         XFRM_SKB_CB(skb)->seq.output.low = ++oseq;
578                         xo->seq.low = oseq;
579                 } else {
580                         XFRM_SKB_CB(skb)->seq.output.low = oseq + 1;
581                         xo->seq.low = oseq + 1;
582                         oseq += skb_shinfo(skb)->gso_segs;
583                 }
584
585                 XFRM_SKB_CB(skb)->seq.output.hi = 0;
586                 xo->seq.hi = 0;
587                 if (unlikely(oseq < x->replay.oseq)) {
588                         xfrm_audit_state_replay_overflow(x, skb);
589                         err = -EOVERFLOW;
590
591                         return err;
592                 }
593
594                 x->replay.oseq = oseq;
595
596                 if (xfrm_aevent_is_on(net))
597                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
598         }
599
600         return err;
601 }
602
603 static int xfrm_replay_overflow_offload_bmp(struct xfrm_state *x, struct sk_buff *skb)
604 {
605         int err = 0;
606         struct xfrm_offload *xo = xfrm_offload(skb);
607         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
608         struct net *net = xs_net(x);
609         __u32 oseq = replay_esn->oseq;
610
611         if (!xo)
612                 return xfrm_replay_overflow_bmp(x, skb);
613
614         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
615                 if (!skb_is_gso(skb)) {
616                         XFRM_SKB_CB(skb)->seq.output.low = ++oseq;
617                         xo->seq.low = oseq;
618                 } else {
619                         XFRM_SKB_CB(skb)->seq.output.low = oseq + 1;
620                         xo->seq.low = oseq + 1;
621                         oseq += skb_shinfo(skb)->gso_segs;
622                 }
623
624                 XFRM_SKB_CB(skb)->seq.output.hi = 0;
625                 xo->seq.hi = 0;
626                 if (unlikely(oseq < replay_esn->oseq)) {
627                         xfrm_audit_state_replay_overflow(x, skb);
628                         err = -EOVERFLOW;
629
630                         return err;
631                 } else {
632                         replay_esn->oseq = oseq;
633                 }
634
635                 if (xfrm_aevent_is_on(net))
636                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
637         }
638
639         return err;
640 }
641
642 static int xfrm_replay_overflow_offload_esn(struct xfrm_state *x, struct sk_buff *skb)
643 {
644         int err = 0;
645         struct xfrm_offload *xo = xfrm_offload(skb);
646         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
647         struct net *net = xs_net(x);
648         __u32 oseq = replay_esn->oseq;
649         __u32 oseq_hi = replay_esn->oseq_hi;
650
651         if (!xo)
652                 return xfrm_replay_overflow_esn(x, skb);
653
654         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
655                 if (!skb_is_gso(skb)) {
656                         XFRM_SKB_CB(skb)->seq.output.low = ++oseq;
657                         XFRM_SKB_CB(skb)->seq.output.hi = oseq_hi;
658                         xo->seq.low = oseq;
659                         xo->seq.hi = oseq_hi;
660                 } else {
661                         XFRM_SKB_CB(skb)->seq.output.low = oseq + 1;
662                         XFRM_SKB_CB(skb)->seq.output.hi = oseq_hi;
663                         xo->seq.low = oseq + 1;
664                         xo->seq.hi = oseq_hi;
665                         oseq += skb_shinfo(skb)->gso_segs;
666                 }
667
668                 if (unlikely(oseq < replay_esn->oseq)) {
669                         XFRM_SKB_CB(skb)->seq.output.hi = ++oseq_hi;
670                         xo->seq.hi = oseq_hi;
671                         replay_esn->oseq_hi = oseq_hi;
672                         if (replay_esn->oseq_hi == 0) {
673                                 replay_esn->oseq--;
674                                 replay_esn->oseq_hi--;
675                                 xfrm_audit_state_replay_overflow(x, skb);
676                                 err = -EOVERFLOW;
677
678                                 return err;
679                         }
680                 }
681
682                 replay_esn->oseq = oseq;
683
684                 if (xfrm_aevent_is_on(net))
685                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
686         }
687
688         return err;
689 }
690
691 static const struct xfrm_replay xfrm_replay_legacy = {
692         .advance        = xfrm_replay_advance,
693         .check          = xfrm_replay_check,
694         .recheck        = xfrm_replay_check,
695         .notify         = xfrm_replay_notify,
696         .overflow       = xfrm_replay_overflow_offload,
697 };
698
699 static const struct xfrm_replay xfrm_replay_bmp = {
700         .advance        = xfrm_replay_advance_bmp,
701         .check          = xfrm_replay_check_bmp,
702         .recheck        = xfrm_replay_check_bmp,
703         .notify         = xfrm_replay_notify_bmp,
704         .overflow       = xfrm_replay_overflow_offload_bmp,
705 };
706
707 static const struct xfrm_replay xfrm_replay_esn = {
708         .advance        = xfrm_replay_advance_esn,
709         .check          = xfrm_replay_check_esn,
710         .recheck        = xfrm_replay_recheck_esn,
711         .notify         = xfrm_replay_notify_esn,
712         .overflow       = xfrm_replay_overflow_offload_esn,
713 };
714 #else
715 static const struct xfrm_replay xfrm_replay_legacy = {
716         .advance        = xfrm_replay_advance,
717         .check          = xfrm_replay_check,
718         .recheck        = xfrm_replay_check,
719         .notify         = xfrm_replay_notify,
720         .overflow       = xfrm_replay_overflow,
721 };
722
723 static const struct xfrm_replay xfrm_replay_bmp = {
724         .advance        = xfrm_replay_advance_bmp,
725         .check          = xfrm_replay_check_bmp,
726         .recheck        = xfrm_replay_check_bmp,
727         .notify         = xfrm_replay_notify_bmp,
728         .overflow       = xfrm_replay_overflow_bmp,
729 };
730
731 static const struct xfrm_replay xfrm_replay_esn = {
732         .advance        = xfrm_replay_advance_esn,
733         .check          = xfrm_replay_check_esn,
734         .recheck        = xfrm_replay_recheck_esn,
735         .notify         = xfrm_replay_notify_esn,
736         .overflow       = xfrm_replay_overflow_esn,
737 };
738 #endif
739
740 int xfrm_init_replay(struct xfrm_state *x)
741 {
742         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
743
744         if (replay_esn) {
745                 if (replay_esn->replay_window >
746                     replay_esn->bmp_len * sizeof(__u32) * 8)
747                         return -EINVAL;
748
749                 if (x->props.flags & XFRM_STATE_ESN) {
750                         if (replay_esn->replay_window == 0)
751                                 return -EINVAL;
752                         x->repl = &xfrm_replay_esn;
753                 } else {
754                         x->repl = &xfrm_replay_bmp;
755                 }
756         } else {
757                 x->repl = &xfrm_replay_legacy;
758         }
759
760         return 0;
761 }
762 EXPORT_SYMBOL(xfrm_init_replay);