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