/* * This is a module which is used for queueing IPv4 packets and * communicating with userspace via netlink. * * (C) 2000 James Morris, this code is GPL. * * 2002-01-10: I modified this code slight to offer more comparisions... - Luke Klein-Berndt * 2000-03-27: Simplified code (thanks to Andi Kleen for clues). * 2000-05-20: Fixed notifier problems (following Miguel Freitas' report). * 2000-06-19: Fixed so nfmark is copied to metadata (reported by Sebastian *             Zander). * 2000-08-01: Added Nick Williams' MAC support. * */#include "packet_queue.h"#define IPQ_QMAX_DEFAULT 1024#define IPQ_PROC_FS_NAME "ip_queue"#define NET_IPQ_QMAX 2088#define NET_IPQ_QMAX_NAME "ip_queue_maxlen"typedef struct ipq_rt_info {    __u8 tos;    __u32 daddr;    __u32 saddr;} ipq_rt_info_t;typedef struct ipq_queue_element {    struct list_head list;		/* Links element into queue */    int verdict;			/* Current verdict */    struct nf_info *info;		/* Extra info from netfilter */    struct sk_buff *skb;		/* Packet inside */    ipq_rt_info_t rt_info;		/* May need post-mangle routing */} ipq_queue_element_t;typedef int (*ipq_send_cb_t)(ipq_queue_element_t *e);typedef struct ipq_queue {    int len;			/* Current queue len */    int *maxlen;			/* Maximum queue len, via sysctl */    unsigned char flushing;		/* If queue is being flushed */    unsigned char terminate;	/* If the queue is being terminated */    struct list_head list;		/* Head of packet queue */    spinlock_t lock;		/* Queue spinlock */} ipq_queue_t;static ipq_queue_t *q;static int netfilter_receive(struct sk_buff *skb, struct nf_info *info, void *data);/**************************************************************************** * * Packet queue * ****************************************************************************//* Dequeue a packet if matched by cmp, or the next available if cmp is NULL */static ipq_queue_element_t * ipq_dequeue( int (*cmp)(ipq_queue_element_t *, u_int32_t), u_int32_t data){    struct list_head *i;    spin_lock_bh(&q->lock);    for (i = q->list.prev; i != &q->list; i = i->prev) {        ipq_queue_element_t *e = (ipq_queue_element_t *)i;        if (!cmp || cmp(e, data)) {            list_del(&e->list);            q->len--;            spin_unlock_bh(&q->lock);            return e;        }    }    spin_unlock_bh(&q->lock);    return NULL;}/* Flush all packets */static void ipq_flush(){    ipq_queue_element_t *e;    spin_lock_bh(&q->lock);    q->flushing = 1;    spin_unlock_bh(&q->lock);    while ((e = ipq_dequeue( NULL, 0))) {        e->verdict = NF_DROP;        nf_reinject(e->skb, e->info, e->verdict);        kfree(e);    }    spin_lock_bh(&q->lock);    q->flushing = 0;    spin_unlock_bh(&q->lock);}static int ipq_create_queue(int *sysctl_qmax){    int status;    q = kmalloc(sizeof(ipq_queue_t), GFP_KERNEL);    if (q == NULL) {        return 0;    }    q->len = 0;    q->maxlen = sysctl_qmax;    q->flushing = 0;    q->terminate = 0;    INIT_LIST_HEAD(&q->list);    spin_lock_init(&q->lock);    status = nf_register_queue_handler(PF_INET, netfilter_receive, q);    if (status < 0) {      printk("Could not create Packet Queue! %d\n",status);        kfree(q);        return 0;    }    return 1;}static int ipq_enqueue(ipq_queue_t *g,struct sk_buff *skb, struct nf_info *info){    ipq_queue_element_t *e;    if (q!=g)    {        printk("trying to enqueue but do not have right queue!!!\n");        return 0;    }    e = kmalloc(sizeof(*e), GFP_ATOMIC);    if (e == NULL) {        printk(KERN_ERR "ip_queue: OOM in enqueue\n");        return -ENOMEM;    }    e->verdict = NF_DROP;    e->info = info;    e->skb = skb;    if (e->info->hook == NF_IP_LOCAL_OUT) {        struct iphdr *iph = skb->nh.iph;        e->rt_info.tos = iph->tos;        e->rt_info.daddr = iph->daddr;        e->rt_info.saddr = iph->saddr;    }    spin_lock_bh(&q->lock);    if (q->len >= *q->maxlen) {        spin_unlock_bh(&q->lock);        if (net_ratelimit())            printk(KERN_WARNING "ip_queue: full at %d entries, "                   "dropping packet(s).\n", q->len);        goto free_drop;    }    if (q->flushing || q->terminate) {        spin_unlock_bh(&q->lock);        goto free_drop;    }    list_add(&e->list, &q->list);    q->len++;    spin_unlock_bh(&q->lock);    return q->len;free_drop:    kfree(e);    return -EBUSY;}static void ipq_destroy_queue(){    nf_unregister_queue_handler(PF_INET);    spin_lock_bh(&q->lock);    q->terminate = 1;    spin_unlock_bh(&q->lock);    ipq_flush();    kfree(q);}/* With a chainsaw... */static int route_me_harder(struct sk_buff *skb){    struct iphdr *iph = skb->nh.iph;    struct rtable *rt;    struct rt_key key = {                    dst:iph->daddr, src:iph->saddr,                    oif:skb->sk ? skb->sk->bound_dev_if : 0,                    tos:RT_TOS(iph->tos)|RTO_CONN,#ifdef CONFIG_IP_ROUTE_FWMARK                    fwmark:skb->nfmark#endif                        };    if (ip_route_output_key(&rt, &key) != 0) {        printk("route_me_harder: No more route.\n");        return -EINVAL;    }    /* Drop old route. */    dst_release(skb->dst);    skb->dst = &rt->u.dst;    return 0;}static inline int id_cmp(ipq_queue_element_t *e,u_int32_t id){    return (id == (unsigned long )e);}static inline int dev_cmp(ipq_queue_element_t *e, u_int32_t ifindex){    if (e->info->indev)        if (e->info->indev->ifindex == ifindex)            return 1;    if (e->info->outdev)        if (e->info->outdev->ifindex == ifindex)            return 1;    return 0;}static inline int ip_cmp(ipq_queue_element_t *e, u_int32_t ip){    if (e->rt_info.daddr == ip)        return 1;    return 0;}/* Drop any queued packets associated with device ifindex */static void ipq_dev_drop(int ifindex){    ipq_queue_element_t *e;    while ((e = ipq_dequeue(dev_cmp,  ifindex))) {        e->verdict = NF_DROP;        nf_reinject(e->skb, e->info, e->verdict);        kfree(e);    }}void ipq_send_ip(u_int32_t ip){    ipq_queue_element_t *e;    while ((e = ipq_dequeue( ip_cmp, ip))) {        e->verdict = NF_ACCEPT;	        e->skb->nfcache |= NFC_ALTERED;        route_me_harder(e->skb);        nf_reinject(e->skb, e->info, e->verdict);        kfree(e);    }}void ipq_drop_ip(u_int32_t ip){    ipq_queue_element_t *e;    while ((e = ipq_dequeue( ip_cmp, ip))) {        e->verdict = NF_DROP;	icmp_send(e->skb,ICMP_DEST_UNREACH,ICMP_HOST_UNREACH,0);	nf_reinject(e->skb, e->info, e->verdict);        kfree(e);    }}/**************************************************************************** * * Netfilter interface * ****************************************************************************//* * Packets arrive here from netfilter for queuing to userspace. * All of them must be fed back via nf_reinject() or Alexey will kill Rusty. */int ipq_insert_packet(struct sk_buff *skb,                      struct nf_info *info){    return ipq_enqueue(q, skb, info);}static int netfilter_receive(struct sk_buff *skb,                             struct nf_info *info, void *data){    return ipq_enqueue((ipq_queue_t *)data, skb, info);}/**************************************************************************** * * System events * ****************************************************************************/static int receive_event(struct notifier_block *this,                         unsigned long event, void *ptr){    struct net_device *dev = ptr;    /* Drop any packets associated with the downed device */    if (event == NETDEV_DOWN)        ipq_dev_drop( dev->ifindex);    return NOTIFY_DONE;}struct notifier_block ipq_dev_notifier = {            receive_event,            NULL,            0        };/**************************************************************************** * * Sysctl - queue tuning. * ****************************************************************************/static int sysctl_maxlen = IPQ_QMAX_DEFAULT;static struct ctl_table_header *ipq_sysctl_header;static ctl_table ipq_table[] = {                                   { NET_IPQ_QMAX, NET_IPQ_QMAX_NAME, &sysctl_maxlen,                                     sizeof(sysctl_maxlen), 0644,  NULL, proc_dointvec },                                   { 0 }                               };static ctl_table ipq_dir_table[] = {                                       {NET_IPV4, "ipv4", NULL, 0, 0555, ipq_table, 0, 0, 0, 0, 0},                                       { 0 }                                   };static ctl_table ipq_root_table[] = {                                        {CTL_NET, "net", NULL, 0, 0555, ipq_dir_table, 0, 0, 0, 0, 0},                                        { 0 }                                    };/**************************************************************************** * * Module stuff. * ****************************************************************************/int init_packet_queue(void){    int status = 0;    //struct proc_dir_entry *proc;    status= ipq_create_queue(  &sysctl_maxlen);    if (status == 0) {        printk(KERN_ERR "ip_queue: initialisation failed: unable to "               "create queue\n");        return status;    }    /*	proc = proc_net_create(IPQ_PROC_FS_NAME, 0, ipq_get_info);    	if (proc) proc->owner = THIS_MODULE;    	else {    		ipq_destroy_queue(nlq);    		sock_release(nfnl->socket);    		return -ENOMEM;    	}*/    ipq_sysctl_header = register_sysctl_table(ipq_root_table, 0);    return status;}void cleanup_packet_queue(void){    unregister_sysctl_table(ipq_sysctl_header);    //proc_net_remove(IPQ_PROC_FS_NAME);    ipq_destroy_queue(q);}