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