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