unbreak world: only include sys/thread2.h in kernel, not in userland
[dragonfly.git] / sys / contrib / ipfilter / netinet / ip_frag.c
1 /*
2  * Copyright (C) 1993-2001 by Darren Reed.
3  *
4  * See the IPFILTER.LICENCE file for details on licencing.
5  *
6  * @(#)ip_frag.c    1.11 3/24/96 (C) 1993-2000 Darren Reed
7  * @(#)$Id: ip_frag.c,v 2.10.2.24 2002/08/28 12:41:04 darrenr Exp $
8  * $FreeBSD: src/sys/contrib/ipfilter/netinet/ip_frag.c,v 1.15.2.7 2004/07/04 09:24:38 darrenr Exp $
9  * $DragonFly: src/sys/contrib/ipfilter/netinet/ip_frag.c,v 1.9 2005/06/05 12:17:46 corecode Exp $
10  */
11 #if defined(KERNEL) && !defined(_KERNEL)
12 # define      _KERNEL
13 #endif
14
15 #if defined(__sgi) && (IRIX > 602)
16 # include <sys/ptimers.h>
17 #endif
18 #include <sys/errno.h>
19 #include <sys/types.h>
20 #include <sys/param.h>
21 #include <sys/time.h>
22 #include <sys/file.h>
23 #if !defined(_KERNEL) && !defined(KERNEL)
24 # include <stdio.h>
25 # include <string.h>
26 # include <stdlib.h>
27 #endif
28 #if (defined(KERNEL) || defined(_KERNEL)) && (defined(__DragonFly__) || __FreeBSD_version >= 220000)
29 # include <sys/filio.h>
30 # include <sys/fcntl.h>
31 #else
32 # include <sys/ioctl.h>
33 #endif
34 #ifndef linux
35 # include <sys/protosw.h>
36 #endif
37 #include <sys/socket.h>
38 #if defined(_KERNEL) && !defined(linux)
39 # include <sys/systm.h>
40 #endif
41 #if !defined(__SVR4) && !defined(__svr4__)
42 # if defined(_KERNEL) && !defined(__sgi)
43 #  include <sys/kernel.h>
44 # endif
45 # ifndef linux
46 #  include <sys/mbuf.h>
47 # endif
48 #else
49 # include <sys/byteorder.h>
50 # ifdef _KERNEL
51 #  include <sys/dditypes.h>
52 # endif
53 # include <sys/stream.h>
54 # include <sys/kmem.h>
55 #endif
56 #if defined(__DragonFly__) && defined(_KERNEL)
57 # include <sys/thread2.h>
58 #endif
59 #include <net/if.h>
60 #ifdef sun
61 # include <net/af.h>
62 #endif
63 #include <net/route.h>
64 #include <netinet/in.h>
65 #include <netinet/in_systm.h>
66 #include <netinet/ip.h>
67 #ifndef linux
68 # include <netinet/ip_var.h>
69 #endif
70 #include <netinet/tcp.h>
71 #include <netinet/udp.h>
72 #include <netinet/ip_icmp.h>
73 #include "ip_compat.h"
74 #include <netinet/tcpip.h>
75 #include "ip_fil.h"
76 #include "ip_nat.h"
77 #include "ip_frag.h"
78 #include "ip_state.h"
79 #include "ip_auth.h"
80 #if defined(__DragonFly__) || __FreeBSD_version >= 300000
81 # include <sys/malloc.h>
82 # if (defined(KERNEL) || defined(_KERNEL))
83 #  ifndef IPFILTER_LKM
84 #   include <sys/libkern.h>
85 #   include <sys/systm.h>
86 #  endif
87 extern struct callout ipfr_slowtimer_ch;
88 # endif
89 #endif
90 #if defined(__NetBSD__) && (__NetBSD_Version__ >= 104230000)
91 # include <sys/callout.h>
92 extern struct callout ipfr_slowtimer_ch;
93 #endif
94 #if defined(__OpenBSD__)
95 # include <sys/timeout.h>
96 extern struct timeout ipfr_slowtimer_ch;
97 #endif
98
99 static const char sccsid[] = "@(#)ip_frag.c    1.11 3/24/96 (C) 1993-2000 Darren Reed";
100
101 static ipfr_t   *ipfr_heads[IPFT_SIZE];
102 static ipfr_t   *ipfr_nattab[IPFT_SIZE];
103 static ipfrstat_t ipfr_stats;
104 static int      ipfr_inuse = 0;
105
106 int     fr_ipfrttl = 120;       /* 60 seconds */
107 int     fr_frag_lock = 0;
108
109 #ifdef _KERNEL
110 # if SOLARIS2 >= 7
111 extern  timeout_id_t    ipfr_timer_id;
112 # else
113 extern  int     ipfr_timer_id;
114 # endif
115 #endif
116 #if     (SOLARIS || defined(__sgi)) && defined(_KERNEL)
117 extern  KRWLOCK_T       ipf_frag, ipf_natfrag, ipf_nat, ipf_mutex;
118 # if    SOLARIS
119 extern  KRWLOCK_T       ipf_solaris;
120 # else
121 KRWLOCK_T       ipf_solaris;
122 # endif
123 extern  kmutex_t        ipf_rw;
124 #endif
125
126
127 static ipfr_t *ipfr_new (ip_t *, fr_info_t *, ipfr_t **);
128 static ipfr_t *ipfr_lookup (ip_t *, fr_info_t *, ipfr_t **);
129 static void ipfr_delete (ipfr_t *);
130
131
132 ipfrstat_t *ipfr_fragstats()
133 {
134         ipfr_stats.ifs_table = ipfr_heads;
135         ipfr_stats.ifs_nattab = ipfr_nattab;
136         ipfr_stats.ifs_inuse = ipfr_inuse;
137         return &ipfr_stats;
138 }
139
140
141 /*
142  * add a new entry to the fragment cache, registering it as having come
143  * through this box, with the result of the filter operation.
144  */
145 static ipfr_t *ipfr_new(ip, fin, table)
146 ip_t *ip;
147 fr_info_t *fin;
148 ipfr_t *table[];
149 {
150         ipfr_t **fp, *fra, frag;
151         u_int idx, off;
152
153         if (ipfr_inuse >= IPFT_SIZE)
154                 return NULL;
155
156         if (!(fin->fin_fi.fi_fl & FI_FRAG))
157                 return NULL;
158
159         frag.ipfr_p = ip->ip_p;
160         idx = ip->ip_p;
161         frag.ipfr_id = ip->ip_id;
162         idx += ip->ip_id;
163         frag.ipfr_tos = ip->ip_tos;
164         frag.ipfr_src.s_addr = ip->ip_src.s_addr;
165         idx += ip->ip_src.s_addr;
166         frag.ipfr_dst.s_addr = ip->ip_dst.s_addr;
167         idx += ip->ip_dst.s_addr;
168         frag.ipfr_ifp = fin->fin_ifp;
169         idx *= 127;
170         idx %= IPFT_SIZE;
171
172         frag.ipfr_optmsk = fin->fin_fi.fi_optmsk & IPF_OPTCOPY;
173         frag.ipfr_secmsk = fin->fin_fi.fi_secmsk;
174         frag.ipfr_auth = fin->fin_fi.fi_auth;
175
176         /*
177          * first, make sure it isn't already there...
178          */
179         for (fp = &table[idx]; (fra = *fp); fp = &fra->ipfr_next)
180                 if (!bcmp((char *)&frag.ipfr_src, (char *)&fra->ipfr_src,
181                           IPFR_CMPSZ)) {
182                         ATOMIC_INCL(ipfr_stats.ifs_exists);
183                         return NULL;
184                 }
185
186         /*
187          * allocate some memory, if possible, if not, just record that we
188          * failed to do so.
189          */
190         KMALLOC(fra, ipfr_t *);
191         if (fra == NULL) {
192                 ATOMIC_INCL(ipfr_stats.ifs_nomem);
193                 return NULL;
194         }
195
196         if ((fra->ipfr_rule = fin->fin_fr) != NULL) {
197                 ATOMIC_INC32(fin->fin_fr->fr_ref);
198         }
199
200
201         /*
202          * Insert the fragment into the fragment table, copy the struct used
203          * in the search using bcopy rather than reassign each field.
204          * Set the ttl to the default.
205          */
206         if ((fra->ipfr_next = table[idx]))
207                 table[idx]->ipfr_prev = fra;
208         fra->ipfr_prev = NULL;
209         fra->ipfr_data = NULL;
210         table[idx] = fra;
211         bcopy((char *)&frag.ipfr_src, (char *)&fra->ipfr_src, IPFR_CMPSZ);
212         fra->ipfr_ttl = fr_ipfrttl;
213         /*
214          * Compute the offset of the expected start of the next packet.
215          */
216         off = ip->ip_off & IP_OFFMASK;
217         if (!off)
218                 fra->ipfr_seen0 = 1;
219         fra->ipfr_off = off + (fin->fin_dlen >> 3);
220         ATOMIC_INCL(ipfr_stats.ifs_new);
221         ATOMIC_INC32(ipfr_inuse);
222         return fra;
223 }
224
225
226 int ipfr_newfrag(ip, fin)
227 ip_t *ip;
228 fr_info_t *fin;
229 {
230         ipfr_t  *ipf;
231
232         if ((ip->ip_v != 4) || (fr_frag_lock))
233                 return -1;
234         WRITE_ENTER(&ipf_frag);
235         ipf = ipfr_new(ip, fin, ipfr_heads);
236         RWLOCK_EXIT(&ipf_frag);
237         if (ipf == NULL) {
238                 ATOMIC_INCL(frstats[fin->fin_out].fr_bnfr);
239                 return -1;
240         }
241         ATOMIC_INCL(frstats[fin->fin_out].fr_nfr);
242         return 0;
243 }
244
245
246 int ipfr_nat_newfrag(ip, fin, nat)
247 ip_t *ip;
248 fr_info_t *fin;
249 nat_t *nat;
250 {
251         ipfr_t  *ipf;
252         int off;
253
254         if ((ip->ip_v != 4) || (fr_frag_lock))
255                 return -1;
256
257         off = fin->fin_off;
258         off <<= 3;
259         if ((off + fin->fin_dlen) > 0xffff || (fin->fin_dlen == 0))
260                 return -1;
261
262         WRITE_ENTER(&ipf_natfrag);
263         ipf = ipfr_new(ip, fin, ipfr_nattab);
264         if (ipf != NULL) {
265                 ipf->ipfr_data = nat;
266                 nat->nat_data = ipf;
267         }
268         RWLOCK_EXIT(&ipf_natfrag);
269         return ipf ? 0 : -1;
270 }
271
272
273 /*
274  * check the fragment cache to see if there is already a record of this packet
275  * with its filter result known.
276  */
277 static ipfr_t *ipfr_lookup(ip, fin, table)
278 ip_t *ip;
279 fr_info_t *fin;
280 ipfr_t *table[];
281 {
282         ipfr_t  *f, frag;
283         u_int   idx;
284
285         /*
286          * For fragments, we record protocol, packet id, TOS and both IP#'s
287          * (these should all be the same for all fragments of a packet).
288          *
289          * build up a hash value to index the table with.
290          */
291         frag.ipfr_p = ip->ip_p;
292         idx = ip->ip_p;
293         frag.ipfr_id = ip->ip_id;
294         idx += ip->ip_id;
295         frag.ipfr_tos = ip->ip_tos;
296         frag.ipfr_src.s_addr = ip->ip_src.s_addr;
297         idx += ip->ip_src.s_addr;
298         frag.ipfr_dst.s_addr = ip->ip_dst.s_addr;
299         idx += ip->ip_dst.s_addr;
300         frag.ipfr_ifp = fin->fin_ifp;
301         idx *= 127;
302         idx %= IPFT_SIZE;
303
304         frag.ipfr_optmsk = fin->fin_fi.fi_optmsk & IPF_OPTCOPY;
305         frag.ipfr_secmsk = fin->fin_fi.fi_secmsk;
306         frag.ipfr_auth = fin->fin_fi.fi_auth;
307
308         /*
309          * check the table, careful to only compare the right amount of data
310          */
311         for (f = table[idx]; f; f = f->ipfr_next)
312                 if (!bcmp((char *)&frag.ipfr_src, (char *)&f->ipfr_src,
313                           IPFR_CMPSZ)) {
314                         u_short atoff, off;
315
316                         off = fin->fin_off;
317
318                         /*
319                          * XXX - We really need to be guarding against the
320                          * retransmission of (src,dst,id,offset-range) here
321                          * because a fragmented packet is never resent with
322                          * the same IP ID#.
323                          */
324                         if (f->ipfr_seen0) {
325                                 if (!off || (fin->fin_fl & FI_SHORT))
326                                         continue;
327                         } else if (!off)
328                                 f->ipfr_seen0 = 1;
329
330                         if (f != table[idx]) {
331                                 /*
332                                  * move fragment info. to the top of the list
333                                  * to speed up searches.
334                                  */
335                                 if ((f->ipfr_prev->ipfr_next = f->ipfr_next))
336                                         f->ipfr_next->ipfr_prev = f->ipfr_prev;
337                                 f->ipfr_next = table[idx];
338                                 table[idx]->ipfr_prev = f;
339                                 f->ipfr_prev = NULL;
340                                 table[idx] = f;
341                         }
342                         atoff = off + (fin->fin_dlen >> 3);
343                         /*
344                          * If we've follwed the fragments, and this is the
345                          * last (in order), shrink expiration time.
346                          */
347                         if (off == f->ipfr_off) {
348                                 if (!(ip->ip_off & IP_MF))
349                                         f->ipfr_ttl = 1;
350                                 else
351                                         f->ipfr_off = atoff;
352                         }
353                         ATOMIC_INCL(ipfr_stats.ifs_hits);
354                         return f;
355                 }
356         return NULL;
357 }
358
359
360 /*
361  * functional interface for NAT lookups of the NAT fragment cache
362  */
363 nat_t *ipfr_nat_knownfrag(ip, fin)
364 ip_t *ip;
365 fr_info_t *fin;
366 {
367         ipfr_t *ipf;
368         nat_t *nat;
369         int off;
370
371         if ((fin->fin_v != 4) || (fr_frag_lock))
372                 return NULL;
373
374         off = fin->fin_off;
375         off <<= 3;
376         if ((off + fin->fin_dlen) > 0xffff || (fin->fin_dlen == 0))
377                 return NULL;
378
379         READ_ENTER(&ipf_natfrag);
380         ipf = ipfr_lookup(ip, fin, ipfr_nattab);
381         if (ipf != NULL) {
382                 nat = ipf->ipfr_data;
383                 /*
384                  * This is the last fragment for this packet.
385                  */
386                 if ((ipf->ipfr_ttl == 1) && (nat != NULL)) {
387                         nat->nat_data = NULL;
388                         ipf->ipfr_data = NULL;
389                 }
390         } else
391                 nat = NULL;
392         RWLOCK_EXIT(&ipf_natfrag);
393         return nat;
394 }
395
396
397 /*
398  * functional interface for normal lookups of the fragment cache
399  */
400 frentry_t *ipfr_knownfrag(ip, fin)
401 ip_t *ip;
402 fr_info_t *fin;
403 {
404         frentry_t *fr;
405         ipfr_t *fra;
406         int off;
407
408         if ((fin->fin_v != 4) || (fr_frag_lock))
409                 return NULL;
410
411         off = fin->fin_off;
412         off <<= 3;
413         if ((off + fin->fin_dlen) > 0xffff || (fin->fin_dlen == 0))
414                 return NULL;
415
416         READ_ENTER(&ipf_frag);
417         fra = ipfr_lookup(ip, fin, ipfr_heads);
418         if (fra != NULL)
419                 fr = fra->ipfr_rule;
420         else
421                 fr = NULL;
422         RWLOCK_EXIT(&ipf_frag);
423         return fr;
424 }
425
426
427 /*
428  * forget any references to this external object.
429  */
430 void ipfr_forget(ptr)
431 void *ptr;
432 {
433         ipfr_t  *fr;
434         int     idx;
435
436         WRITE_ENTER(&ipf_frag);
437         for (idx = IPFT_SIZE - 1; idx >= 0; idx--)
438                 for (fr = ipfr_heads[idx]; fr; fr = fr->ipfr_next)
439                         if (fr->ipfr_data == ptr)
440                                 fr->ipfr_data = NULL;
441
442         RWLOCK_EXIT(&ipf_frag);
443 }
444
445
446 /*
447  * forget any references to this external object.
448  */
449 void ipfr_forgetnat(nat)
450 void *nat;
451 {
452         ipfr_t  *fr;
453         int     idx;
454
455         WRITE_ENTER(&ipf_natfrag);
456         for (idx = IPFT_SIZE - 1; idx >= 0; idx--)
457                 for (fr = ipfr_nattab[idx]; fr; fr = fr->ipfr_next)
458                         if (fr->ipfr_data == nat)
459                                 fr->ipfr_data = NULL;
460
461         RWLOCK_EXIT(&ipf_natfrag);
462 }
463
464
465 static void ipfr_delete(fra)
466 ipfr_t *fra;
467 {
468         frentry_t *fr;
469
470         fr = fra->ipfr_rule;
471         if (fr != NULL) {
472                 ATOMIC_DEC32(fr->fr_ref);
473                 if (fr->fr_ref == 0)
474                         KFREE(fr);
475         }
476         if (fra->ipfr_prev)
477                 fra->ipfr_prev->ipfr_next = fra->ipfr_next;
478         if (fra->ipfr_next)
479                 fra->ipfr_next->ipfr_prev = fra->ipfr_prev;
480         KFREE(fra);
481 }
482
483
484 /*
485  * Free memory in use by fragment state info. kept.
486  */
487 void ipfr_unload()
488 {
489         ipfr_t  **fp, *fra;
490         nat_t   *nat;
491         int     idx;
492
493         WRITE_ENTER(&ipf_frag);
494         for (idx = IPFT_SIZE - 1; idx >= 0; idx--)
495                 for (fp = &ipfr_heads[idx]; (fra = *fp); ) {
496                         *fp = fra->ipfr_next;
497                         ipfr_delete(fra);
498                 }
499         RWLOCK_EXIT(&ipf_frag);
500
501         WRITE_ENTER(&ipf_nat);
502         WRITE_ENTER(&ipf_natfrag);
503         for (idx = IPFT_SIZE - 1; idx >= 0; idx--)
504                 for (fp = &ipfr_nattab[idx]; (fra = *fp); ) {
505                         *fp = fra->ipfr_next;
506                         nat = fra->ipfr_data;
507                         if (nat != NULL) {
508                                 if (nat->nat_data == fra)
509                                         nat->nat_data = NULL;
510                         }
511                         ipfr_delete(fra);
512                 }
513         RWLOCK_EXIT(&ipf_natfrag);
514         RWLOCK_EXIT(&ipf_nat);
515 }
516
517
518 void ipfr_fragexpire()
519 {
520         ipfr_t  **fp, *fra;
521         nat_t   *nat;
522         int     idx;
523 #if defined(_KERNEL)
524 # if !SOLARIS && !defined(__DragonFly__)
525         int     s;
526 # endif
527 #endif
528
529         if (fr_frag_lock)
530                 return;
531
532         SPL_NET(s);
533         WRITE_ENTER(&ipf_frag);
534
535         /*
536          * Go through the entire table, looking for entries to expire,
537          * decreasing the ttl by one for each entry.  If it reaches 0,
538          * remove it from the chain and free it.
539          */
540         for (idx = IPFT_SIZE - 1; idx >= 0; idx--)
541                 for (fp = &ipfr_heads[idx]; (fra = *fp); ) {
542                         --fra->ipfr_ttl;
543                         if (fra->ipfr_ttl == 0) {
544                                 *fp = fra->ipfr_next;
545                                 ipfr_delete(fra);
546                                 ATOMIC_INCL(ipfr_stats.ifs_expire);
547                                 ATOMIC_DEC32(ipfr_inuse);
548                         } else
549                                 fp = &fra->ipfr_next;
550                 }
551         RWLOCK_EXIT(&ipf_frag);
552
553         /*
554          * Same again for the NAT table, except that if the structure also
555          * still points to a NAT structure, and the NAT structure points back
556          * at the one to be free'd, NULL the reference from the NAT struct.
557          * NOTE: We need to grab both mutex's early, and in this order so as
558          * to prevent a deadlock if both try to expire at the same time.
559          */
560         WRITE_ENTER(&ipf_nat);
561         WRITE_ENTER(&ipf_natfrag);
562         for (idx = IPFT_SIZE - 1; idx >= 0; idx--)
563                 for (fp = &ipfr_nattab[idx]; (fra = *fp); ) {
564                         --fra->ipfr_ttl;
565                         if (fra->ipfr_ttl == 0) {
566                                 ATOMIC_INCL(ipfr_stats.ifs_expire);
567                                 ATOMIC_DEC32(ipfr_inuse);
568                                 nat = fra->ipfr_data;
569                                 if (nat != NULL) {
570                                         if (nat->nat_data == fra)
571                                                 nat->nat_data = NULL;
572                                 }
573                                 *fp = fra->ipfr_next;
574                                 ipfr_delete(fra);
575                         } else
576                                 fp = &fra->ipfr_next;
577                 }
578         RWLOCK_EXIT(&ipf_natfrag);
579         RWLOCK_EXIT(&ipf_nat);
580         SPL_X(s);
581 }
582
583
584 /*
585  * Slowly expire held state for fragments.  Timeouts are set * in expectation
586  * of this being called twice per second.
587  */
588 #ifdef _KERNEL
589 # if (BSD >= 199306) || SOLARIS || defined(__sgi)
590 #  if defined(SOLARIS2) && (SOLARIS2 < 7)
591 void ipfr_slowtimer()
592 #  else
593 void ipfr_slowtimer (void *ptr)
594 #  endif
595 # else
596 int ipfr_slowtimer()
597 # endif
598 #else
599 void ipfr_slowtimer()
600 #endif
601 {
602 #if defined(_KERNEL) && SOLARIS
603         extern  int     fr_running;
604
605         if (fr_running <= 0) 
606                 return;
607         READ_ENTER(&ipf_solaris);
608 #endif
609
610 #if defined(__sgi) && defined(_KERNEL)
611         ipfilter_sgi_intfsync();
612 #endif
613
614         ipfr_fragexpire();
615         fr_timeoutstate();
616         ip_natexpire();
617         fr_authexpire();
618 #if defined(_KERNEL)
619 # if    SOLARIS
620         ipfr_timer_id = timeout(ipfr_slowtimer, NULL, drv_usectohz(500000));
621         RWLOCK_EXIT(&ipf_solaris);
622 # else
623 #  if defined(__NetBSD__) && (__NetBSD_Version__ >= 104240000)
624         callout_reset(&ipfr_slowtimer_ch, hz / 2, ipfr_slowtimer, NULL);
625 #  else
626 #   if defined(__DragonFly__) || __FreeBSD_version >= 300000
627         callout_reset(&ipfr_slowtimer_ch, hz / 2, ipfr_slowtimer, NULL);
628 #   else
629 #    if defined(__OpenBSD__)
630         timeout_add(&ipfr_slowtimer_ch, hz/2);
631 #    else
632         timeout(ipfr_slowtimer, NULL, hz/2);
633 #    endif
634 #   endif
635 #   if (BSD < 199306) && !defined(__sgi)
636         return 0;
637 #   endif /* FreeBSD */
638 #  endif /* NetBSD */
639 # endif /* SOLARIS */
640 #endif /* defined(_KERNEL) */
641 }