Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / net / ipv6 / netfilter / ip6t_dst.c
1 /* Kernel module to match Hop-by-Hop and Destination parameters. */
2
3 /* (C) 2001-2002 Andras Kis-Szabo <kisza@sch.bme.hu>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  */
9
10 #include <linux/module.h>
11 #include <linux/skbuff.h>
12 #include <linux/ipv6.h>
13 #include <linux/types.h>
14 #include <net/checksum.h>
15 #include <net/ipv6.h>
16
17 #include <asm/byteorder.h>
18
19 #include <linux/netfilter_ipv6/ip6_tables.h>
20 #include <linux/netfilter_ipv6/ip6t_opts.h>
21
22 #define HOPBYHOP        0
23
24 MODULE_LICENSE("GPL");
25 #if HOPBYHOP
26 MODULE_DESCRIPTION("IPv6 HbH match");
27 #else
28 MODULE_DESCRIPTION("IPv6 DST match");
29 #endif
30 MODULE_AUTHOR("Andras Kis-Szabo <kisza@sch.bme.hu>");
31
32 #if 0
33 #define DEBUGP printk
34 #else
35 #define DEBUGP(format, args...)
36 #endif
37
38 /*
39  *  (Type & 0xC0) >> 6
40  *      0       -> ignorable
41  *      1       -> must drop the packet
42  *      2       -> send ICMP PARM PROB regardless and drop packet
43  *      3       -> Send ICMP if not a multicast address and drop packet
44  *  (Type & 0x20) >> 5
45  *      0       -> invariant
46  *      1       -> can change the routing
47  *  (Type & 0x1F) Type
48  *      0       -> Pad1 (only 1 byte!)
49  *      1       -> PadN LENGTH info (total length = length + 2)
50  *      C0 | 2  -> JUMBO 4 x x x x ( xxxx > 64k )
51  *      5       -> RTALERT 2 x x
52  */
53
54 static int
55 match(const struct sk_buff *skb,
56       const struct net_device *in,
57       const struct net_device *out,
58       const struct xt_match *match,
59       const void *matchinfo,
60       int offset,
61       unsigned int protoff,
62       int *hotdrop)
63 {
64         struct ipv6_opt_hdr _optsh, *oh;
65         const struct ip6t_opts *optinfo = matchinfo;
66         unsigned int temp;
67         unsigned int ptr;
68         unsigned int hdrlen = 0;
69         unsigned int ret = 0;
70         u8 _opttype, *tp = NULL;
71         u8 _optlen, *lp = NULL;
72         unsigned int optlen;
73
74 #if HOPBYHOP
75         if (ipv6_find_hdr(skb, &ptr, NEXTHDR_HOP, NULL) < 0)
76 #else
77         if (ipv6_find_hdr(skb, &ptr, NEXTHDR_DEST, NULL) < 0)
78 #endif
79                 return 0;
80
81         oh = skb_header_pointer(skb, ptr, sizeof(_optsh), &_optsh);
82         if (oh == NULL) {
83                 *hotdrop = 1;
84                 return 0;
85         }
86
87         hdrlen = ipv6_optlen(oh);
88         if (skb->len - ptr < hdrlen) {
89                 /* Packet smaller than it's length field */
90                 return 0;
91         }
92
93         DEBUGP("IPv6 OPTS LEN %u %u ", hdrlen, oh->hdrlen);
94
95         DEBUGP("len %02X %04X %02X ",
96                optinfo->hdrlen, hdrlen,
97                (!(optinfo->flags & IP6T_OPTS_LEN) ||
98                 ((optinfo->hdrlen == hdrlen) ^
99                  !!(optinfo->invflags & IP6T_OPTS_INV_LEN))));
100
101         ret = (oh != NULL) &&
102               (!(optinfo->flags & IP6T_OPTS_LEN) ||
103                ((optinfo->hdrlen == hdrlen) ^
104                 !!(optinfo->invflags & IP6T_OPTS_INV_LEN)));
105
106         ptr += 2;
107         hdrlen -= 2;
108         if (!(optinfo->flags & IP6T_OPTS_OPTS)) {
109                 return ret;
110         } else if (optinfo->flags & IP6T_OPTS_NSTRICT) {
111                 DEBUGP("Not strict - not implemented");
112         } else {
113                 DEBUGP("Strict ");
114                 DEBUGP("#%d ", optinfo->optsnr);
115                 for (temp = 0; temp < optinfo->optsnr; temp++) {
116                         /* type field exists ? */
117                         if (hdrlen < 1)
118                                 break;
119                         tp = skb_header_pointer(skb, ptr, sizeof(_opttype),
120                                                 &_opttype);
121                         if (tp == NULL)
122                                 break;
123
124                         /* Type check */
125                         if (*tp != (optinfo->opts[temp] & 0xFF00) >> 8) {
126                                 DEBUGP("Tbad %02X %02X\n",
127                                        *tp,
128                                        (optinfo->opts[temp] & 0xFF00) >> 8);
129                                 return 0;
130                         } else {
131                                 DEBUGP("Tok ");
132                         }
133                         /* Length check */
134                         if (*tp) {
135                                 u16 spec_len;
136
137                                 /* length field exists ? */
138                                 if (hdrlen < 2)
139                                         break;
140                                 lp = skb_header_pointer(skb, ptr + 1,
141                                                         sizeof(_optlen),
142                                                         &_optlen);
143                                 if (lp == NULL)
144                                         break;
145                                 spec_len = optinfo->opts[temp] & 0x00FF;
146
147                                 if (spec_len != 0x00FF && spec_len != *lp) {
148                                         DEBUGP("Lbad %02X %04X\n", *lp,
149                                                spec_len);
150                                         return 0;
151                                 }
152                                 DEBUGP("Lok ");
153                                 optlen = *lp + 2;
154                         } else {
155                                 DEBUGP("Pad1\n");
156                                 optlen = 1;
157                         }
158
159                         /* Step to the next */
160                         DEBUGP("len%04X \n", optlen);
161
162                         if ((ptr > skb->len - optlen || hdrlen < optlen) &&
163                             (temp < optinfo->optsnr - 1)) {
164                                 DEBUGP("new pointer is too large! \n");
165                                 break;
166                         }
167                         ptr += optlen;
168                         hdrlen -= optlen;
169                 }
170                 if (temp == optinfo->optsnr)
171                         return ret;
172                 else
173                         return 0;
174         }
175
176         return 0;
177 }
178
179 /* Called when user tries to insert an entry of this type. */
180 static int
181 checkentry(const char *tablename,
182            const void *info,
183            const struct xt_match *match,
184            void *matchinfo,
185            unsigned int matchinfosize,
186            unsigned int hook_mask)
187 {
188         const struct ip6t_opts *optsinfo = matchinfo;
189
190         if (optsinfo->invflags & ~IP6T_OPTS_INV_MASK) {
191                 DEBUGP("ip6t_opts: unknown flags %X\n", optsinfo->invflags);
192                 return 0;
193         }
194         return 1;
195 }
196
197 static struct ip6t_match opts_match = {
198 #if HOPBYHOP
199         .name           = "hbh",
200 #else
201         .name           = "dst",
202 #endif
203         .match          = match,
204         .matchsize      = sizeof(struct ip6t_opts),
205         .checkentry     = checkentry,
206         .me             = THIS_MODULE,
207 };
208
209 static int __init init(void)
210 {
211         return ip6t_register_match(&opts_match);
212 }
213
214 static void __exit cleanup(void)
215 {
216         ip6t_unregister_match(&opts_match);
217 }
218
219 module_init(init);
220 module_exit(cleanup);