[NETFILTER]: Introduce infrastructure for address family specific operations
[linux-2.6.git] / net / netfilter / nf_queue.c
1 #include <linux/config.h>
2 #include <linux/kernel.h>
3 #include <linux/init.h>
4 #include <linux/module.h>
5 #include <linux/proc_fs.h>
6 #include <linux/skbuff.h>
7 #include <linux/netfilter.h>
8 #include <linux/seq_file.h>
9 #include <linux/rcupdate.h>
10 #include <net/protocol.h>
11
12 #include "nf_internals.h"
13
14 /* 
15  * A queue handler may be registered for each protocol.  Each is protected by
16  * long term mutex.  The handler must provide an an outfn() to accept packets
17  * for queueing and must reinject all packets it receives, no matter what.
18  */
19 static struct nf_queue_handler *queue_handler[NPROTO];
20
21 static DEFINE_RWLOCK(queue_handler_lock);
22
23 /* return EBUSY when somebody else is registered, return EEXIST if the
24  * same handler is registered, return 0 in case of success. */
25 int nf_register_queue_handler(int pf, struct nf_queue_handler *qh)
26 {      
27         int ret;
28
29         if (pf >= NPROTO)
30                 return -EINVAL;
31
32         write_lock_bh(&queue_handler_lock);
33         if (queue_handler[pf] == qh)
34                 ret = -EEXIST;
35         else if (queue_handler[pf])
36                 ret = -EBUSY;
37         else {
38                 queue_handler[pf] = qh;
39                 ret = 0;
40         }
41         write_unlock_bh(&queue_handler_lock);
42
43         return ret;
44 }
45 EXPORT_SYMBOL(nf_register_queue_handler);
46
47 /* The caller must flush their queue before this */
48 int nf_unregister_queue_handler(int pf)
49 {
50         if (pf >= NPROTO)
51                 return -EINVAL;
52
53         write_lock_bh(&queue_handler_lock);
54         queue_handler[pf] = NULL;
55         write_unlock_bh(&queue_handler_lock);
56         
57         return 0;
58 }
59 EXPORT_SYMBOL(nf_unregister_queue_handler);
60
61 void nf_unregister_queue_handlers(struct nf_queue_handler *qh)
62 {
63         int pf;
64
65         write_lock_bh(&queue_handler_lock);
66         for (pf = 0; pf < NPROTO; pf++)  {
67                 if (queue_handler[pf] == qh)
68                         queue_handler[pf] = NULL;
69         }
70         write_unlock_bh(&queue_handler_lock);
71 }
72 EXPORT_SYMBOL_GPL(nf_unregister_queue_handlers);
73
74 /* 
75  * Any packet that leaves via this function must come back 
76  * through nf_reinject().
77  */
78 int nf_queue(struct sk_buff **skb, 
79              struct list_head *elem, 
80              int pf, unsigned int hook,
81              struct net_device *indev,
82              struct net_device *outdev,
83              int (*okfn)(struct sk_buff *),
84              unsigned int queuenum)
85 {
86         int status;
87         struct nf_info *info;
88 #ifdef CONFIG_BRIDGE_NETFILTER
89         struct net_device *physindev = NULL;
90         struct net_device *physoutdev = NULL;
91 #endif
92         struct nf_afinfo *afinfo;
93
94         /* QUEUE == DROP if noone is waiting, to be safe. */
95         read_lock(&queue_handler_lock);
96         if (!queue_handler[pf]) {
97                 read_unlock(&queue_handler_lock);
98                 kfree_skb(*skb);
99                 return 1;
100         }
101
102         afinfo = nf_get_afinfo(pf);
103         if (!afinfo) {
104                 read_unlock(&queue_handler_lock);
105                 kfree_skb(*skb);
106                 return 1;
107         }
108
109         info = kmalloc(sizeof(*info) + afinfo->route_key_size, GFP_ATOMIC);
110         if (!info) {
111                 if (net_ratelimit())
112                         printk(KERN_ERR "OOM queueing packet %p\n",
113                                *skb);
114                 read_unlock(&queue_handler_lock);
115                 kfree_skb(*skb);
116                 return 1;
117         }
118
119         *info = (struct nf_info) { 
120                 (struct nf_hook_ops *)elem, pf, hook, indev, outdev, okfn };
121
122         /* If it's going away, ignore hook. */
123         if (!try_module_get(info->elem->owner)) {
124                 read_unlock(&queue_handler_lock);
125                 kfree(info);
126                 return 0;
127         }
128
129         /* Bump dev refs so they don't vanish while packet is out */
130         if (indev) dev_hold(indev);
131         if (outdev) dev_hold(outdev);
132
133 #ifdef CONFIG_BRIDGE_NETFILTER
134         if ((*skb)->nf_bridge) {
135                 physindev = (*skb)->nf_bridge->physindev;
136                 if (physindev) dev_hold(physindev);
137                 physoutdev = (*skb)->nf_bridge->physoutdev;
138                 if (physoutdev) dev_hold(physoutdev);
139         }
140 #endif
141         afinfo->saveroute(*skb, info);
142         status = queue_handler[pf]->outfn(*skb, info, queuenum,
143                                           queue_handler[pf]->data);
144
145         read_unlock(&queue_handler_lock);
146
147         if (status < 0) {
148                 /* James M doesn't say fuck enough. */
149                 if (indev) dev_put(indev);
150                 if (outdev) dev_put(outdev);
151 #ifdef CONFIG_BRIDGE_NETFILTER
152                 if (physindev) dev_put(physindev);
153                 if (physoutdev) dev_put(physoutdev);
154 #endif
155                 module_put(info->elem->owner);
156                 kfree(info);
157                 kfree_skb(*skb);
158
159                 return 1;
160         }
161
162         return 1;
163 }
164
165 void nf_reinject(struct sk_buff *skb, struct nf_info *info,
166                  unsigned int verdict)
167 {
168         struct list_head *elem = &info->elem->list;
169         struct list_head *i;
170         struct nf_afinfo *afinfo;
171
172         rcu_read_lock();
173
174         /* Release those devices we held, or Alexey will kill me. */
175         if (info->indev) dev_put(info->indev);
176         if (info->outdev) dev_put(info->outdev);
177 #ifdef CONFIG_BRIDGE_NETFILTER
178         if (skb->nf_bridge) {
179                 if (skb->nf_bridge->physindev)
180                         dev_put(skb->nf_bridge->physindev);
181                 if (skb->nf_bridge->physoutdev)
182                         dev_put(skb->nf_bridge->physoutdev);
183         }
184 #endif
185
186         /* Drop reference to owner of hook which queued us. */
187         module_put(info->elem->owner);
188
189         list_for_each_rcu(i, &nf_hooks[info->pf][info->hook]) {
190                 if (i == elem) 
191                         break;
192         }
193   
194         if (i == &nf_hooks[info->pf][info->hook]) {
195                 /* The module which sent it to userspace is gone. */
196                 NFDEBUG("%s: module disappeared, dropping packet.\n",
197                         __FUNCTION__);
198                 verdict = NF_DROP;
199         }
200
201         /* Continue traversal iff userspace said ok... */
202         if (verdict == NF_REPEAT) {
203                 elem = elem->prev;
204                 verdict = NF_ACCEPT;
205         }
206
207         if (verdict == NF_ACCEPT) {
208                 afinfo = nf_get_afinfo(info->pf);
209                 if (!afinfo || afinfo->reroute(&skb, info) < 0)
210                         verdict = NF_DROP;
211         }
212
213         if (verdict == NF_ACCEPT) {
214         next_hook:
215                 verdict = nf_iterate(&nf_hooks[info->pf][info->hook],
216                                      &skb, info->hook, 
217                                      info->indev, info->outdev, &elem,
218                                      info->okfn, INT_MIN);
219         }
220
221         switch (verdict & NF_VERDICT_MASK) {
222         case NF_ACCEPT:
223                 info->okfn(skb);
224                 break;
225
226         case NF_QUEUE:
227                 if (!nf_queue(&skb, elem, info->pf, info->hook, 
228                               info->indev, info->outdev, info->okfn,
229                               verdict >> NF_VERDICT_BITS))
230                         goto next_hook;
231                 break;
232         }
233         rcu_read_unlock();
234
235         if (verdict == NF_DROP)
236                 kfree_skb(skb);
237
238         kfree(info);
239         return;
240 }
241 EXPORT_SYMBOL(nf_reinject);
242
243 #ifdef CONFIG_PROC_FS
244 static void *seq_start(struct seq_file *seq, loff_t *pos)
245 {
246         if (*pos >= NPROTO)
247                 return NULL;
248
249         return pos;
250 }
251
252 static void *seq_next(struct seq_file *s, void *v, loff_t *pos)
253 {
254         (*pos)++;
255
256         if (*pos >= NPROTO)
257                 return NULL;
258
259         return pos;
260 }
261
262 static void seq_stop(struct seq_file *s, void *v)
263 {
264
265 }
266
267 static int seq_show(struct seq_file *s, void *v)
268 {
269         int ret;
270         loff_t *pos = v;
271         struct nf_queue_handler *qh;
272
273         read_lock_bh(&queue_handler_lock);
274         qh = queue_handler[*pos];
275         if (!qh)
276                 ret = seq_printf(s, "%2lld NONE\n", *pos);
277         else
278                 ret = seq_printf(s, "%2lld %s\n", *pos, qh->name);
279         read_unlock_bh(&queue_handler_lock);
280
281         return ret;
282 }
283
284 static struct seq_operations nfqueue_seq_ops = {
285         .start  = seq_start,
286         .next   = seq_next,
287         .stop   = seq_stop,
288         .show   = seq_show,
289 };
290
291 static int nfqueue_open(struct inode *inode, struct file *file)
292 {
293         return seq_open(file, &nfqueue_seq_ops);
294 }
295
296 static struct file_operations nfqueue_file_ops = {
297         .owner   = THIS_MODULE,
298         .open    = nfqueue_open,
299         .read    = seq_read,
300         .llseek  = seq_lseek,
301         .release = seq_release,
302 };
303 #endif /* PROC_FS */
304
305
306 int __init netfilter_queue_init(void)
307 {
308 #ifdef CONFIG_PROC_FS
309         struct proc_dir_entry *pde;
310
311         pde = create_proc_entry("nf_queue", S_IRUGO, proc_net_netfilter);
312         if (!pde)
313                 return -1;
314         pde->proc_fops = &nfqueue_file_ops;
315 #endif
316         return 0;
317 }
318