Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / net / ipv4 / netfilter / iptable_filter.c
1 /*
2  * This is the 1999 rewrite of IP Firewalling, aiming for kernel 2.3.x.
3  *
4  * Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
5  * Copyright (C) 2000-2004 Netfilter Core Team <coreteam@netfilter.org>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  */
12
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/netfilter_ipv4/ip_tables.h>
16
17 MODULE_LICENSE("GPL");
18 MODULE_AUTHOR("Netfilter Core Team <coreteam@netfilter.org>");
19 MODULE_DESCRIPTION("iptables filter table");
20
21 #define FILTER_VALID_HOOKS ((1 << NF_IP_LOCAL_IN) | (1 << NF_IP_FORWARD) | (1 << NF_IP_LOCAL_OUT))
22
23 static struct
24 {
25         struct ipt_replace repl;
26         struct ipt_standard entries[3];
27         struct ipt_error term;
28 } initial_table __initdata 
29 = { { "filter", FILTER_VALID_HOOKS, 4,
30       sizeof(struct ipt_standard) * 3 + sizeof(struct ipt_error),
31       { [NF_IP_LOCAL_IN] = 0,
32         [NF_IP_FORWARD] = sizeof(struct ipt_standard),
33         [NF_IP_LOCAL_OUT] = sizeof(struct ipt_standard) * 2 },
34       { [NF_IP_LOCAL_IN] = 0,
35         [NF_IP_FORWARD] = sizeof(struct ipt_standard),
36         [NF_IP_LOCAL_OUT] = sizeof(struct ipt_standard) * 2 },
37       0, NULL, { } },
38     {
39             /* LOCAL_IN */
40             { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },
41                 0,
42                 sizeof(struct ipt_entry),
43                 sizeof(struct ipt_standard),
44                 0, { 0, 0 }, { } },
45               { { { { IPT_ALIGN(sizeof(struct ipt_standard_target)), "" } }, { } },
46                 -NF_ACCEPT - 1 } },
47             /* FORWARD */
48             { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },
49                 0,
50                 sizeof(struct ipt_entry),
51                 sizeof(struct ipt_standard),
52                 0, { 0, 0 }, { } },
53               { { { { IPT_ALIGN(sizeof(struct ipt_standard_target)), "" } }, { } },
54                 -NF_ACCEPT - 1 } },
55             /* LOCAL_OUT */
56             { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },
57                 0,
58                 sizeof(struct ipt_entry),
59                 sizeof(struct ipt_standard),
60                 0, { 0, 0 }, { } },
61               { { { { IPT_ALIGN(sizeof(struct ipt_standard_target)), "" } }, { } },
62                 -NF_ACCEPT - 1 } }
63     },
64     /* ERROR */
65     { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },
66         0,
67         sizeof(struct ipt_entry),
68         sizeof(struct ipt_error),
69         0, { 0, 0 }, { } },
70       { { { { IPT_ALIGN(sizeof(struct ipt_error_target)), IPT_ERROR_TARGET } },
71           { } },
72         "ERROR"
73       }
74     }
75 };
76
77 static struct ipt_table packet_filter = {
78         .name           = "filter",
79         .valid_hooks    = FILTER_VALID_HOOKS,
80         .lock           = RW_LOCK_UNLOCKED,
81         .me             = THIS_MODULE
82 };
83
84 /* The work comes in here from netfilter.c. */
85 static unsigned int
86 ipt_hook(unsigned int hook,
87          struct sk_buff **pskb,
88          const struct net_device *in,
89          const struct net_device *out,
90          int (*okfn)(struct sk_buff *))
91 {
92         return ipt_do_table(pskb, hook, in, out, &packet_filter, NULL);
93 }
94
95 static unsigned int
96 ipt_local_out_hook(unsigned int hook,
97                    struct sk_buff **pskb,
98                    const struct net_device *in,
99                    const struct net_device *out,
100                    int (*okfn)(struct sk_buff *))
101 {
102         /* root is playing with raw sockets. */
103         if ((*pskb)->len < sizeof(struct iphdr)
104             || (*pskb)->nh.iph->ihl * 4 < sizeof(struct iphdr)) {
105                 if (net_ratelimit())
106                         printk("ipt_hook: happy cracking.\n");
107                 return NF_ACCEPT;
108         }
109
110         return ipt_do_table(pskb, hook, in, out, &packet_filter, NULL);
111 }
112
113 static struct nf_hook_ops ipt_ops[] = {
114         {
115                 .hook           = ipt_hook,
116                 .owner          = THIS_MODULE,
117                 .pf             = PF_INET,
118                 .hooknum        = NF_IP_LOCAL_IN,
119                 .priority       = NF_IP_PRI_FILTER,
120         },
121         {
122                 .hook           = ipt_hook,
123                 .owner          = THIS_MODULE,
124                 .pf             = PF_INET,
125                 .hooknum        = NF_IP_FORWARD,
126                 .priority       = NF_IP_PRI_FILTER,
127         },
128         {
129                 .hook           = ipt_local_out_hook,
130                 .owner          = THIS_MODULE,
131                 .pf             = PF_INET,
132                 .hooknum        = NF_IP_LOCAL_OUT,
133                 .priority       = NF_IP_PRI_FILTER,
134         },
135 };
136
137 /* Default to forward because I got too much mail already. */
138 static int forward = NF_ACCEPT;
139 module_param(forward, bool, 0000);
140
141 static int __init init(void)
142 {
143         int ret;
144
145         if (forward < 0 || forward > NF_MAX_VERDICT) {
146                 printk("iptables forward must be 0 or 1\n");
147                 return -EINVAL;
148         }
149
150         /* Entry 1 is the FORWARD hook */
151         initial_table.entries[1].target.verdict = -forward - 1;
152
153         /* Register table */
154         ret = ipt_register_table(&packet_filter, &initial_table.repl);
155         if (ret < 0)
156                 return ret;
157
158         /* Register hooks */
159         ret = nf_register_hook(&ipt_ops[0]);
160         if (ret < 0)
161                 goto cleanup_table;
162
163         ret = nf_register_hook(&ipt_ops[1]);
164         if (ret < 0)
165                 goto cleanup_hook0;
166
167         ret = nf_register_hook(&ipt_ops[2]);
168         if (ret < 0)
169                 goto cleanup_hook1;
170
171         return ret;
172
173  cleanup_hook1:
174         nf_unregister_hook(&ipt_ops[1]);
175  cleanup_hook0:
176         nf_unregister_hook(&ipt_ops[0]);
177  cleanup_table:
178         ipt_unregister_table(&packet_filter);
179
180         return ret;
181 }
182
183 static void __exit fini(void)
184 {
185         unsigned int i;
186
187         for (i = 0; i < sizeof(ipt_ops)/sizeof(struct nf_hook_ops); i++)
188                 nf_unregister_hook(&ipt_ops[i]);
189
190         ipt_unregister_table(&packet_filter);
191 }
192
193 module_init(init);
194 module_exit(fini);