source: trunk/target/linux/generic-2.6/patches-2.6.26/150-netfilter_imq.patch @ 11436

Last change on this file since 11436 was 11436, checked in by kaloz, 8 years ago

upgrade orion to 2.6.26-rc5

File size: 23.2 KB
  • new file drivers/net/imq.c

    - +  
     1/* 
     2 *             Pseudo-driver for the intermediate queue device. 
     3 * 
     4 *             This program is free software; you can redistribute it and/or 
     5 *             modify it under the terms of the GNU General Public License 
     6 *             as published by the Free Software Foundation; either version 
     7 *             2 of the License, or (at your option) any later version. 
     8 * 
     9 * Authors:    Patrick McHardy, <kaber@trash.net> 
     10 * 
     11 *            The first version was written by Martin Devera, <devik@cdi.cz> 
     12 * 
     13 * Credits:    Jan Rafaj <imq2t@cedric.vabo.cz> 
     14 *              - Update patch to 2.4.21 
     15 *             Sebastian Strollo <sstrollo@nortelnetworks.com> 
     16 *              - Fix "Dead-loop on netdevice imq"-issue 
     17 *             Marcel Sebek <sebek64@post.cz> 
     18 *              - Update to 2.6.2-rc1 
     19 * 
     20 *             After some time of inactivity there is a group taking care 
     21 *             of IMQ again: http://www.linuximq.net 
     22 * 
     23 * 
     24 *             2004/06/30 - New version of IMQ patch to kernels <=2.6.7 
     25 *             including the following changes: 
     26 * 
     27 *             - Correction of ipv6 support "+"s issue (Hasso Tepper) 
     28 *             - Correction of imq_init_devs() issue that resulted in 
     29 *             kernel OOPS unloading IMQ as module (Norbert Buchmuller) 
     30 *             - Addition of functionality to choose number of IMQ devices 
     31 *             during kernel config (Andre Correa) 
     32 *             - Addition of functionality to choose how IMQ hooks on 
     33 *             PRE and POSTROUTING (after or before NAT) (Andre Correa) 
     34 *             - Cosmetic corrections (Norbert Buchmuller) (Andre Correa) 
     35 * 
     36 * 
     37 *             2005/12/16 - IMQ versions between 2.6.7 and 2.6.13 were 
     38 *             released with almost no problems. 2.6.14-x was released 
     39 *             with some important changes: nfcache was removed; After 
     40 *             some weeks of trouble we figured out that some IMQ fields 
     41 *             in skb were missing in skbuff.c - skb_clone and copy_skb_header. 
     42 *             These functions are correctly patched by this new patch version. 
     43 * 
     44 *             Thanks for all who helped to figure out all the problems with 
     45 *             2.6.14.x: Patrick McHardy, Rune Kock, VeNoMouS, Max CtRiX, 
     46 *             Kevin Shanahan, Richard Lucassen, Valery Dachev (hopefully 
     47 *             I didn't forget anybody). I apologize again for my lack of time. 
     48 * 
     49 * 
     50 *             2008/06/07 - Changed imq.c to use qdisc_run() instead of 
     51 *             qdisc_restart() and moved qdisc_run() to tasklet to avoid 
     52 *             recursive locking. (Jussi Kivilinna) 
     53 * 
     54 * 
     55 *             More info at: http://www.linuximq.net/ (Andre Correa) 
     56 */ 
     57 
     58#include <linux/module.h> 
     59#include <linux/kernel.h> 
     60#include <linux/moduleparam.h> 
     61#include <linux/skbuff.h> 
     62#include <linux/netdevice.h> 
     63#include <linux/rtnetlink.h> 
     64#include <linux/if_arp.h> 
     65#include <linux/netfilter.h> 
     66#include <linux/netfilter_ipv4.h> 
     67#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 
     68        #include <linux/netfilter_ipv6.h> 
     69#endif 
     70#include <linux/imq.h> 
     71#include <net/pkt_sched.h> 
     72#include <net/netfilter/nf_queue.h> 
     73 
     74struct imq_private { 
     75        struct tasklet_struct tasklet; 
     76        int tasklet_pending; 
     77}; 
     78 
     79static nf_hookfn imq_nf_hook; 
     80 
     81static struct nf_hook_ops imq_ingress_ipv4 = { 
     82        .hook           = imq_nf_hook, 
     83        .owner          = THIS_MODULE, 
     84        .pf             = PF_INET, 
     85        .hooknum        = NF_INET_PRE_ROUTING, 
     86#if defined(CONFIG_IMQ_BEHAVIOR_BA) || defined(CONFIG_IMQ_BEHAVIOR_BB) 
     87        .priority       = NF_IP_PRI_MANGLE + 1 
     88#else 
     89        .priority       = NF_IP_PRI_NAT_DST + 1 
     90#endif 
     91}; 
     92 
     93static struct nf_hook_ops imq_egress_ipv4 = { 
     94        .hook           = imq_nf_hook, 
     95        .owner          = THIS_MODULE, 
     96        .pf             = PF_INET, 
     97        .hooknum        = NF_INET_POST_ROUTING, 
     98#if defined(CONFIG_IMQ_BEHAVIOR_AA) || defined(CONFIG_IMQ_BEHAVIOR_BA) 
     99        .priority       = NF_IP_PRI_LAST 
     100#else 
     101        .priority       = NF_IP_PRI_NAT_SRC - 1 
     102#endif 
     103}; 
     104 
     105#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 
     106static struct nf_hook_ops imq_ingress_ipv6 = { 
     107        .hook           = imq_nf_hook, 
     108        .owner          = THIS_MODULE, 
     109        .pf             = PF_INET6, 
     110        .hooknum        = NF_INET_PRE_ROUTING, 
     111#if defined(CONFIG_IMQ_BEHAVIOR_BA) || defined(CONFIG_IMQ_BEHAVIOR_BB) 
     112        .priority       = NF_IP6_PRI_MANGLE + 1 
     113#else 
     114        .priority       = NF_IP6_PRI_NAT_DST + 1 
     115#endif 
     116}; 
     117 
     118static struct nf_hook_ops imq_egress_ipv6 = { 
     119        .hook           = imq_nf_hook, 
     120        .owner          = THIS_MODULE, 
     121        .pf             = PF_INET6, 
     122        .hooknum        = NF_INET_POST_ROUTING, 
     123#if defined(CONFIG_IMQ_BEHAVIOR_AA) || defined(CONFIG_IMQ_BEHAVIOR_BA) 
     124        .priority       = NF_IP6_PRI_LAST 
     125#else 
     126        .priority       = NF_IP6_PRI_NAT_SRC - 1 
     127#endif 
     128}; 
     129#endif 
     130 
     131#if defined(CONFIG_IMQ_NUM_DEVS) 
     132static unsigned int numdevs = CONFIG_IMQ_NUM_DEVS; 
     133#else 
     134static unsigned int numdevs = 16; 
     135#endif 
     136 
     137static struct net_device *imq_devs; 
     138 
     139static struct net_device_stats *imq_get_stats(struct net_device *dev) 
     140{ 
     141        return &dev->stats; 
     142} 
     143 
     144/* called for packets kfree'd in qdiscs at places other than enqueue */ 
     145static void imq_skb_destructor(struct sk_buff *skb) 
     146{ 
     147        struct nf_queue_entry *entry = skb->nf_queue_entry; 
     148 
     149        if (entry) { 
     150                if (entry->indev) 
     151                        dev_put(entry->indev); 
     152                if (entry->outdev) 
     153                        dev_put(entry->outdev); 
     154                kfree(entry); 
     155        } 
     156} 
     157 
     158static int imq_dev_xmit(struct sk_buff *skb, struct net_device *dev) 
     159{ 
     160        dev->stats.tx_bytes += skb->len; 
     161        dev->stats.tx_packets++; 
     162 
     163        skb->imq_flags = 0; 
     164        skb->destructor = NULL; 
     165 
     166        dev->trans_start = jiffies; 
     167        nf_reinject(skb->nf_queue_entry, NF_ACCEPT); 
     168        return 0; 
     169} 
     170 
     171static int imq_nf_queue(struct nf_queue_entry *entry, unsigned queue_num) 
     172{ 
     173        struct net_device *dev; 
     174        struct imq_private *priv; 
     175        struct sk_buff *skb2 = NULL; 
     176        struct Qdisc *q; 
     177        unsigned int index = entry->skb->imq_flags & IMQ_F_IFMASK; 
     178        int ret = -1; 
     179 
     180        if (index > numdevs) 
     181                return -1; 
     182 
     183        dev = imq_devs + index; 
     184        priv = netdev_priv(dev); 
     185        if (!(dev->flags & IFF_UP)) { 
     186                entry->skb->imq_flags = 0; 
     187                nf_reinject(entry, NF_ACCEPT); 
     188                return 0; 
     189        } 
     190        dev->last_rx = jiffies; 
     191 
     192        if (entry->skb->destructor) { 
     193                skb2 = entry->skb; 
     194                entry->skb = skb_clone(entry->skb, GFP_ATOMIC); 
     195                if (!entry->skb) 
     196                        return -1; 
     197        } 
     198        entry->skb->nf_queue_entry = entry; 
     199 
     200        dev->stats.rx_bytes += entry->skb->len; 
     201        dev->stats.rx_packets++; 
     202 
     203        spin_lock_bh(&dev->queue_lock); 
     204        q = dev->qdisc; 
     205        if (q->enqueue) { 
     206                q->enqueue(skb_get(entry->skb), q); 
     207                if (skb_shared(entry->skb)) { 
     208                        entry->skb->destructor = imq_skb_destructor; 
     209                        kfree_skb(entry->skb); 
     210                        ret = 0; 
     211                } 
     212        } 
     213 
     214        spin_unlock_bh(&dev->queue_lock); 
     215 
     216        if (!test_and_set_bit(1, &priv->tasklet_pending)) 
     217                tasklet_schedule(&priv->tasklet); 
     218 
     219        if (skb2) 
     220                kfree_skb(ret ? entry->skb : skb2); 
     221 
     222        return ret; 
     223} 
     224 
     225static struct nf_queue_handler nfqh = { 
     226        .name  = "imq", 
     227        .outfn = imq_nf_queue, 
     228}; 
     229 
     230static void qdisc_run_tasklet(unsigned long arg) 
     231{ 
     232        struct net_device *dev = (struct net_device *)arg; 
     233        struct imq_private *priv = netdev_priv(dev); 
     234 
     235        spin_lock(&dev->queue_lock); 
     236        qdisc_run(dev); 
     237        spin_unlock(&dev->queue_lock); 
     238 
     239        clear_bit(1, &priv->tasklet_pending); 
     240} 
     241 
     242static unsigned int imq_nf_hook(unsigned int hook, struct sk_buff *pskb, 
     243                                const struct net_device *indev, 
     244                                const struct net_device *outdev, 
     245                                int (*okfn)(struct sk_buff *)) 
     246{ 
     247        if (pskb->imq_flags & IMQ_F_ENQUEUE) 
     248                return NF_QUEUE; 
     249 
     250        return NF_ACCEPT; 
     251} 
     252 
     253static int imq_close(struct net_device *dev) 
     254{ 
     255        struct imq_private *priv = netdev_priv(dev); 
     256 
     257        tasklet_kill(&priv->tasklet); 
     258        netif_stop_queue(dev); 
     259 
     260        return 0; 
     261} 
     262 
     263static int imq_open(struct net_device *dev) 
     264{ 
     265        struct imq_private *priv = netdev_priv(dev); 
     266 
     267        tasklet_init(&priv->tasklet, qdisc_run_tasklet, (unsigned long)dev); 
     268        netif_start_queue(dev); 
     269 
     270        return 0; 
     271} 
     272 
     273static int __init imq_init_hooks(void) 
     274{ 
     275        int err; 
     276 
     277        err = nf_register_queue_handler(PF_INET, &nfqh); 
     278        if (err) 
     279                goto err1; 
     280 
     281        err = nf_register_hook(&imq_ingress_ipv4); 
     282        if (err) 
     283                goto err2; 
     284 
     285        err = nf_register_hook(&imq_egress_ipv4); 
     286        if (err) 
     287                goto err3; 
     288 
     289#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 
     290        err = nf_register_queue_handler(PF_INET6, &nfqh); 
     291        if (err) 
     292                goto err4; 
     293 
     294        err = nf_register_hook(&imq_ingress_ipv6); 
     295        if (err) 
     296                goto err5; 
     297 
     298        err = nf_register_hook(&imq_egress_ipv6); 
     299        if (err) 
     300                goto err6; 
     301#endif 
     302 
     303        return 0; 
     304 
     305#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 
     306err6: 
     307        nf_unregister_hook(&imq_ingress_ipv6); 
     308err5: 
     309        nf_unregister_queue_handler(PF_INET6, &nfqh); 
     310err4: 
     311        nf_unregister_hook(&imq_egress_ipv4); 
     312#endif 
     313err3: 
     314        nf_unregister_hook(&imq_ingress_ipv4); 
     315err2: 
     316        nf_unregister_queue_handler(PF_INET, &nfqh); 
     317err1: 
     318        return err; 
     319} 
     320 
     321static void __exit imq_unhook(void) 
     322{ 
     323#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) 
     324        nf_unregister_hook(&imq_ingress_ipv6); 
     325        nf_unregister_hook(&imq_egress_ipv6); 
     326        nf_unregister_queue_handler(PF_INET6, &nfqh); 
     327#endif 
     328        nf_unregister_hook(&imq_ingress_ipv4); 
     329        nf_unregister_hook(&imq_egress_ipv4); 
     330        nf_unregister_queue_handler(PF_INET, &nfqh); 
     331} 
     332 
     333static int __init imq_dev_init(struct net_device *dev) 
     334{ 
     335        dev->hard_start_xmit    = imq_dev_xmit; 
     336        dev->open               = imq_open; 
     337        dev->get_stats          = imq_get_stats; 
     338        dev->stop               = imq_close; 
     339        dev->type               = ARPHRD_VOID; 
     340        dev->mtu                = 16000; 
     341        dev->tx_queue_len       = 11000; 
     342        dev->flags              = IFF_NOARP; 
     343 
     344        dev->priv = kzalloc(sizeof(struct imq_private), GFP_KERNEL); 
     345        if (dev->priv == NULL) 
     346                return -ENOMEM; 
     347 
     348        return 0; 
     349} 
     350 
     351static void imq_dev_uninit(struct net_device *dev) 
     352{ 
     353        kfree(dev->priv); 
     354} 
     355 
     356static int __init imq_init_devs(struct net *net) 
     357{ 
     358        struct net_device *dev; 
     359        int i, j; 
     360 
     361        if (!numdevs || numdevs > IMQ_MAX_DEVS) { 
     362                printk(KERN_ERR "IMQ: numdevs has to be betweed 1 and %u\n", 
     363                       IMQ_MAX_DEVS); 
     364                return -EINVAL; 
     365        } 
     366 
     367        imq_devs = kzalloc(sizeof(struct net_device) * numdevs, GFP_KERNEL); 
     368        if (!imq_devs) 
     369                return -ENOMEM; 
     370 
     371        /* we start counting at zero */ 
     372        j = numdevs - 1; 
     373 
     374        for (i = 0, dev = imq_devs; i <= j; i++, dev++) { 
     375                strcpy(dev->name, "imq%d"); 
     376                dev->init   = imq_dev_init; 
     377                dev->uninit = imq_dev_uninit; 
     378                dev->nd_net = net; 
     379 
     380                if (register_netdev(dev) < 0) 
     381                        goto err_register; 
     382        } 
     383        printk(KERN_INFO "IMQ starting with %u devices...\n", numdevs); 
     384        return 0; 
     385 
     386err_register: 
     387        for (; i; i--) 
     388                unregister_netdev(--dev); 
     389        kfree(imq_devs); 
     390        return -EIO; 
     391} 
     392 
     393static void imq_cleanup_devs(void) 
     394{ 
     395        int i; 
     396        struct net_device *dev = imq_devs; 
     397 
     398        for (i = 0; i <= numdevs; i++) 
     399                unregister_netdev(dev++); 
     400 
     401        kfree(imq_devs); 
     402} 
     403 
     404static __net_init int imq_init_module(struct net *net) 
     405{ 
     406        int err; 
     407 
     408        err = imq_init_devs(net); 
     409        if (err) { 
     410                printk(KERN_ERR "IMQ: Error trying imq_init_devs(net)\n"); 
     411                return err; 
     412        } 
     413 
     414        err = imq_init_hooks(); 
     415        if (err) { 
     416                printk(KERN_ERR "IMQ: Error trying imq_init_hooks()\n"); 
     417                imq_cleanup_devs(); 
     418                return err; 
     419        } 
     420 
     421        printk(KERN_INFO "IMQ driver loaded successfully.\n"); 
     422 
     423#if defined(CONFIG_IMQ_BEHAVIOR_BA) || defined(CONFIG_IMQ_BEHAVIOR_BB) 
     424        printk(KERN_INFO "\tHooking IMQ before NAT on PREROUTING.\n"); 
     425#else 
     426        printk(KERN_INFO "\tHooking IMQ after NAT on PREROUTING.\n"); 
     427#endif 
     428#if defined(CONFIG_IMQ_BEHAVIOR_AB) || defined(CONFIG_IMQ_BEHAVIOR_BB) 
     429        printk(KERN_INFO "\tHooking IMQ before NAT on POSTROUTING.\n"); 
     430#else 
     431        printk(KERN_INFO "\tHooking IMQ after NAT on POSTROUTING.\n"); 
     432#endif 
     433 
     434        return 0; 
     435} 
     436 
     437static __net_exit void imq_exit_module(struct net *net) 
     438{ 
     439        imq_unhook(); 
     440        imq_cleanup_devs(); 
     441        printk(KERN_INFO "IMQ driver unloaded successfully.\n"); 
     442} 
     443 
     444static struct pernet_operations __net_initdata imq_net_ops = { 
     445        .init = imq_init_module, 
     446        .exit = imq_exit_module, 
     447}; 
     448 
     449static int __init imq_init(void) 
     450{ 
     451        return register_pernet_device(&imq_net_ops); 
     452} 
     453 
     454module_init(imq_init); 
     455/*module_exit(imq_cleanup_module);*/ 
     456 
     457module_param(numdevs, int, 0); 
     458MODULE_PARM_DESC(numdevs, "number of IMQ devices (how many imq* devices will " 
     459                        "be created)"); 
     460MODULE_AUTHOR("http://www.linuximq.net"); 
     461MODULE_DESCRIPTION("Pseudo-driver for the intermediate queue device. See " 
     462                        "http://www.linuximq.net/ for more information."); 
     463MODULE_LICENSE("GPL"); 
     464 
  • drivers/net/Kconfig

    a b  
    117117          To compile this driver as a module, choose M here: the module 
    118118          will be called eql.  If unsure, say N. 
    119119 
     120config IMQ 
     121        tristate "IMQ (intermediate queueing device) support" 
     122        depends on NETDEVICES && NETFILTER 
     123        ---help--- 
     124          The IMQ device(s) is used as placeholder for QoS queueing 
     125          disciplines. Every packet entering/leaving the IP stack can be 
     126          directed through the IMQ device where it's enqueued/dequeued to the 
     127          attached qdisc. This allows you to treat network devices as classes 
     128          and distribute bandwidth among them. Iptables is used to specify 
     129          through which IMQ device, if any, packets travel. 
     130 
     131          More information at: http://www.linuximq.net/ 
     132 
     133          To compile this driver as a module, choose M here: the module 
     134          will be called imq.  If unsure, say N. 
     135 
     136choice 
     137        prompt "IMQ behavior (PRE/POSTROUTING)" 
     138        depends on IMQ 
     139        default IMQ_BEHAVIOR_BB 
     140        help 
     141 
     142                This settings defines how IMQ behaves in respect to its 
     143                hooking in PREROUTING and POSTROUTING. 
     144 
     145                IMQ can work in any of the following ways: 
     146 
     147                    PREROUTING   |      POSTROUTING 
     148                -----------------|------------------- 
     149                #1  After NAT    |      After NAT 
     150                #2  After NAT    |      Before NAT 
     151                #3  Before NAT   |      After NAT 
     152                #4  Before NAT   |      Before NAT 
     153 
     154                The default behavior is to hook before NAT on PREROUTING 
     155                and after NAT on POSTROUTING (#3). 
     156 
     157                This settings are specially usefull when trying to use IMQ 
     158                to shape NATed clients. 
     159 
     160                More information can be found at: www.linuximq.net 
     161 
     162                If not sure leave the default settings alone. 
     163 
     164config IMQ_BEHAVIOR_AA 
     165        bool "IMQ AA" 
     166        help 
     167                This settings defines how IMQ behaves in respect to its 
     168                hooking in PREROUTING and POSTROUTING. 
     169 
     170                Choosing this option will make IMQ hook like this: 
     171 
     172                PREROUTING:   After NAT 
     173                POSTROUTING:  After NAT 
     174 
     175                More information can be found at: www.linuximq.net 
     176 
     177                If not sure leave the default settings alone. 
     178 
     179config IMQ_BEHAVIOR_AB 
     180        bool "IMQ AB" 
     181        help 
     182                This settings defines how IMQ behaves in respect to its 
     183                hooking in PREROUTING and POSTROUTING. 
     184 
     185                Choosing this option will make IMQ hook like this: 
     186 
     187                PREROUTING:   After NAT 
     188                POSTROUTING:  Before NAT 
     189 
     190                More information can be found at: www.linuximq.net 
     191 
     192                If not sure leave the default settings alone. 
     193 
     194config IMQ_BEHAVIOR_BA 
     195        bool "IMQ BA" 
     196        help 
     197                This settings defines how IMQ behaves in respect to its 
     198                hooking in PREROUTING and POSTROUTING. 
     199 
     200                Choosing this option will make IMQ hook like this: 
     201 
     202                PREROUTING:   Before NAT 
     203                POSTROUTING:  After NAT 
     204 
     205                More information can be found at: www.linuximq.net 
     206 
     207                If not sure leave the default settings alone. 
     208 
     209config IMQ_BEHAVIOR_BB 
     210        bool "IMQ BB" 
     211        help 
     212                This settings defines how IMQ behaves in respect to its 
     213                hooking in PREROUTING and POSTROUTING. 
     214 
     215                Choosing this option will make IMQ hook like this: 
     216 
     217                PREROUTING:   Before NAT 
     218                POSTROUTING:  Before NAT 
     219 
     220                More information can be found at: www.linuximq.net 
     221 
     222                If not sure leave the default settings alone. 
     223 
     224endchoice 
     225 
     226config IMQ_NUM_DEVS 
     227 
     228        int "Number of IMQ devices" 
     229        range 2 16 
     230        depends on IMQ 
     231        default "16" 
     232        help 
     233 
     234                This settings defines how many IMQ devices will be 
     235                created. 
     236 
     237                The default value is 16. 
     238 
     239                More information can be found at: www.linuximq.net 
     240 
     241                If not sure leave the default settings alone. 
     242 
    120243config TUN 
    121244        tristate "Universal TUN/TAP device driver support" 
    122245        select CRC32 
  • drivers/net/Makefile

    a b  
    142142obj-$(CONFIG_XEN_NETDEV_FRONTEND) += xen-netfront.o 
    143143 
    144144obj-$(CONFIG_DUMMY) += dummy.o 
     145obj-$(CONFIG_IMQ) += imq.o 
    145146obj-$(CONFIG_IFB) += ifb.o 
    146147obj-$(CONFIG_MACVLAN) += macvlan.o 
    147148obj-$(CONFIG_DE600) += de600.o 
  • new file include/linux/imq.h

    - +  
     1#ifndef _IMQ_H 
     2#define _IMQ_H 
     3 
     4#define IMQ_MAX_DEVS   16 
     5 
     6#define IMQ_F_IFMASK   0x7f 
     7#define IMQ_F_ENQUEUE  0x80 
     8 
     9#endif /* _IMQ_H */ 
  • new file include/linux/netfilter_ipv4/ipt_IMQ.h

    - +  
     1#ifndef _IPT_IMQ_H 
     2#define _IPT_IMQ_H 
     3 
     4struct ipt_imq_info { 
     5        unsigned int todev;     /* target imq device */ 
     6}; 
     7 
     8#endif /* _IPT_IMQ_H */ 
  • new file include/linux/netfilter_ipv6/ip6t_IMQ.h

    - +  
     1#ifndef _IP6T_IMQ_H 
     2#define _IP6T_IMQ_H 
     3 
     4struct ip6t_imq_info { 
     5        unsigned int todev;     /* target imq device */ 
     6}; 
     7 
     8#endif /* _IP6T_IMQ_H */ 
  • include/linux/skbuff.h

    a b  
    300300        struct nf_conntrack     *nfct; 
    301301        struct sk_buff          *nfct_reasm; 
    302302#endif 
     303#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE) 
     304        unsigned char                   imq_flags; 
     305        struct nf_queue_entry   *nf_queue_entry; 
     306#endif 
    303307#ifdef CONFIG_BRIDGE_NETFILTER 
    304308        struct nf_bridge_info   *nf_bridge; 
    305309#endif 
     
    16331637        dst->nfct_reasm = src->nfct_reasm; 
    16341638        nf_conntrack_get_reasm(src->nfct_reasm); 
    16351639#endif 
     1640#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE) 
     1641        dst->imq_flags = src->imq_flags; 
     1642        dst->nf_queue_entry = src->nf_queue_entry; 
     1643#endif 
    16361644#ifdef CONFIG_BRIDGE_NETFILTER 
    16371645        dst->nf_bridge  = src->nf_bridge; 
    16381646        nf_bridge_get(src->nf_bridge); 
  • net/core/dev.c

    a b  
    9595#include <net/net_namespace.h> 
    9696#include <net/sock.h> 
    9797#include <linux/rtnetlink.h> 
     98#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE) 
     99#include <linux/imq.h> 
     100#endif 
    98101#include <linux/proc_fs.h> 
    99102#include <linux/seq_file.h> 
    100103#include <linux/stat.h> 
     
    15451548int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 
    15461549{ 
    15471550        if (likely(!skb->next)) { 
    1548                 if (!list_empty(&ptype_all)) 
     1551                if (!list_empty(&ptype_all) 
     1552#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE) 
     1553                    && !(skb->imq_flags & IMQ_F_ENQUEUE) 
     1554#endif 
     1555                    ) 
    15491556                        dev_queue_xmit_nit(skb, dev); 
    15501557 
    15511558                if (netif_needs_gso(dev, skb)) { 
  • new file net/ipv4/netfilter/ipt_IMQ.c

    - +  
     1/* 
     2 * This target marks packets to be enqueued to an imq device 
     3 */ 
     4#include <linux/module.h> 
     5#include <linux/skbuff.h> 
     6#include <linux/netfilter_ipv4/ip_tables.h> 
     7#include <linux/netfilter_ipv4/ipt_IMQ.h> 
     8#include <linux/imq.h> 
     9 
     10static unsigned int imq_target(struct sk_buff *pskb, 
     11                               const struct net_device *in, 
     12                               const struct net_device *out, 
     13                               unsigned int hooknum, 
     14                               const struct xt_target *target, 
     15                               const void *targinfo) 
     16{ 
     17        struct ipt_imq_info *mr = (struct ipt_imq_info*)targinfo; 
     18 
     19        pskb->imq_flags = mr->todev | IMQ_F_ENQUEUE; 
     20 
     21        return XT_CONTINUE; 
     22} 
     23 
     24static bool imq_checkentry(const char *tablename, 
     25                          const void *e, 
     26                          const struct xt_target *target, 
     27                          void *targinfo, 
     28                          unsigned int hook_mask) 
     29{ 
     30        struct ipt_imq_info *mr; 
     31 
     32        mr = (struct ipt_imq_info*)targinfo; 
     33 
     34        if (mr->todev > IMQ_MAX_DEVS) { 
     35                printk(KERN_WARNING 
     36                       "IMQ: invalid device specified, highest is %u\n", 
     37                       IMQ_MAX_DEVS); 
     38                return 0; 
     39        } 
     40 
     41        return 1; 
     42} 
     43 
     44static struct xt_target ipt_imq_reg = { 
     45        .name           = "IMQ", 
     46        .family         = AF_INET, 
     47        .target         = imq_target, 
     48        .targetsize     = sizeof(struct ipt_imq_info), 
     49        .checkentry     = imq_checkentry, 
     50        .me             = THIS_MODULE, 
     51        .table          = "mangle" 
     52}; 
     53 
     54static int __init init(void) 
     55{ 
     56        return xt_register_target(&ipt_imq_reg); 
     57} 
     58 
     59static void __exit fini(void) 
     60{ 
     61        xt_unregister_target(&ipt_imq_reg); 
     62} 
     63 
     64module_init(init); 
     65module_exit(fini); 
     66 
     67MODULE_AUTHOR("http://www.linuximq.net"); 
     68MODULE_DESCRIPTION("Pseudo-driver for the intermediate queue device. See http://www.linuximq.net/ for more information."); 
     69MODULE_LICENSE("GPL"); 
  • net/ipv4/netfilter/Kconfig

    a b  
    145145 
    146146          To compile it as a module, choose M here.  If unsure, say N. 
    147147 
     148config IP_NF_TARGET_IMQ 
     149       tristate "IMQ target support" 
     150       depends on IP_NF_MANGLE 
     151       help 
     152         This option adds a `IMQ' target which is used to specify if and 
     153         to which IMQ device packets should get enqueued/dequeued. 
     154 
     155         For more information visit: http://www.linuximq.net/ 
     156 
     157         To compile it as a module, choose M here.  If unsure, say N. 
     158 
    148159config IP_NF_TARGET_REJECT 
    149160        tristate "REJECT target support" 
    150161        depends on IP_NF_FILTER 
  • net/ipv4/netfilter/Makefile

    a b  
    5858obj-$(CONFIG_IP_NF_TARGET_CLUSTERIP) += ipt_CLUSTERIP.o 
    5959obj-$(CONFIG_IP_NF_TARGET_ECN) += ipt_ECN.o 
    6060obj-$(CONFIG_IP_NF_TARGET_LOG) += ipt_LOG.o 
     61obj-$(CONFIG_IP_NF_TARGET_IMQ) += ipt_IMQ.o 
    6162obj-$(CONFIG_IP_NF_TARGET_MASQUERADE) += ipt_MASQUERADE.o 
    6263obj-$(CONFIG_IP_NF_TARGET_NETMAP) += ipt_NETMAP.o 
    6364obj-$(CONFIG_IP_NF_TARGET_REDIRECT) += ipt_REDIRECT.o 
  • new file net/ipv6/netfilter/ip6t_IMQ.c

    - +  
     1/* 
     2 * This target marks packets to be enqueued to an imq device 
     3 */ 
     4#include <linux/module.h> 
     5#include <linux/skbuff.h> 
     6#include <linux/netfilter_ipv6/ip6_tables.h> 
     7#include <linux/netfilter_ipv6/ip6t_IMQ.h> 
     8#include <linux/imq.h> 
     9 
     10static unsigned int imq_target(struct sk_buff *pskb, 
     11                               const struct net_device *in, 
     12                               const struct net_device *out, 
     13                               unsigned int hooknum, 
     14                               const struct xt_target *target, 
     15                               const void *targinfo) 
     16{ 
     17        struct ip6t_imq_info *mr = (struct ip6t_imq_info*)targinfo; 
     18 
     19        pskb->imq_flags = mr->todev | IMQ_F_ENQUEUE; 
     20 
     21        return XT_CONTINUE; 
     22} 
     23 
     24static bool imq_checkentry(const char *tablename, 
     25                          const void *entry, 
     26                          const struct xt_target *target, 
     27                          void *targinfo, 
     28                          unsigned int hook_mask) 
     29{ 
     30        struct ip6t_imq_info *mr; 
     31 
     32        mr = (struct ip6t_imq_info*)targinfo; 
     33 
     34        if (mr->todev > IMQ_MAX_DEVS) { 
     35                printk(KERN_WARNING 
     36                       "IMQ: invalid device specified, highest is %u\n", 
     37                       IMQ_MAX_DEVS); 
     38                return 0; 
     39        } 
     40 
     41        return 1; 
     42} 
     43 
     44static struct xt_target ip6t_imq_reg = { 
     45        .name           = "IMQ", 
     46        .family         = AF_INET6, 
     47        .target         = imq_target, 
     48        .targetsize     = sizeof(struct ip6t_imq_info), 
     49        .table          = "mangle", 
     50        .checkentry     = imq_checkentry, 
     51        .me             = THIS_MODULE 
     52}; 
     53 
     54static int __init init(void) 
     55{ 
     56        return xt_register_target(&ip6t_imq_reg); 
     57} 
     58 
     59static void __exit fini(void) 
     60{ 
     61        xt_unregister_target(&ip6t_imq_reg); 
     62} 
     63 
     64module_init(init); 
     65module_exit(fini); 
     66 
     67MODULE_AUTHOR("http://www.linuximq.net"); 
     68MODULE_DESCRIPTION("Pseudo-driver for the intermediate queue device. See http://www.linuximq.net/ for more information."); 
     69MODULE_LICENSE("GPL"); 
  • net/ipv6/netfilter/Kconfig

    a b  
    179179 
    180180          To compile it as a module, choose M here.  If unsure, say N. 
    181181 
     182config IP6_NF_TARGET_IMQ 
     183        tristate "IMQ target support" 
     184        depends on IP6_NF_MANGLE 
     185        help 
     186          This option adds a `IMQ' target which is used to specify if and 
     187          to which imq device packets should get enqueued/dequeued. 
     188 
     189          To compile it as a module, choose M here.  If unsure, say N. 
     190 
    182191config IP6_NF_TARGET_HL 
    183192        tristate  'HL (hoplimit) target support' 
    184193        depends on IP6_NF_MANGLE 
  • net/ipv6/netfilter/Makefile

    a b  
    66obj-$(CONFIG_IP6_NF_IPTABLES) += ip6_tables.o 
    77obj-$(CONFIG_IP6_NF_FILTER) += ip6table_filter.o 
    88obj-$(CONFIG_IP6_NF_MANGLE) += ip6table_mangle.o 
     9obj-$(CONFIG_IP6_NF_TARGET_IMQ) += ip6t_IMQ.o 
    910obj-$(CONFIG_IP6_NF_QUEUE) += ip6_queue.o 
    1011obj-$(CONFIG_IP6_NF_RAW) += ip6table_raw.o 
    1112 
  • net/sched/sch_generic.c

    a b  
    203203 
    204204        clear_bit(__LINK_STATE_QDISC_RUNNING, &dev->state); 
    205205} 
     206EXPORT_SYMBOL(__qdisc_run); 
    206207 
    207208static void dev_watchdog(unsigned long arg) 
    208209{ 
Note: See TracBrowser for help on using the repository browser.