[NETFILTER]: {nf_netlink,ip,ip6}_queue: use list_for_each_entry
[linux-2.6] / net / netfilter / xt_u32.c
1 /*
2  *      xt_u32 - kernel module to match u32 packet content
3  *
4  *      Original author: Don Cohen <don@isis.cs3-inc.com>
5  *      (C) CC Computer Consultants GmbH, 2007
6  *      Contact: <jengelh@computergmbh.de>
7  */
8
9 #include <linux/module.h>
10 #include <linux/moduleparam.h>
11 #include <linux/spinlock.h>
12 #include <linux/skbuff.h>
13 #include <linux/types.h>
14 #include <linux/netfilter/x_tables.h>
15 #include <linux/netfilter/xt_u32.h>
16
17 static bool u32_match_it(const struct xt_u32 *data,
18                          const struct sk_buff *skb)
19 {
20         const struct xt_u32_test *ct;
21         unsigned int testind;
22         unsigned int nnums;
23         unsigned int nvals;
24         unsigned int i;
25         __be32 n;
26         u_int32_t pos;
27         u_int32_t val;
28         u_int32_t at;
29         int ret;
30
31         /*
32          * Small example: "0 >> 28 == 4 && 8 & 0xFF0000 >> 16 = 6, 17"
33          * (=IPv4 and (TCP or UDP)). Outer loop runs over the "&&" operands.
34          */
35         for (testind = 0; testind < data->ntests; ++testind) {
36                 ct  = &data->tests[testind];
37                 at  = 0;
38                 pos = ct->location[0].number;
39
40                 if (skb->len < 4 || pos > skb->len - 4)
41                         return false;
42
43                 ret   = skb_copy_bits(skb, pos, &n, sizeof(n));
44                 BUG_ON(ret < 0);
45                 val   = ntohl(n);
46                 nnums = ct->nnums;
47
48                 /* Inner loop runs over "&", "<<", ">>" and "@" operands */
49                 for (i = 1; i < nnums; ++i) {
50                         u_int32_t number = ct->location[i].number;
51                         switch (ct->location[i].nextop) {
52                         case XT_U32_AND:
53                                 val &= number;
54                                 break;
55                         case XT_U32_LEFTSH:
56                                 val <<= number;
57                                 break;
58                         case XT_U32_RIGHTSH:
59                                 val >>= number;
60                                 break;
61                         case XT_U32_AT:
62                                 if (at + val < at)
63                                         return false;
64                                 at += val;
65                                 pos = number;
66                                 if (at + 4 < at || skb->len < at + 4 ||
67                                     pos > skb->len - at - 4)
68                                         return false;
69
70                                 ret = skb_copy_bits(skb, at + pos, &n,
71                                                     sizeof(n));
72                                 BUG_ON(ret < 0);
73                                 val = ntohl(n);
74                                 break;
75                         }
76                 }
77
78                 /* Run over the "," and ":" operands */
79                 nvals = ct->nvalues;
80                 for (i = 0; i < nvals; ++i)
81                         if (ct->value[i].min <= val && val <= ct->value[i].max)
82                                 break;
83
84                 if (i >= ct->nvalues)
85                         return false;
86         }
87
88         return true;
89 }
90
91 static bool
92 u32_mt(const struct sk_buff *skb, const struct net_device *in,
93        const struct net_device *out, const struct xt_match *match,
94        const void *matchinfo, int offset, unsigned int protoff, bool *hotdrop)
95 {
96         const struct xt_u32 *data = matchinfo;
97         bool ret;
98
99         ret = u32_match_it(data, skb);
100         return ret ^ data->invert;
101 }
102
103 static struct xt_match u32_mt_reg[] __read_mostly = {
104         {
105                 .name       = "u32",
106                 .family     = AF_INET,
107                 .match      = u32_mt,
108                 .matchsize  = sizeof(struct xt_u32),
109                 .me         = THIS_MODULE,
110         },
111         {
112                 .name       = "u32",
113                 .family     = AF_INET6,
114                 .match      = u32_mt,
115                 .matchsize  = sizeof(struct xt_u32),
116                 .me         = THIS_MODULE,
117         },
118 };
119
120 static int __init u32_mt_init(void)
121 {
122         return xt_register_matches(u32_mt_reg, ARRAY_SIZE(u32_mt_reg));
123 }
124
125 static void __exit u32_mt_exit(void)
126 {
127         xt_unregister_matches(u32_mt_reg, ARRAY_SIZE(u32_mt_reg));
128 }
129
130 module_init(u32_mt_init);
131 module_exit(u32_mt_exit);
132 MODULE_AUTHOR("Jan Engelhardt <jengelh@computergmbh.de>");
133 MODULE_DESCRIPTION("netfilter u32 match module");
134 MODULE_LICENSE("GPL");
135 MODULE_ALIAS("ipt_u32");
136 MODULE_ALIAS("ip6t_u32");