Fixed repo

[linux-2.6.git] / linux-2.6-595-vserver-new-netns.patch

diff -Nurb linux-2.6.22-594/include/linux/vserver/network.h.orig.orig linux-2.6.22-595/include/linux/vserver/network.h.orig.orig
--- linux-2.6.22-594/include/linux/vserver/network.h.orig.orig  2008-03-20 01:27:27.000000000 -0400
+++ linux-2.6.22-595/include/linux/vserver/network.h.orig.orig  1969-12-31 19:00:00.000000000 -0500
@@ -1,143 +0,0 @@
-#ifndef _VX_NETWORK_H
-#define _VX_NETWORK_H
-
-#include <linux/types.h>
-
-
-#define MAX_N_CONTEXT  65535   /* Arbitrary limit */
-
-
-/* network flags */
-
-#define NXF_INFO_PRIVATE       0x00000008
-
-#define NXF_SINGLE_IP          0x00000100
-#define NXF_LBACK_REMAP                0x00000200
-
-#define NXF_HIDE_NETIF         0x02000000
-#define NXF_HIDE_LBACK         0x04000000
-
-#define NXF_STATE_SETUP                (1ULL << 32)
-#define NXF_STATE_ADMIN                (1ULL << 34)
-
-#define NXF_SC_HELPER          (1ULL << 36)
-#define NXF_PERSISTENT         (1ULL << 38)
-
-#define NXF_ONE_TIME           (0x0005ULL << 32)
-
-
-#define        NXF_INIT_SET            (__nxf_init_set())
-
-static inline uint64_t __nxf_init_set(void) {
-       return    NXF_STATE_ADMIN
-#ifdef CONFIG_VSERVER_AUTO_LBACK
-               | NXF_LBACK_REMAP
-               | NXF_HIDE_LBACK
-#endif
-#ifdef CONFIG_VSERVER_AUTO_SINGLE
-               | NXF_SINGLE_IP
-#endif
-               | NXF_HIDE_NETIF;
-}
-
-
-/* network caps */
-
-#define NXC_RAW_ICMP           0x00000100
-
-
-/* address types */
-
-#define NXA_TYPE_IPV4          0x0001
-#define NXA_TYPE_IPV6          0x0002
-
-#define NXA_TYPE_NONE          0x0000
-#define NXA_TYPE_ANY           0x00FF
-
-#define NXA_TYPE_ADDR          0x0010
-#define NXA_TYPE_MASK          0x0020
-#define NXA_TYPE_RANGE         0x0040
-
-#define NXA_MASK_ALL           (NXA_TYPE_ADDR | NXA_TYPE_MASK | NXA_TYPE_RANGE)
-
-#define NXA_MOD_BCAST          0x0100
-#define NXA_MOD_LBACK          0x0200
-
-#define NXA_LOOPBACK           0x1000
-
-#define NXA_MASK_BIND          (NXA_MASK_ALL | NXA_MOD_BCAST | NXA_MOD_LBACK)
-#define NXA_MASK_SHOW          (NXA_MASK_ALL | NXA_LOOPBACK)
-
-#ifdef __KERNEL__
-
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include <linux/rcupdate.h>
-#include <linux/in.h>
-#include <linux/in6.h>
-#include <asm/atomic.h>
-
-struct nx_addr_v4 {
-       struct nx_addr_v4 *next;
-       struct in_addr ip[2];
-       struct in_addr mask;
-       uint16_t type;
-       uint16_t flags;
-};
-
-struct nx_addr_v6 {
-       struct nx_addr_v6 *next;
-       struct in6_addr ip;
-       struct in6_addr mask;
-       uint32_t prefix;
-       uint16_t type;
-       uint16_t flags;
-};
-
-struct nx_info {
-       struct hlist_node nx_hlist;     /* linked list of nxinfos */
-       nid_t nx_id;                    /* vnet id */
-       atomic_t nx_usecnt;             /* usage count */
-       atomic_t nx_tasks;              /* tasks count */
-       int nx_state;                   /* context state */
-
-       uint64_t nx_flags;              /* network flag word */
-       uint64_t nx_ncaps;              /* network capabilities */
-
-       struct in_addr v4_lback;        /* Loopback address */
-       struct in_addr v4_bcast;        /* Broadcast address */
-       struct nx_addr_v4 v4;           /* First/Single ipv4 address */
-#ifdef CONFIG_IPV6
-       struct nx_addr_v6 v6;           /* First/Single ipv6 address */
-#endif
-       char nx_name[65];               /* network context name */
-};
-
-
-/* status flags */
-
-#define NXS_HASHED      0x0001
-#define NXS_SHUTDOWN    0x0100
-#define NXS_RELEASED    0x8000
-
-extern struct nx_info *lookup_nx_info(int);
-
-extern int get_nid_list(int, unsigned int *, int);
-extern int nid_is_hashed(nid_t);
-
-extern int nx_migrate_task(struct task_struct *, struct nx_info *);
-
-extern long vs_net_change(struct nx_info *, unsigned int);
-
-struct sock;
-
-
-#define NX_IPV4(n)     ((n)->v4.type != NXA_TYPE_NONE)
-#ifdef  CONFIG_IPV6
-#define NX_IPV6(n)     ((n)->v6.type != NXA_TYPE_NONE)
-#else
-#define NX_IPV6(n)     (0)
-#endif
-
-#endif /* __KERNEL__ */
-#endif /* _VX_NETWORK_H */
diff -Nurb linux-2.6.22-594/kernel/nsproxy.c.orig linux-2.6.22-595/kernel/nsproxy.c.orig
--- linux-2.6.22-594/kernel/nsproxy.c.orig      2008-03-20 01:27:50.000000000 -0400
+++ linux-2.6.22-595/kernel/nsproxy.c.orig      1969-12-31 19:00:00.000000000 -0500
@@ -1,264 +0,0 @@
-/*
- *  Copyright (C) 2006 IBM Corporation
- *
- *  Author: Serge Hallyn <serue@us.ibm.com>
- *
- *  This program is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU General Public License as
- *  published by the Free Software Foundation, version 2 of the
- *  License.
- *
- *  Jun 2006 - namespaces support
- *             OpenVZ, SWsoft Inc.
- *             Pavel Emelianov <xemul@openvz.org>
- */
-
-#include <linux/module.h>
-#include <linux/version.h>
-#include <linux/nsproxy.h>
-#include <linux/init_task.h>
-#include <linux/mnt_namespace.h>
-#include <linux/utsname.h>
-#include <net/net_namespace.h>
-#include <linux/pid_namespace.h>
-#include <linux/vserver/global.h>
-#include <linux/vserver/debug.h>
-
-static struct kmem_cache *nsproxy_cachep;
-
-struct nsproxy init_nsproxy = INIT_NSPROXY(init_nsproxy);
-
-void get_task_namespaces(struct task_struct *tsk)
-{
-       struct nsproxy *ns = tsk->nsproxy;
-       if (ns) {
-               get_nsproxy(ns);
-       }
-}
-
-/*
- * creates a copy of "orig" with refcount 1.
- */
-static inline struct nsproxy *clone_nsproxy(struct nsproxy *orig)
-{
-       struct nsproxy *ns;
-
-       ns = kmemdup(orig, sizeof(struct nsproxy), GFP_KERNEL);
-       if (ns)
-               atomic_set(&ns->count, 1);
-       vxdprintk(VXD_CBIT(space, 2), "clone_nsproxy(%p[%u] = %p[1]",
-               orig, atomic_read(&orig->count), ns);
-       atomic_inc(&vs_global_nsproxy);
-       return ns;
-}
-
-/*
- * Create new nsproxy and all of its the associated namespaces.
- * Return the newly created nsproxy.  Do not attach this to the task,
- * leave it to the caller to do proper locking and attach it to task.
- */
-static struct nsproxy *unshare_namespaces(int flags, struct nsproxy *orig,
-                       struct fs_struct *new_fs)
-{
-       struct nsproxy *new_nsp;
-       int err = -ENOMEM;
-
-       vxdprintk(VXD_CBIT(space, 4),
-               "unshare_namespaces(0x%08x,%p,%p)",
-               flags, orig, new_fs);
-
-       new_nsp = clone_nsproxy(orig);
-       if (!new_nsp)
-               return ERR_PTR(-ENOMEM);
-
-       new_nsp->mnt_ns = copy_mnt_ns(flags, orig->mnt_ns, new_fs);
-       if (IS_ERR(new_nsp->mnt_ns))
-               goto out_ns;
-
-       new_nsp->uts_ns = copy_utsname(flags, orig->uts_ns);
-       if (IS_ERR(new_nsp->uts_ns))
-               goto out_uts;
-
-       new_nsp->ipc_ns = copy_ipcs(flags, orig->ipc_ns);
-       if (IS_ERR(new_nsp->ipc_ns))
-               goto out_ipc;
-
-       new_nsp->pid_ns = copy_pid_ns(flags, orig->pid_ns);
-       if (IS_ERR(new_nsp->pid_ns))
-               goto out_pid;
-
-       new_nsp->user_ns = copy_user_ns(flags, orig->user_ns);
-       if (IS_ERR(new_nsp->user_ns))
-               goto out_user;
-
-       new_nsp->net_ns = copy_net_ns(flags, orig->net_ns);
-       if (IS_ERR(new_nsp->net_ns))
-               goto out_net;
-
-       return new_nsp;
-
-out_net:
-       if (new_nsp->user_ns)
-               put_user_ns(new_nsp->user_ns);
-       if (new_nsp->net_ns)
-               put_net(new_nsp->net_ns);
-out_user:
-       if (new_nsp->pid_ns)
-               put_pid_ns(new_nsp->pid_ns);
-out_pid:
-       if (new_nsp->ipc_ns)
-               put_ipc_ns(new_nsp->ipc_ns);
-out_ipc:
-       if (new_nsp->uts_ns)
-               put_uts_ns(new_nsp->uts_ns);
-out_uts:
-       if (new_nsp->mnt_ns)
-               put_mnt_ns(new_nsp->mnt_ns);
-out_ns:
-       kmem_cache_free(nsproxy_cachep, new_nsp);
-       return ERR_PTR(err);
-}
-
-static struct nsproxy *create_new_namespaces(unsigned long flags, struct task_struct *tsk,
-                       struct fs_struct *new_fs)
-{
-       return unshare_namespaces(flags, tsk->nsproxy, new_fs);
-}
-
-/*
- * copies the nsproxy, setting refcount to 1, and grabbing a
- * reference to all contained namespaces.
- */
-struct nsproxy *copy_nsproxy(struct nsproxy *orig)
-{
-       struct nsproxy *ns = clone_nsproxy(orig);
-
-       if (ns) {
-               if (ns->mnt_ns)
-                       get_mnt_ns(ns->mnt_ns);
-               if (ns->uts_ns)
-                       get_uts_ns(ns->uts_ns);
-               if (ns->ipc_ns)
-                       get_ipc_ns(ns->ipc_ns);
-               if (ns->pid_ns)
-                       get_pid_ns(ns->pid_ns);
-       }
-       return ns;
-}
-
-/*
- * called from clone.  This now handles copy for nsproxy and all
- * namespaces therein.
- */
-int copy_namespaces(unsigned long flags, struct task_struct *tsk)
-{
-       struct nsproxy *old_ns = tsk->nsproxy;
-       struct nsproxy *new_ns = NULL;
-       int err = 0;
-
-       vxdprintk(VXD_CBIT(space, 7), "copy_namespaces(0x%08x,%p[%p])",
-               flags, tsk, old_ns);
-
-       if (!old_ns)
-               return 0;
-
-       get_nsproxy(old_ns);
-       return 0;
-
-       if (!(flags & (CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWIPC | CLONE_NEWUSER | CLONE_NEWNET)))
-               return 0;
-
-        #ifndef CONFIG_NET_NS
-               if (unshare_flags & CLONE_NEWNET)
-                       return -EINVAL;
-        #endif
-
-
-       if (!capable(CAP_SYS_ADMIN)) {
-               err = -EPERM;
-               goto out;
-       }
-
-       new_ns = create_new_namespaces(flags, tsk, tsk->fs);
-       if (IS_ERR(new_ns)) {
-               err = PTR_ERR(new_ns);
-               goto out;
-       }
-
-       err = ns_container_clone(tsk);
-       if (err) {
-               put_nsproxy(new_ns);
-               goto out;
-       }
-
-       tsk->nsproxy = new_ns;
-
-out:
-       put_nsproxy(old_ns);
-       vxdprintk(VXD_CBIT(space, 3),
-               "copy_namespaces(0x%08x,%p[%p]) = %d [%p]",
-               flags, tsk, old_ns, err, new_ns);
-       return err;
-}
-
-void free_nsproxy(struct nsproxy *ns)
-{
-       if (ns->mnt_ns)
-               put_mnt_ns(ns->mnt_ns);
-       if (ns->uts_ns)
-               put_uts_ns(ns->uts_ns);
-       if (ns->ipc_ns)
-               put_ipc_ns(ns->ipc_ns);
-       if (ns->pid_ns)
-               put_pid_ns(ns->pid_ns);
-       atomic_dec(&vs_global_nsproxy);
-       kfree(ns);
-}
-
-/*
- * Called from unshare. Unshare all the namespaces part of nsproxy.
- * On success, returns the new nsproxy.
- */
-int unshare_nsproxy_namespaces(unsigned long unshare_flags,
-               struct nsproxy **new_nsp, struct fs_struct *new_fs)
-{
-       int err = 0;
-
-       vxdprintk(VXD_CBIT(space, 4),
-               "unshare_nsproxy_namespaces(0x%08lx,[%p])",
-               unshare_flags, current->nsproxy);
-
-       if (!(unshare_flags & (CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWIPC |
-                              CLONE_NEWUSER | CLONE_NEWNET)))
-               return 0;
-
-#ifndef CONFIG_NET_NS
-       if (unshare_flags & CLONE_NEWNET)
-               return -EINVAL;
-#endif
-       if (!capable(CAP_SYS_ADMIN))
-               return -EPERM;
-
-       *new_nsp = create_new_namespaces(unshare_flags, current,
-                               new_fs ? new_fs : current->fs);
-       if (IS_ERR(*new_nsp)) {
-               err = PTR_ERR(*new_nsp);
-               goto out;
-       }
-
-       err = ns_container_clone(current);
-       if (err)
-               put_nsproxy(*new_nsp);
-
-out:
-       return err;
-}
-
-static int __init nsproxy_cache_init(void)
-{
-       nsproxy_cachep = kmem_cache_create("nsproxy", sizeof(struct nsproxy),
-                                          0, SLAB_PANIC, NULL, NULL);
-       return 0;
-}
-
-module_init(nsproxy_cache_init);
diff -Nurb linux-2.6.22-594/kernel/user.c.orig linux-2.6.22-595/kernel/user.c.orig
--- linux-2.6.22-594/kernel/user.c.orig 2008-03-20 01:27:50.000000000 -0400
+++ linux-2.6.22-595/kernel/user.c.orig 1969-12-31 19:00:00.000000000 -0500
@@ -1,227 +0,0 @@
-/*
- * The "user cache".
- *
- * (C) Copyright 1991-2000 Linus Torvalds
- *
- * We have a per-user structure to keep track of how many
- * processes, files etc the user has claimed, in order to be
- * able to have per-user limits for system resources. 
- */
-
-#include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/bitops.h>
-#include <linux/key.h>
-#include <linux/interrupt.h>
-#include <linux/module.h>
-#include <linux/user_namespace.h>
-
-/*
- * UID task count cache, to get fast user lookup in "alloc_uid"
- * when changing user ID's (ie setuid() and friends).
- */
-
-#define UIDHASH_MASK           (UIDHASH_SZ - 1)
-#define __uidhashfn(xid,uid)   ((((uid) >> UIDHASH_BITS) + ((uid)^(xid))) & UIDHASH_MASK)
-#define uidhashentry(ns, xid, uid)     ((ns)->uidhash_table + __uidhashfn(xid, uid))
-
-static struct kmem_cache *uid_cachep;
-static struct list_head uidhash_table[UIDHASH_SZ];
-
-/*
- * The uidhash_lock is mostly taken from process context, but it is
- * occasionally also taken from softirq/tasklet context, when
- * task-structs get RCU-freed. Hence all locking must be softirq-safe.
- * But free_uid() is also called with local interrupts disabled, and running
- * local_bh_enable() with local interrupts disabled is an error - we'll run
- * softirq callbacks, and they can unconditionally enable interrupts, and
- * the caller of free_uid() didn't expect that..
- */
-static DEFINE_SPINLOCK(uidhash_lock);
-
-struct user_struct root_user = {
-       .__count        = ATOMIC_INIT(1),
-       .processes      = ATOMIC_INIT(1),
-       .files          = ATOMIC_INIT(0),
-       .sigpending     = ATOMIC_INIT(0),
-       .mq_bytes       = 0,
-       .locked_shm     = 0,
-#ifdef CONFIG_KEYS
-       .uid_keyring    = &root_user_keyring,
-       .session_keyring = &root_session_keyring,
-#endif
-};
-
-/*
- * These routines must be called with the uidhash spinlock held!
- */
-static inline void uid_hash_insert(struct user_struct *up, struct list_head *hashent)
-{
-       list_add(&up->uidhash_list, hashent);
-}
-
-static inline void uid_hash_remove(struct user_struct *up)
-{
-       list_del(&up->uidhash_list);
-}
-
-static inline struct user_struct *uid_hash_find(xid_t xid, uid_t uid, struct list_head *hashent)
-{
-       struct list_head *up;
-
-       list_for_each(up, hashent) {
-               struct user_struct *user;
-
-               user = list_entry(up, struct user_struct, uidhash_list);
-
-               if(user->uid == uid && user->xid == xid) {
-                       atomic_inc(&user->__count);
-                       return user;
-               }
-       }
-
-       return NULL;
-}
-
-/*
- * Locate the user_struct for the passed UID.  If found, take a ref on it.  The
- * caller must undo that ref with free_uid().
- *
- * If the user_struct could not be found, return NULL.
- */
-struct user_struct *find_user(xid_t xid, uid_t uid)
-{
-       struct user_struct *ret;
-       unsigned long flags;
-       struct user_namespace *ns = current->nsproxy->user_ns;
-
-       spin_lock_irqsave(&uidhash_lock, flags);
-       ret = uid_hash_find(xid, uid, uidhashentry(ns, xid, uid));
-       spin_unlock_irqrestore(&uidhash_lock, flags);
-       return ret;
-}
-
-void free_uid(struct user_struct *up)
-{
-       unsigned long flags;
-
-       if (!up)
-               return;
-
-       local_irq_save(flags);
-       if (atomic_dec_and_lock(&up->__count, &uidhash_lock)) {
-               uid_hash_remove(up);
-               spin_unlock_irqrestore(&uidhash_lock, flags);
-               key_put(up->uid_keyring);
-               key_put(up->session_keyring);
-               kmem_cache_free(uid_cachep, up);
-       } else {
-               local_irq_restore(flags);
-       }
-}
-
-struct user_struct * alloc_uid(xid_t xid, uid_t uid)
-{
-       struct user_namespace *ns = current->nsproxy->user_ns;
-       struct list_head *hashent = uidhashentry(ns,xid, uid);
-       struct user_struct *up;
-
-       spin_lock_irq(&uidhash_lock);
-       up = uid_hash_find(xid, uid, hashent);
-       spin_unlock_irq(&uidhash_lock);
-
-       if (!up) {
-               struct user_struct *new;
-
-               new = kmem_cache_alloc(uid_cachep, GFP_KERNEL);
-               if (!new)
-                       return NULL;
-               new->uid = uid;
-               new->xid = xid;
-               atomic_set(&new->__count, 1);
-               atomic_set(&new->processes, 0);
-               atomic_set(&new->files, 0);
-               atomic_set(&new->sigpending, 0);
-#ifdef CONFIG_INOTIFY_USER
-               atomic_set(&new->inotify_watches, 0);
-               atomic_set(&new->inotify_devs, 0);
-#endif
-
-               new->mq_bytes = 0;
-               new->locked_shm = 0;
-
-               if (alloc_uid_keyring(new, current) < 0) {
-                       kmem_cache_free(uid_cachep, new);
-                       return NULL;
-               }
-
-               /*
-                * Before adding this, check whether we raced
-                * on adding the same user already..
-                */
-               spin_lock_irq(&uidhash_lock);
-               up = uid_hash_find(xid, uid, hashent);
-               if (up) {
-                       key_put(new->uid_keyring);
-                       key_put(new->session_keyring);
-                       kmem_cache_free(uid_cachep, new);
-               } else {
-                       uid_hash_insert(new, hashent);
-                       up = new;
-               }
-               spin_unlock_irq(&uidhash_lock);
-
-       }
-       return up;
-}
-
-void switch_uid(struct user_struct *new_user)
-{
-       struct user_struct *old_user;
-
-       /* What if a process setreuid()'s and this brings the
-        * new uid over his NPROC rlimit?  We can check this now
-        * cheaply with the new uid cache, so if it matters
-        * we should be checking for it.  -DaveM
-        */
-       old_user = current->user;
-       atomic_inc(&new_user->processes);
-       atomic_dec(&old_user->processes);
-       switch_uid_keyring(new_user);
-       current->user = new_user;
-
-       /*
-        * We need to synchronize with __sigqueue_alloc()
-        * doing a get_uid(p->user).. If that saw the old
-        * user value, we need to wait until it has exited
-        * its critical region before we can free the old
-        * structure.
-        */
-       smp_mb();
-       spin_unlock_wait(&current->sighand->siglock);
-
-       free_uid(old_user);
-       suid_keys(current);
-}
-
-
-static int __init uid_cache_init(void)
-{
-       int n;
-
-       uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
-                       0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
-
-       for(n = 0; n < UIDHASH_SZ; ++n)
-               INIT_LIST_HEAD(init_user_ns.uidhash_table + n);
-
-       /* Insert the root user immediately (init already runs as root) */
-       spin_lock_irq(&uidhash_lock);
-       uid_hash_insert(&root_user, uidhashentry(&init_user_ns, 0, 0));
-       spin_unlock_irq(&uidhash_lock);
-
-       return 0;
-}
-
-module_init(uid_cache_init);
diff -Nurb linux-2.6.22-594/kernel/vserver/context.c linux-2.6.22-595/kernel/vserver/context.c
--- linux-2.6.22-594/kernel/vserver/context.c   2008-03-20 01:27:21.000000000 -0400
+++ linux-2.6.22-595/kernel/vserver/context.c   2008-03-20 01:28:00.000000000 -0400
@@ -589,13 +589,13 @@
                        struct nsproxy *old_nsp, *new_nsp;
 
                        ret = unshare_nsproxy_namespaces(
-                               CLONE_NEWUTS | CLONE_NEWIPC,
+                               CLONE_NEWUTS | CLONE_NEWIPC | CLONE_NEWNET,
                                &new_nsp, NULL);
                        if (ret)
                                goto out;
 
                        old_nsp = xchg(&p->nsproxy, new_nsp);
-                       vx_set_space(vxi, CLONE_NEWUTS | CLONE_NEWIPC);
+                       vx_set_space(vxi, CLONE_NEWUTS | CLONE_NEWIPC | CLONE_NEWNET);
                        put_nsproxy(old_nsp);
                }
        }
@@ -781,7 +781,7 @@
        if (vs_state_change(new_vxi, VSC_STARTUP))
                goto out;
 
-       ret = vx_migrate_task(current, new_vxi, (!data));
+       ret = vx_migrate_task(current, new_vxi, 1 /*(!data) Hack no. 1 - Sapan*/);
        if (ret)
                goto out;
 
diff -Nurb linux-2.6.22-594/kernel/vserver/space.c linux-2.6.22-595/kernel/vserver/space.c
--- linux-2.6.22-594/kernel/vserver/space.c     2008-03-20 01:27:54.000000000 -0400
+++ linux-2.6.22-595/kernel/vserver/space.c     2008-03-20 01:28:00.000000000 -0400
@@ -15,6 +15,7 @@
 #include <linux/utsname.h>
 #include <linux/nsproxy.h>
 #include <linux/err.h>
+#include <net/net_namespace.h>
 #include <asm/uaccess.h>
 
 #include <linux/vs_context.h>
@@ -55,6 +56,7 @@
        struct mnt_namespace *old_ns;
        struct uts_namespace *old_uts;
        struct ipc_namespace *old_ipc;
+       struct net *old_net;
        struct nsproxy *nsproxy;
 
        nsproxy = copy_nsproxy(old_nsproxy);
@@ -85,12 +87,26 @@
        } else
                old_ipc = NULL;
 
+       if (mask & CLONE_NEWNET) {
+               old_net = nsproxy->net_ns;
+               nsproxy->net_ns = new_nsproxy->net_ns;
+               if (nsproxy->net_ns) {
+                       get_net(nsproxy->net_ns);
+                       printk(KERN_ALERT "Cloning network namespace\n"); 
+               }       
+       } else
+               old_net = NULL;
+
+
        if (old_ns)
                put_mnt_ns(old_ns);
        if (old_uts)
                put_uts_ns(old_uts);
        if (old_ipc)
                put_ipc_ns(old_ipc);
+       if (old_net)
+               put_net(old_net);
+
 out:
        return nsproxy;
 }
@@ -251,6 +267,7 @@
 
 int vc_enter_space(struct vx_info *vxi, void __user *data)
 {
+       /* Ask dhozac how to pass this flag from user space - Sapan*/
        struct vcmd_space_mask vc_data = { .mask = 0 };
 
        if (data && copy_from_user(&vc_data, data, sizeof(vc_data)))
diff -Nurb linux-2.6.22-594/net/core/dev.c linux-2.6.22-595/net/core/dev.c
--- linux-2.6.22-594/net/core/dev.c     2008-03-20 01:27:55.000000000 -0400
+++ linux-2.6.22-595/net/core/dev.c     2008-03-20 01:32:22.000000000 -0400
@@ -2207,7 +2207,7 @@
 
        total = 0;
        for_each_netdev(net, dev) {
-               if (!nx_dev_visible(current->nx_info, dev))
+               if (net==&init_net && !nx_dev_visible(current->nx_info, dev))
                        continue;
                for (i = 0; i < NPROTO; i++) {
                        if (gifconf_list[i]) {
@@ -2274,8 +2274,9 @@
 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
 {
        struct net_device_stats *stats = dev->get_stats(dev);
+       struct net *net = seq->private;
 
-       if (!nx_dev_visible(current->nx_info, dev))
+       if (net==&init_net && !nx_dev_visible(current->nx_info, dev))
                return;
 
        seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
diff -Nurb linux-2.6.22-594/net/core/dev.c.orig linux-2.6.22-595/net/core/dev.c.orig
--- linux-2.6.22-594/net/core/dev.c.orig        1969-12-31 19:00:00.000000000 -0500
+++ linux-2.6.22-595/net/core/dev.c.orig        2008-03-20 01:27:55.000000000 -0400
@@ -0,0 +1,4141 @@
+/*
+ *     NET3    Protocol independent device support routines.
+ *
+ *             This program is free software; you can redistribute it and/or
+ *             modify it under the terms of the GNU General Public License
+ *             as published by the Free Software Foundation; either version
+ *             2 of the License, or (at your option) any later version.
+ *
+ *     Derived from the non IP parts of dev.c 1.0.19
+ *             Authors:        Ross Biro
+ *                             Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *                             Mark Evans, <evansmp@uhura.aston.ac.uk>
+ *
+ *     Additional Authors:
+ *             Florian la Roche <rzsfl@rz.uni-sb.de>
+ *             Alan Cox <gw4pts@gw4pts.ampr.org>
+ *             David Hinds <dahinds@users.sourceforge.net>
+ *             Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
+ *             Adam Sulmicki <adam@cfar.umd.edu>
+ *              Pekka Riikonen <priikone@poesidon.pspt.fi>
+ *
+ *     Changes:
+ *              D.J. Barrow     :       Fixed bug where dev->refcnt gets set
+ *                                     to 2 if register_netdev gets called
+ *                                     before net_dev_init & also removed a
+ *                                     few lines of code in the process.
+ *             Alan Cox        :       device private ioctl copies fields back.
+ *             Alan Cox        :       Transmit queue code does relevant
+ *                                     stunts to keep the queue safe.
+ *             Alan Cox        :       Fixed double lock.
+ *             Alan Cox        :       Fixed promisc NULL pointer trap
+ *             ????????        :       Support the full private ioctl range
+ *             Alan Cox        :       Moved ioctl permission check into
+ *                                     drivers
+ *             Tim Kordas      :       SIOCADDMULTI/SIOCDELMULTI
+ *             Alan Cox        :       100 backlog just doesn't cut it when
+ *                                     you start doing multicast video 8)
+ *             Alan Cox        :       Rewrote net_bh and list manager.
+ *             Alan Cox        :       Fix ETH_P_ALL echoback lengths.
+ *             Alan Cox        :       Took out transmit every packet pass
+ *                                     Saved a few bytes in the ioctl handler
+ *             Alan Cox        :       Network driver sets packet type before
+ *                                     calling netif_rx. Saves a function
+ *                                     call a packet.
+ *             Alan Cox        :       Hashed net_bh()
+ *             Richard Kooijman:       Timestamp fixes.
+ *             Alan Cox        :       Wrong field in SIOCGIFDSTADDR
+ *             Alan Cox        :       Device lock protection.
+ *             Alan Cox        :       Fixed nasty side effect of device close
+ *                                     changes.
+ *             Rudi Cilibrasi  :       Pass the right thing to
+ *                                     set_mac_address()
+ *             Dave Miller     :       32bit quantity for the device lock to
+ *                                     make it work out on a Sparc.
+ *             Bjorn Ekwall    :       Added KERNELD hack.
+ *             Alan Cox        :       Cleaned up the backlog initialise.
+ *             Craig Metz      :       SIOCGIFCONF fix if space for under
+ *                                     1 device.
+ *         Thomas Bogendoerfer :       Return ENODEV for dev_open, if there
+ *                                     is no device open function.
+ *             Andi Kleen      :       Fix error reporting for SIOCGIFCONF
+ *         Michael Chastain    :       Fix signed/unsigned for SIOCGIFCONF
+ *             Cyrus Durgin    :       Cleaned for KMOD
+ *             Adam Sulmicki   :       Bug Fix : Network Device Unload
+ *                                     A network device unload needs to purge
+ *                                     the backlog queue.
+ *     Paul Rusty Russell      :       SIOCSIFNAME
+ *              Pekka Riikonen  :      Netdev boot-time settings code
+ *              Andrew Morton   :       Make unregister_netdevice wait
+ *                                     indefinitely on dev->refcnt
+ *             J Hadi Salim    :       - Backlog queue sampling
+ *                                     - netif_rx() feedback
+ */
+
+#include <asm/uaccess.h>
+#include <asm/system.h>
+#include <linux/bitops.h>
+#include <linux/capability.h>
+#include <linux/cpu.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/mutex.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/socket.h>
+#include <linux/sockios.h>
+#include <linux/errno.h>
+#include <linux/interrupt.h>
+#include <linux/if_ether.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/notifier.h>
+#include <linux/skbuff.h>
+#include <net/sock.h>
+#include <linux/rtnetlink.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <linux/stat.h>
+#include <linux/if_bridge.h>
+#include <net/dst.h>
+#include <net/pkt_sched.h>
+#include <net/checksum.h>
+#include <linux/highmem.h>
+#include <linux/init.h>
+#include <linux/kmod.h>
+#include <linux/module.h>
+#include <linux/kallsyms.h>
+#include <linux/netpoll.h>
+#include <linux/rcupdate.h>
+#include <linux/delay.h>
+#include <net/wext.h>
+#include <net/iw_handler.h>
+#include <asm/current.h>
+#include <linux/audit.h>
+#include <linux/dmaengine.h>
+#include <linux/err.h>
+#include <linux/ctype.h>
+#include <net/net_namespace.h>
+#include <linux/if_arp.h>
+#include <linux/vs_inet.h>
+
+/*
+ *     The list of packet types we will receive (as opposed to discard)
+ *     and the routines to invoke.
+ *
+ *     Why 16. Because with 16 the only overlap we get on a hash of the
+ *     low nibble of the protocol value is RARP/SNAP/X.25.
+ *
+ *      NOTE:  That is no longer true with the addition of VLAN tags.  Not
+ *             sure which should go first, but I bet it won't make much
+ *             difference if we are running VLANs.  The good news is that
+ *             this protocol won't be in the list unless compiled in, so
+ *             the average user (w/out VLANs) will not be adversely affected.
+ *             --BLG
+ *
+ *             0800    IP
+ *             8100    802.1Q VLAN
+ *             0001    802.3
+ *             0002    AX.25
+ *             0004    802.2
+ *             8035    RARP
+ *             0005    SNAP
+ *             0805    X.25
+ *             0806    ARP
+ *             8137    IPX
+ *             0009    Localtalk
+ *             86DD    IPv6
+ */
+
+static DEFINE_SPINLOCK(ptype_lock);
+static struct list_head ptype_base[16] __read_mostly;  /* 16 way hashed list */
+static struct list_head ptype_all __read_mostly;       /* Taps */
+
+#ifdef CONFIG_NET_DMA
+struct net_dma {
+       struct dma_client client;
+       spinlock_t lock;
+       cpumask_t channel_mask;
+       struct dma_chan *channels[NR_CPUS];
+};
+
+static enum dma_state_client
+netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
+       enum dma_state state);
+
+static struct net_dma net_dma = {
+       .client = {
+               .event_callback = netdev_dma_event,
+       },
+};
+#endif
+
+/*
+ * The @dev_base_head list is protected by @dev_base_lock and the rtnl
+ * semaphore.
+ *
+ * Pure readers hold dev_base_lock for reading.
+ *
+ * Writers must hold the rtnl semaphore while they loop through the
+ * dev_base_head list, and hold dev_base_lock for writing when they do the
+ * actual updates.  This allows pure readers to access the list even
+ * while a writer is preparing to update it.
+ *
+ * To put it another way, dev_base_lock is held for writing only to
+ * protect against pure readers; the rtnl semaphore provides the
+ * protection against other writers.
+ *
+ * See, for example usages, register_netdevice() and
+ * unregister_netdevice(), which must be called with the rtnl
+ * semaphore held.
+ */
+DEFINE_RWLOCK(dev_base_lock);
+
+EXPORT_SYMBOL(dev_base_lock);
+
+#define NETDEV_HASHBITS        8
+#define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
+
+static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
+{
+       unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
+       return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
+}
+
+static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
+{
+       return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
+}
+
+/* Device list insertion */
+static int list_netdevice(struct net_device *dev)
+{
+       struct net *net = dev->nd_net;
+
+       ASSERT_RTNL();
+
+       write_lock_bh(&dev_base_lock);
+       list_add_tail(&dev->dev_list, &net->dev_base_head);
+       hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
+       hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
+       write_unlock_bh(&dev_base_lock);
+       return 0;
+}
+
+/* Device list removal */
+static void unlist_netdevice(struct net_device *dev)
+{
+       ASSERT_RTNL();
+
+       /* Unlink dev from the device chain */
+       write_lock_bh(&dev_base_lock);
+       list_del(&dev->dev_list);
+       hlist_del(&dev->name_hlist);
+       hlist_del(&dev->index_hlist);
+       write_unlock_bh(&dev_base_lock);
+}
+
+/*
+ *     Our notifier list
+ */
+
+static RAW_NOTIFIER_HEAD(netdev_chain);
+
+/*
+ *     Device drivers call our routines to queue packets here. We empty the
+ *     queue in the local softnet handler.
+ */
+DEFINE_PER_CPU(struct softnet_data, softnet_data) = { NULL };
+
+#ifdef CONFIG_SYSFS
+extern int netdev_sysfs_init(void);
+extern int netdev_register_sysfs(struct net_device *);
+extern void netdev_unregister_sysfs(struct net_device *);
+#else
+#define netdev_sysfs_init()            (0)
+#define netdev_register_sysfs(dev)     (0)
+#define        netdev_unregister_sysfs(dev)    do { } while(0)
+#endif
+
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+/*
+ * register_netdevice() inits dev->_xmit_lock and sets lockdep class
+ * according to dev->type
+ */
+static const unsigned short netdev_lock_type[] =
+       {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
+        ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
+        ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
+        ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
+        ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
+        ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
+        ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
+        ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
+        ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
+        ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
+        ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
+        ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
+        ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
+        ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_VOID,
+        ARPHRD_NONE};
+
+static const char *netdev_lock_name[] =
+       {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
+        "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
+        "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
+        "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
+        "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
+        "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
+        "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
+        "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
+        "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
+        "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
+        "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
+        "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
+        "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
+        "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_VOID",
+        "_xmit_NONE"};
+
+static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
+
+static inline unsigned short netdev_lock_pos(unsigned short dev_type)
+{
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
+               if (netdev_lock_type[i] == dev_type)
+                       return i;
+       /* the last key is used by default */
+       return ARRAY_SIZE(netdev_lock_type) - 1;
+}
+
+static inline void netdev_set_lockdep_class(spinlock_t *lock,
+                                           unsigned short dev_type)
+{
+       int i;
+
+       i = netdev_lock_pos(dev_type);
+       lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
+                                  netdev_lock_name[i]);
+}
+#else
+static inline void netdev_set_lockdep_class(spinlock_t *lock,
+                                           unsigned short dev_type)
+{
+}
+#endif
+
+/*******************************************************************************
+
+               Protocol management and registration routines
+
+*******************************************************************************/
+
+/*
+ *     Add a protocol ID to the list. Now that the input handler is
+ *     smarter we can dispense with all the messy stuff that used to be
+ *     here.
+ *
+ *     BEWARE!!! Protocol handlers, mangling input packets,
+ *     MUST BE last in hash buckets and checking protocol handlers
+ *     MUST start from promiscuous ptype_all chain in net_bh.
+ *     It is true now, do not change it.
+ *     Explanation follows: if protocol handler, mangling packet, will
+ *     be the first on list, it is not able to sense, that packet
+ *     is cloned and should be copied-on-write, so that it will
+ *     change it and subsequent readers will get broken packet.
+ *                                                     --ANK (980803)
+ */
+
+/**
+ *     dev_add_pack - add packet handler
+ *     @pt: packet type declaration
+ *
+ *     Add a protocol handler to the networking stack. The passed &packet_type
+ *     is linked into kernel lists and may not be freed until it has been
+ *     removed from the kernel lists.
+ *
+ *     This call does not sleep therefore it can not
+ *     guarantee all CPU's that are in middle of receiving packets
+ *     will see the new packet type (until the next received packet).
+ */
+
+void dev_add_pack(struct packet_type *pt)
+{
+       int hash;
+
+       spin_lock_bh(&ptype_lock);
+       if (pt->type == htons(ETH_P_ALL))
+               list_add_rcu(&pt->list, &ptype_all);
+       else {
+               hash = ntohs(pt->type) & 15;
+               list_add_rcu(&pt->list, &ptype_base[hash]);
+       }
+       spin_unlock_bh(&ptype_lock);
+}
+
+/**
+ *     __dev_remove_pack        - remove packet handler
+ *     @pt: packet type declaration
+ *
+ *     Remove a protocol handler that was previously added to the kernel
+ *     protocol handlers by dev_add_pack(). The passed &packet_type is removed
+ *     from the kernel lists and can be freed or reused once this function
+ *     returns.
+ *
+ *      The packet type might still be in use by receivers
+ *     and must not be freed until after all the CPU's have gone
+ *     through a quiescent state.
+ */
+void __dev_remove_pack(struct packet_type *pt)
+{
+       struct list_head *head;
+       struct packet_type *pt1;
+
+       spin_lock_bh(&ptype_lock);
+
+       if (pt->type == htons(ETH_P_ALL))
+               head = &ptype_all;
+       else
+               head = &ptype_base[ntohs(pt->type) & 15];
+
+       list_for_each_entry(pt1, head, list) {
+               if (pt == pt1) {
+                       list_del_rcu(&pt->list);
+                       goto out;
+               }
+       }
+
+       printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
+out:
+       spin_unlock_bh(&ptype_lock);
+}
+/**
+ *     dev_remove_pack  - remove packet handler
+ *     @pt: packet type declaration
+ *
+ *     Remove a protocol handler that was previously added to the kernel
+ *     protocol handlers by dev_add_pack(). The passed &packet_type is removed
+ *     from the kernel lists and can be freed or reused once this function
+ *     returns.
+ *
+ *     This call sleeps to guarantee that no CPU is looking at the packet
+ *     type after return.
+ */
+void dev_remove_pack(struct packet_type *pt)
+{
+       __dev_remove_pack(pt);
+
+       synchronize_net();
+}
+
+/******************************************************************************
+
+                     Device Boot-time Settings Routines
+
+*******************************************************************************/
+
+/* Boot time configuration table */
+static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
+
+/**
+ *     netdev_boot_setup_add   - add new setup entry
+ *     @name: name of the device
+ *     @map: configured settings for the device
+ *
+ *     Adds new setup entry to the dev_boot_setup list.  The function
+ *     returns 0 on error and 1 on success.  This is a generic routine to
+ *     all netdevices.
+ */
+static int netdev_boot_setup_add(char *name, struct ifmap *map)
+{
+       struct netdev_boot_setup *s;
+       int i;
+
+       s = dev_boot_setup;
+       for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
+               if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
+                       memset(s[i].name, 0, sizeof(s[i].name));
+                       strcpy(s[i].name, name);
+                       memcpy(&s[i].map, map, sizeof(s[i].map));
+                       break;
+               }
+       }
+
+       return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
+}
+
+/**
+ *     netdev_boot_setup_check - check boot time settings
+ *     @dev: the netdevice
+ *
+ *     Check boot time settings for the device.
+ *     The found settings are set for the device to be used
+ *     later in the device probing.
+ *     Returns 0 if no settings found, 1 if they are.
+ */
+int netdev_boot_setup_check(struct net_device *dev)
+{
+       struct netdev_boot_setup *s = dev_boot_setup;
+       int i;
+
+       for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
+               if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
+                   !strncmp(dev->name, s[i].name, strlen(s[i].name))) {
+                       dev->irq        = s[i].map.irq;
+                       dev->base_addr  = s[i].map.base_addr;
+                       dev->mem_start  = s[i].map.mem_start;
+                       dev->mem_end    = s[i].map.mem_end;
+                       return 1;
+               }
+       }
+       return 0;
+}
+
+
+/**
+ *     netdev_boot_base        - get address from boot time settings
+ *     @prefix: prefix for network device
+ *     @unit: id for network device
+ *
+ *     Check boot time settings for the base address of device.
+ *     The found settings are set for the device to be used
+ *     later in the device probing.
+ *     Returns 0 if no settings found.
+ */
+unsigned long netdev_boot_base(const char *prefix, int unit)
+{
+       const struct netdev_boot_setup *s = dev_boot_setup;
+       char name[IFNAMSIZ];
+       int i;
+
+       sprintf(name, "%s%d", prefix, unit);
+
+       /*
+        * If device already registered then return base of 1
+        * to indicate not to probe for this interface
+        */
+       if (__dev_get_by_name(&init_net, name))
+               return 1;
+
+       for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
+               if (!strcmp(name, s[i].name))
+                       return s[i].map.base_addr;
+       return 0;
+}
+
+/*
+ * Saves at boot time configured settings for any netdevice.
+ */
+int __init netdev_boot_setup(char *str)
+{
+       int ints[5];
+       struct ifmap map;
+
+       str = get_options(str, ARRAY_SIZE(ints), ints);
+       if (!str || !*str)
+               return 0;
+
+       /* Save settings */
+       memset(&map, 0, sizeof(map));
+       if (ints[0] > 0)
+               map.irq = ints[1];
+       if (ints[0] > 1)
+               map.base_addr = ints[2];
+       if (ints[0] > 2)
+               map.mem_start = ints[3];
+       if (ints[0] > 3)
+               map.mem_end = ints[4];
+
+       /* Add new entry to the list */
+       return netdev_boot_setup_add(str, &map);
+}
+
+__setup("netdev=", netdev_boot_setup);
+
+/*******************************************************************************
+
+                           Device Interface Subroutines
+
+*******************************************************************************/
+
+/**
+ *     __dev_get_by_name       - find a device by its name
+ *     @name: name to find
+ *
+ *     Find an interface by name. Must be called under RTNL semaphore
+ *     or @dev_base_lock. If the name is found a pointer to the device
+ *     is returned. If the name is not found then %NULL is returned. The
+ *     reference counters are not incremented so the caller must be
+ *     careful with locks.
+ */
+
+struct net_device *__dev_get_by_name(struct net *net, const char *name)
+{
+       struct hlist_node *p;
+
+       hlist_for_each(p, dev_name_hash(net, name)) {
+               struct net_device *dev
+                       = hlist_entry(p, struct net_device, name_hlist);
+               if (!strncmp(dev->name, name, IFNAMSIZ))
+                       return dev;
+       }
+       return NULL;
+}
+
+/**
+ *     dev_get_by_name         - find a device by its name
+ *     @name: name to find
+ *
+ *     Find an interface by name. This can be called from any
+ *     context and does its own locking. The returned handle has
+ *     the usage count incremented and the caller must use dev_put() to
+ *     release it when it is no longer needed. %NULL is returned if no
+ *     matching device is found.
+ */
+
+struct net_device *dev_get_by_name(struct net *net, const char *name)
+{
+       struct net_device *dev;
+
+       read_lock(&dev_base_lock);
+       dev = __dev_get_by_name(net, name);
+       if (dev)
+               dev_hold(dev);
+       read_unlock(&dev_base_lock);
+       return dev;
+}
+
+/**
+ *     __dev_get_by_index - find a device by its ifindex
+ *     @ifindex: index of device
+ *
+ *     Search for an interface by index. Returns %NULL if the device
+ *     is not found or a pointer to the device. The device has not
+ *     had its reference counter increased so the caller must be careful
+ *     about locking. The caller must hold either the RTNL semaphore
+ *     or @dev_base_lock.
+ */
+
+struct net_device *__dev_get_by_index(struct net *net, int ifindex)
+{
+       struct hlist_node *p;
+
+       hlist_for_each(p, dev_index_hash(net, ifindex)) {
+               struct net_device *dev
+                       = hlist_entry(p, struct net_device, index_hlist);
+               if (dev->ifindex == ifindex)
+                       return dev;
+       }
+       return NULL;
+}
+
+
+/**
+ *     dev_get_by_index - find a device by its ifindex
+ *     @ifindex: index of device
+ *
+ *     Search for an interface by index. Returns NULL if the device
+ *     is not found or a pointer to the device. The device returned has
+ *     had a reference added and the pointer is safe until the user calls
+ *     dev_put to indicate they have finished with it.
+ */
+
+struct net_device *dev_get_by_index(struct net *net, int ifindex)
+{
+       struct net_device *dev;
+
+       read_lock(&dev_base_lock);
+       dev = __dev_get_by_index(net, ifindex);
+       if (dev)
+               dev_hold(dev);
+       read_unlock(&dev_base_lock);
+       return dev;
+}
+
+/**
+ *     dev_getbyhwaddr - find a device by its hardware address
+ *     @type: media type of device
+ *     @ha: hardware address
+ *
+ *     Search for an interface by MAC address. Returns NULL if the device
+ *     is not found or a pointer to the device. The caller must hold the
+ *     rtnl semaphore. The returned device has not had its ref count increased
+ *     and the caller must therefore be careful about locking
+ *
+ *     BUGS:
+ *     If the API was consistent this would be __dev_get_by_hwaddr
+ */
+
+struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
+{
+       struct net_device *dev;
+
+       ASSERT_RTNL();
+
+       for_each_netdev(&init_net, dev)
+               if (dev->type == type &&
+                   !memcmp(dev->dev_addr, ha, dev->addr_len))
+                       return dev;
+
+       return NULL;
+}
+
+EXPORT_SYMBOL(dev_getbyhwaddr);
+
+struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
+{
+       struct net_device *dev;
+
+       ASSERT_RTNL();
+       for_each_netdev(net, dev)
+               if (dev->type == type)
+                       return dev;
+
+       return NULL;
+}
+
+EXPORT_SYMBOL(__dev_getfirstbyhwtype);
+
+struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
+{
+       struct net_device *dev;
+
+       rtnl_lock();
+       dev = __dev_getfirstbyhwtype(net, type);
+       if (dev)
+               dev_hold(dev);
+       rtnl_unlock();
+       return dev;
+}
+
+EXPORT_SYMBOL(dev_getfirstbyhwtype);
+
+/**
+ *     dev_get_by_flags - find any device with given flags
+ *     @if_flags: IFF_* values
+ *     @mask: bitmask of bits in if_flags to check
+ *
+ *     Search for any interface with the given flags. Returns NULL if a device
+ *     is not found or a pointer to the device. The device returned has
+ *     had a reference added and the pointer is safe until the user calls
+ *     dev_put to indicate they have finished with it.
+ */
+
+struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
+{
+       struct net_device *dev, *ret;
+
+       ret = NULL;
+       read_lock(&dev_base_lock);
+       for_each_netdev(net, dev) {
+               if (((dev->flags ^ if_flags) & mask) == 0) {
+                       dev_hold(dev);
+                       ret = dev;
+                       break;
+               }
+       }
+       read_unlock(&dev_base_lock);
+       return ret;
+}
+
+/**
+ *     dev_valid_name - check if name is okay for network device
+ *     @name: name string
+ *
+ *     Network device names need to be valid file names to
+ *     to allow sysfs to work.  We also disallow any kind of
+ *     whitespace.
+ */
+int dev_valid_name(const char *name)
+{
+       if (*name == '\0')
+               return 0;
+       if (strlen(name) >= IFNAMSIZ)
+               return 0;
+       if (!strcmp(name, ".") || !strcmp(name, ".."))
+               return 0;
+
+       while (*name) {
+               if (*name == '/' || isspace(*name))
+                       return 0;
+               name++;
+       }
+       return 1;
+}
+
+/**
+ *     __dev_alloc_name - allocate a name for a device
+ *     @net: network namespace to allocate the device name in
+ *     @name: name format string
+ *     @buf:  scratch buffer and result name string
+ *
+ *     Passed a format string - eg "lt%d" it will try and find a suitable
+ *     id. It scans list of devices to build up a free map, then chooses
+ *     the first empty slot. The caller must hold the dev_base or rtnl lock
+ *     while allocating the name and adding the device in order to avoid
+ *     duplicates.
+ *     Limited to bits_per_byte * page size devices (ie 32K on most platforms).
+ *     Returns the number of the unit assigned or a negative errno code.
+ */
+
+static int __dev_alloc_name(struct net *net, const char *name, char *buf)
+{
+       int i = 0;
+       const char *p;
+       const int max_netdevices = 8*PAGE_SIZE;
+       long *inuse;
+       struct net_device *d;
+
+       p = strnchr(name, IFNAMSIZ-1, '%');
+       if (p) {
+               /*
+                * Verify the string as this thing may have come from
+                * the user.  There must be either one "%d" and no other "%"
+                * characters.
+                */
+               if (p[1] != 'd' || strchr(p + 2, '%'))
+                       return -EINVAL;
+
+               /* Use one page as a bit array of possible slots */
+               inuse = (long *) get_zeroed_page(GFP_ATOMIC);
+               if (!inuse)
+                       return -ENOMEM;
+
+               for_each_netdev(net, d) {
+                       if (!sscanf(d->name, name, &i))
+                               continue;
+                       if (i < 0 || i >= max_netdevices)
+                               continue;
+
+                       /*  avoid cases where sscanf is not exact inverse of printf */
+                       snprintf(buf, IFNAMSIZ, name, i);
+                       if (!strncmp(buf, d->name, IFNAMSIZ))
+                               set_bit(i, inuse);
+               }
+
+               i = find_first_zero_bit(inuse, max_netdevices);
+               free_page((unsigned long) inuse);
+       }
+
+       snprintf(buf, IFNAMSIZ, name, i);
+       if (!__dev_get_by_name(net, buf))
+               return i;
+
+       /* It is possible to run out of possible slots
+        * when the name is long and there isn't enough space left
+        * for the digits, or if all bits are used.
+        */
+       return -ENFILE;
+}
+
+/**
+ *     dev_alloc_name - allocate a name for a device
+ *     @dev: device
+ *     @name: name format string
+ *
+ *     Passed a format string - eg "lt%d" it will try and find a suitable
+ *     id. It scans list of devices to build up a free map, then chooses
+ *     the first empty slot. The caller must hold the dev_base or rtnl lock
+ *     while allocating the name and adding the device in order to avoid
+ *     duplicates.
+ *     Limited to bits_per_byte * page size devices (ie 32K on most platforms).
+ *     Returns the number of the unit assigned or a negative errno code.
+ */
+
+int dev_alloc_name(struct net_device *dev, const char *name)
+{
+       char buf[IFNAMSIZ];
+       struct net *net;
+       int ret;
+
+       BUG_ON(!dev->nd_net);
+       net = dev->nd_net;
+       ret = __dev_alloc_name(net, name, buf);
+       if (ret >= 0)
+               strlcpy(dev->name, buf, IFNAMSIZ);
+       return ret;
+}
+
+
+/**
+ *     dev_change_name - change name of a device
+ *     @dev: device
+ *     @newname: name (or format string) must be at least IFNAMSIZ
+ *
+ *     Change name of a device, can pass format strings "eth%d".
+ *     for wildcarding.
+ */
+int dev_change_name(struct net_device *dev, char *newname)
+{
+       int err = 0;
+       struct net *net;
+
+       ASSERT_RTNL();
+       BUG_ON(!dev->nd_net);
+
+       net = dev->nd_net;
+       if (dev->flags & IFF_UP)
+               return -EBUSY;
+
+       if (!dev_valid_name(newname))
+               return -EINVAL;
+
+       if (strchr(newname, '%')) {
+               err = dev_alloc_name(dev, newname);
+               if (err < 0)
+                       return err;
+               strcpy(newname, dev->name);
+       }
+       else if (__dev_get_by_name(net, newname))
+               return -EEXIST;
+       else {
+               if (strncmp(newname, dev->name, IFNAMSIZ))
+                       printk(KERN_INFO "%s renamed to %s\n",
+                                       dev->name, newname);
+               strlcpy(dev->name, newname, IFNAMSIZ);
+       }
+
+       device_rename(&dev->dev, dev->name);
+       hlist_del(&dev->name_hlist);
+       hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
+       raw_notifier_call_chain(&netdev_chain, NETDEV_CHANGENAME, dev);
+
+       return err;
+}
+
+/**
+ *     netdev_features_change - device changes features
+ *     @dev: device to cause notification
+ *
+ *     Called to indicate a device has changed features.
+ */
+void netdev_features_change(struct net_device *dev)
+{
+       raw_notifier_call_chain(&netdev_chain, NETDEV_FEAT_CHANGE, dev);
+}
+EXPORT_SYMBOL(netdev_features_change);
+
+/**
+ *     netdev_state_change - device changes state
+ *     @dev: device to cause notification
+ *
+ *     Called to indicate a device has changed state. This function calls
+ *     the notifier chains for netdev_chain and sends a NEWLINK message
+ *     to the routing socket.
+ */
+void netdev_state_change(struct net_device *dev)
+{
+       if (dev->flags & IFF_UP) {
+               raw_notifier_call_chain(&netdev_chain,
+                               NETDEV_CHANGE, dev);
+               rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
+       }
+}
+
+/**
+ *     dev_load        - load a network module
+ *     @name: name of interface
+ *
+ *     If a network interface is not present and the process has suitable
+ *     privileges this function loads the module. If module loading is not
+ *     available in this kernel then it becomes a nop.
+ */
+
+void dev_load(struct net *net, const char *name)
+{
+       struct net_device *dev;
+
+       read_lock(&dev_base_lock);
+       dev = __dev_get_by_name(net, name);
+       read_unlock(&dev_base_lock);
+
+       if (!dev && capable(CAP_SYS_MODULE))
+               request_module("%s", name);
+}
+
+static int default_rebuild_header(struct sk_buff *skb)
+{
+       printk(KERN_DEBUG "%s: default_rebuild_header called -- BUG!\n",
+              skb->dev ? skb->dev->name : "NULL!!!");
+       kfree_skb(skb);
+       return 1;
+}
+
+/**
+ *     dev_open        - prepare an interface for use.
+ *     @dev:   device to open
+ *
+ *     Takes a device from down to up state. The device's private open
+ *     function is invoked and then the multicast lists are loaded. Finally
+ *     the device is moved into the up state and a %NETDEV_UP message is
+ *     sent to the netdev notifier chain.
+ *
+ *     Calling this function on an active interface is a nop. On a failure
+ *     a negative errno code is returned.
+ */
+int dev_open(struct net_device *dev)
+{
+       int ret = 0;
+
+       /*
+        *      Is it already up?
+        */
+
+       if (dev->flags & IFF_UP)
+               return 0;
+
+       /*
+        *      Is it even present?
+        */
+       if (!netif_device_present(dev))
+               return -ENODEV;
+
+       /*
+        *      Call device private open method
+        */
+       set_bit(__LINK_STATE_START, &dev->state);
+       if (dev->open) {
+               ret = dev->open(dev);
+               if (ret)
+                       clear_bit(__LINK_STATE_START, &dev->state);
+       }
+
+       /*
+        *      If it went open OK then:
+        */
+
+       if (!ret) {
+               /*
+                *      Set the flags.
+                */
+               dev->flags |= IFF_UP;
+
+               /*
+                *      Initialize multicasting status
+                */
+               dev_mc_upload(dev);
+
+               /*
+                *      Wakeup transmit queue engine
+                */
+               dev_activate(dev);
+
+               /*
+                *      ... and announce new interface.
+                */
+               raw_notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
+       }
+       return ret;
+}
+
+/**
+ *     dev_close - shutdown an interface.
+ *     @dev: device to shutdown
+ *
+ *     This function moves an active device into down state. A
+ *     %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
+ *     is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
+ *     chain.
+ */
+int dev_close(struct net_device *dev)
+{
+       if (!(dev->flags & IFF_UP))
+               return 0;
+
+       /*
+        *      Tell people we are going down, so that they can
+        *      prepare to death, when device is still operating.
+        */
+       raw_notifier_call_chain(&netdev_chain, NETDEV_GOING_DOWN, dev);
+
+       dev_deactivate(dev);
+
+       clear_bit(__LINK_STATE_START, &dev->state);
+
+       /* Synchronize to scheduled poll. We cannot touch poll list,
+        * it can be even on different cpu. So just clear netif_running(),
+        * and wait when poll really will happen. Actually, the best place
+        * for this is inside dev->stop() after device stopped its irq
+        * engine, but this requires more changes in devices. */
+
+       smp_mb__after_clear_bit(); /* Commit netif_running(). */
+       while (test_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
+               /* No hurry. */
+               msleep(1);
+       }
+
+       /*
+        *      Call the device specific close. This cannot fail.
+        *      Only if device is UP
+        *
+        *      We allow it to be called even after a DETACH hot-plug
+        *      event.
+        */
+       if (dev->stop)
+               dev->stop(dev);
+
+       /*
+        *      Device is now down.
+        */
+
+       dev->flags &= ~IFF_UP;
+
+       /*
+        * Tell people we are down
+        */
+       raw_notifier_call_chain(&netdev_chain, NETDEV_DOWN, dev);
+
+       return 0;
+}
+
+
+static int dev_boot_phase = 1;
+
+/*
+ *     Device change register/unregister. These are not inline or static
+ *     as we export them to the world.
+ */
+
+/**
+ *     register_netdevice_notifier - register a network notifier block
+ *     @nb: notifier
+ *
+ *     Register a notifier to be called when network device events occur.
+ *     The notifier passed is linked into the kernel structures and must
+ *     not be reused until it has been unregistered. A negative errno code
+ *     is returned on a failure.
+ *
+ *     When registered all registration and up events are replayed
+ *     to the new notifier to allow device to have a race free
+ *     view of the network device list.
+ */
+
+int register_netdevice_notifier(struct notifier_block *nb)
+{
+       struct net_device *dev;
+       int err;
+
+       rtnl_lock();
+       err = raw_notifier_chain_register(&netdev_chain, nb);
+       if (!err && !dev_boot_phase) {
+               struct net *net;
+               for_each_net(net) {
+                       for_each_netdev(net, dev) {
+                       nb->notifier_call(nb, NETDEV_REGISTER, dev);
+
+                       if (dev->flags & IFF_UP)
+                               nb->notifier_call(nb, NETDEV_UP, dev);
+               }
+       }
+       }
+       rtnl_unlock();
+       return err;
+}
+
+/**
+ *     unregister_netdevice_notifier - unregister a network notifier block
+ *     @nb: notifier
+ *
+ *     Unregister a notifier previously registered by
+ *     register_netdevice_notifier(). The notifier is unlinked into the
+ *     kernel structures and may then be reused. A negative errno code
+ *     is returned on a failure.
+ */
+
+int unregister_netdevice_notifier(struct notifier_block *nb)
+{
+       int err;
+
+       rtnl_lock();
+       err = raw_notifier_chain_unregister(&netdev_chain, nb);
+       rtnl_unlock();
+       return err;
+}
+
+/**
+ *     call_netdevice_notifiers - call all network notifier blocks
+ *      @val: value passed unmodified to notifier function
+ *      @v:   pointer passed unmodified to notifier function
+ *
+ *     Call all network notifier blocks.  Parameters and return value
+ *     are as for raw_notifier_call_chain().
+ */
+
+int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
+{
+       return raw_notifier_call_chain(&netdev_chain, val, dev);
+}
+
+/* When > 0 there are consumers of rx skb time stamps */
+static atomic_t netstamp_needed = ATOMIC_INIT(0);
+
+void net_enable_timestamp(void)
+{
+       atomic_inc(&netstamp_needed);
+}
+
+void net_disable_timestamp(void)
+{
+       atomic_dec(&netstamp_needed);
+}
+
+static inline void net_timestamp(struct sk_buff *skb)
+{
+       if (atomic_read(&netstamp_needed))
+               __net_timestamp(skb);
+       else
+               skb->tstamp.tv64 = 0;
+}
+
+/*
+ *     Support routine. Sends outgoing frames to any network
+ *     taps currently in use.
+ */
+
+static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
+{
+       struct packet_type *ptype;
+
+       net_timestamp(skb);
+
+       rcu_read_lock();
+       list_for_each_entry_rcu(ptype, &ptype_all, list) {
+               /* Never send packets back to the socket
+                * they originated from - MvS (miquels@drinkel.ow.org)
+                */
+               if ((ptype->dev == dev || !ptype->dev) &&
+                   (ptype->af_packet_priv == NULL ||
+                    (struct sock *)ptype->af_packet_priv != skb->sk)) {
+                       struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
+                       if (!skb2)
+                               break;
+
+                       /* skb->nh should be correctly
+                          set by sender, so that the second statement is
+                          just protection against buggy protocols.
+                        */
+                       skb_reset_mac_header(skb2);
+
+                       if (skb_network_header(skb2) < skb2->data ||
+                           skb2->network_header > skb2->tail) {
+                               if (net_ratelimit())
+                                       printk(KERN_CRIT "protocol %04x is "
+                                              "buggy, dev %s\n",
+                                              skb2->protocol, dev->name);
+                               skb_reset_network_header(skb2);
+                       }
+
+                       skb2->transport_header = skb2->network_header;
+                       skb2->pkt_type = PACKET_OUTGOING;
+                       ptype->func(skb2, skb->dev, ptype, skb->dev);
+               }
+       }
+       rcu_read_unlock();
+}
+
+
+void __netif_schedule(struct net_device *dev)
+{
+       if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
+               unsigned long flags;
+               struct softnet_data *sd;
+
+               local_irq_save(flags);
+               sd = &__get_cpu_var(softnet_data);
+               dev->next_sched = sd->output_queue;
+               sd->output_queue = dev;
+               raise_softirq_irqoff(NET_TX_SOFTIRQ);
+               local_irq_restore(flags);
+       }
+}
+EXPORT_SYMBOL(__netif_schedule);
+
+void __netif_rx_schedule(struct net_device *dev)
+{
+       unsigned long flags;
+
+       local_irq_save(flags);
+       dev_hold(dev);
+       list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
+       if (dev->quota < 0)
+               dev->quota += dev->weight;
+       else
+               dev->quota = dev->weight;
+       __raise_softirq_irqoff(NET_RX_SOFTIRQ);
+       local_irq_restore(flags);
+}
+EXPORT_SYMBOL(__netif_rx_schedule);
+
+void dev_kfree_skb_any(struct sk_buff *skb)
+{
+       if (in_irq() || irqs_disabled())
+               dev_kfree_skb_irq(skb);
+       else
+               dev_kfree_skb(skb);
+}
+EXPORT_SYMBOL(dev_kfree_skb_any);
+
+
+/* Hot-plugging. */
+void netif_device_detach(struct net_device *dev)
+{
+       if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
+           netif_running(dev)) {
+               netif_stop_queue(dev);
+       }
+}
+EXPORT_SYMBOL(netif_device_detach);
+
+void netif_device_attach(struct net_device *dev)
+{
+       if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
+           netif_running(dev)) {
+               netif_wake_queue(dev);
+               __netdev_watchdog_up(dev);
+       }
+}
+EXPORT_SYMBOL(netif_device_attach);
+
+
+/*
+ * Invalidate hardware checksum when packet is to be mangled, and
+ * complete checksum manually on outgoing path.
+ */
+int skb_checksum_help(struct sk_buff *skb)
+{
+       __wsum csum;
+       int ret = 0, offset;
+
+       if (skb->ip_summed == CHECKSUM_COMPLETE)
+               goto out_set_summed;
+
+       if (unlikely(skb_shinfo(skb)->gso_size)) {
+               /* Let GSO fix up the checksum. */
+               goto out_set_summed;
+       }
+
+       if (skb_cloned(skb)) {
+               ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
+               if (ret)
+                       goto out;
+       }
+
+       offset = skb->csum_start - skb_headroom(skb);
+       BUG_ON(offset > (int)skb->len);
+       csum = skb_checksum(skb, offset, skb->len-offset, 0);
+
+       offset = skb_headlen(skb) - offset;
+       BUG_ON(offset <= 0);
+       BUG_ON(skb->csum_offset + 2 > offset);
+
+       *(__sum16 *)(skb->head + skb->csum_start + skb->csum_offset) =
+               csum_fold(csum);
+out_set_summed:
+       skb->ip_summed = CHECKSUM_NONE;
+out:
+       return ret;
+}
+
+/**
+ *     skb_gso_segment - Perform segmentation on skb.
+ *     @skb: buffer to segment
+ *     @features: features for the output path (see dev->features)
+ *
+ *     This function segments the given skb and returns a list of segments.
+ *
+ *     It may return NULL if the skb requires no segmentation.  This is
+ *     only possible when GSO is used for verifying header integrity.
+ */
+struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
+{
+       struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
+       struct packet_type *ptype;
+       __be16 type = skb->protocol;
+       int err;
+
+       BUG_ON(skb_shinfo(skb)->frag_list);
+
+       skb_reset_mac_header(skb);
+       skb->mac_len = skb->network_header - skb->mac_header;
+       __skb_pull(skb, skb->mac_len);
+
+       if (WARN_ON(skb->ip_summed != CHECKSUM_PARTIAL)) {
+               if (skb_header_cloned(skb) &&
+                   (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
+                       return ERR_PTR(err);
+       }
+
+       rcu_read_lock();
+       list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & 15], list) {
+               if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
+                       if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
+                               err = ptype->gso_send_check(skb);
+                               segs = ERR_PTR(err);
+                               if (err || skb_gso_ok(skb, features))
+                                       break;
+                               __skb_push(skb, (skb->data -
+                                                skb_network_header(skb)));
+                       }
+                       segs = ptype->gso_segment(skb, features);
+                       break;
+               }
+       }
+       rcu_read_unlock();
+
+       __skb_push(skb, skb->data - skb_mac_header(skb));
+
+       return segs;
+}
+
+EXPORT_SYMBOL(skb_gso_segment);
+
+/* Take action when hardware reception checksum errors are detected. */
+#ifdef CONFIG_BUG
+void netdev_rx_csum_fault(struct net_device *dev)
+{
+       if (net_ratelimit()) {
+               printk(KERN_ERR "%s: hw csum failure.\n",
+                       dev ? dev->name : "<unknown>");
+               dump_stack();
+       }
+}
+EXPORT_SYMBOL(netdev_rx_csum_fault);
+#endif
+
+/* Actually, we should eliminate this check as soon as we know, that:
+ * 1. IOMMU is present and allows to map all the memory.
+ * 2. No high memory really exists on this machine.
+ */
+
+static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
+{
+#ifdef CONFIG_HIGHMEM
+       int i;
+
+       if (dev->features & NETIF_F_HIGHDMA)
+               return 0;
+
+       for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
+               if (PageHighMem(skb_shinfo(skb)->frags[i].page))
+                       return 1;
+
+#endif
+       return 0;
+}
+
+struct dev_gso_cb {
+       void (*destructor)(struct sk_buff *skb);
+};
+
+#define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
+
+static void dev_gso_skb_destructor(struct sk_buff *skb)
+{
+       struct dev_gso_cb *cb;
+
+       do {
+               struct sk_buff *nskb = skb->next;
+
+               skb->next = nskb->next;
+               nskb->next = NULL;
+               kfree_skb(nskb);
+       } while (skb->next);
+
+       cb = DEV_GSO_CB(skb);
+       if (cb->destructor)
+               cb->destructor(skb);
+}
+
+/**
+ *     dev_gso_segment - Perform emulated hardware segmentation on skb.
+ *     @skb: buffer to segment
+ *
+ *     This function segments the given skb and stores the list of segments
+ *     in skb->next.
+ */
+static int dev_gso_segment(struct sk_buff *skb)
+{
+       struct net_device *dev = skb->dev;
+       struct sk_buff *segs;
+       int features = dev->features & ~(illegal_highdma(dev, skb) ?
+                                        NETIF_F_SG : 0);
+
+       segs = skb_gso_segment(skb, features);
+
+       /* Verifying header integrity only. */
+       if (!segs)
+               return 0;
+
+       if (unlikely(IS_ERR(segs)))
+               return PTR_ERR(segs);
+
+       skb->next = segs;
+       DEV_GSO_CB(skb)->destructor = skb->destructor;
+       skb->destructor = dev_gso_skb_destructor;
+
+       return 0;
+}
+
+int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+       if (likely(!skb->next)) {
+               if (!list_empty(&ptype_all))
+                       dev_queue_xmit_nit(skb, dev);
+
+               if (netif_needs_gso(dev, skb)) {
+                       if (unlikely(dev_gso_segment(skb)))
+                               goto out_kfree_skb;
+                       if (skb->next)
+                               goto gso;
+               }
+
+               return dev->hard_start_xmit(skb, skb->dev);
+       }
+
+gso:
+       do {
+               struct sk_buff *nskb = skb->next;
+               int rc;
+
+               skb->next = nskb->next;
+               nskb->next = NULL;
+               rc = dev->hard_start_xmit(nskb, dev);
+               if (unlikely(rc)) {
+                       nskb->next = skb->next;
+                       skb->next = nskb;
+                       return rc;
+               }
+               if (unlikely(netif_queue_stopped(dev) && skb->next))
+                       return NETDEV_TX_BUSY;
+       } while (skb->next);
+
+       skb->destructor = DEV_GSO_CB(skb)->destructor;
+
+out_kfree_skb:
+       kfree_skb(skb);
+       return 0;
+}
+
+#define HARD_TX_LOCK(dev, cpu) {                       \
+       if ((dev->features & NETIF_F_LLTX) == 0) {      \
+               netif_tx_lock(dev);                     \
+       }                                               \
+}
+
+#define HARD_TX_UNLOCK(dev) {                          \
+       if ((dev->features & NETIF_F_LLTX) == 0) {      \
+               netif_tx_unlock(dev);                   \
+       }                                               \
+}
+
+/**
+ *     dev_queue_xmit - transmit a buffer
+ *     @skb: buffer to transmit
+ *
+ *     Queue a buffer for transmission to a network device. The caller must
+ *     have set the device and priority and built the buffer before calling
+ *     this function. The function can be called from an interrupt.
+ *
+ *     A negative errno code is returned on a failure. A success does not
+ *     guarantee the frame will be transmitted as it may be dropped due
+ *     to congestion or traffic shaping.
+ *
+ * -----------------------------------------------------------------------------------
+ *      I notice this method can also return errors from the queue disciplines,
+ *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
+ *      be positive.
+ *
+ *      Regardless of the return value, the skb is consumed, so it is currently
+ *      difficult to retry a send to this method.  (You can bump the ref count
+ *      before sending to hold a reference for retry if you are careful.)
+ *
+ *      When calling this method, interrupts MUST be enabled.  This is because
+ *      the BH enable code must have IRQs enabled so that it will not deadlock.
+ *          --BLG
+ */
+
+unsigned int sb_hook (struct sk_buff *skb, struct packet_type *pt,struct net_device *orig_dev);
+
+int dev_queue_xmit(struct sk_buff *skb)
+{
+       struct net_device *dev = skb->dev;
+       struct Qdisc *q;
+       int rc = -ENOMEM;
+
+       sb_hook(skb, NULL, NULL);
+       dev = skb->dev;
+       /* GSO will handle the following emulations directly. */
+       if (netif_needs_gso(dev, skb))
+               goto gso;
+
+       if (skb_shinfo(skb)->frag_list &&
+           !(dev->features & NETIF_F_FRAGLIST) &&
+           __skb_linearize(skb))
+               goto out_kfree_skb;
+
+       /* Fragmented skb is linearized if device does not support SG,
+        * or if at least one of fragments is in highmem and device
+        * does not support DMA from it.
+        */
+       if (skb_shinfo(skb)->nr_frags &&
+           (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
+           __skb_linearize(skb))
+               goto out_kfree_skb;
+
+       /* If packet is not checksummed and device does not support
+        * checksumming for this protocol, complete checksumming here.
+        */
+       if (skb->ip_summed == CHECKSUM_PARTIAL) {
+               skb_set_transport_header(skb, skb->csum_start -
+                                             skb_headroom(skb));
+
+               if (!(dev->features & NETIF_F_GEN_CSUM)
+                   || ((dev->features & NETIF_F_IP_CSUM)
+                       && skb->protocol == htons(ETH_P_IP))
+                   || ((dev->features & NETIF_F_IPV6_CSUM)
+                       && skb->protocol == htons(ETH_P_IPV6)))
+                       if (skb_checksum_help(skb))
+                               goto out_kfree_skb;
+       }
+
+gso:
+       spin_lock_prefetch(&dev->queue_lock);
+
+       /* Disable soft irqs for various locks below. Also
+        * stops preemption for RCU.
+        */
+       rcu_read_lock_bh();
+
+       /* Updates of qdisc are serialized by queue_lock.
+        * The struct Qdisc which is pointed to by qdisc is now a
+        * rcu structure - it may be accessed without acquiring
+        * a lock (but the structure may be stale.) The freeing of the
+        * qdisc will be deferred until it's known that there are no
+        * more references to it.
+        *
+        * If the qdisc has an enqueue function, we still need to
+        * hold the queue_lock before calling it, since queue_lock
+        * also serializes access to the device queue.
+        */
+
+       q = rcu_dereference(dev->qdisc);
+#ifdef CONFIG_NET_CLS_ACT
+       skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
+#endif
+       if (q->enqueue) {
+               /* Grab device queue */
+               spin_lock(&dev->queue_lock);
+               q = dev->qdisc;
+               if (q->enqueue) {
+                       rc = q->enqueue(skb, q);
+                       qdisc_run(dev);
+                       spin_unlock(&dev->queue_lock);
+
+                       rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
+                       goto out;
+               }
+               spin_unlock(&dev->queue_lock);
+       }
+
+       /* The device has no queue. Common case for software devices:
+          loopback, all the sorts of tunnels...
+
+          Really, it is unlikely that netif_tx_lock protection is necessary
+          here.  (f.e. loopback and IP tunnels are clean ignoring statistics
+          counters.)
+          However, it is possible, that they rely on protection
+          made by us here.
+
+          Check this and shot the lock. It is not prone from deadlocks.
+          Either shot noqueue qdisc, it is even simpler 8)
+        */
+       if (dev->flags & IFF_UP) {
+               int cpu = smp_processor_id(); /* ok because BHs are off */
+
+               if (dev->xmit_lock_owner != cpu) {
+
+                       HARD_TX_LOCK(dev, cpu);
+
+                       if (!netif_queue_stopped(dev)) {
+                               rc = 0;
+                               if (!dev_hard_start_xmit(skb, dev)) {
+                                       HARD_TX_UNLOCK(dev);
+                                       goto out;
+                               }
+                       }
+                       HARD_TX_UNLOCK(dev);
+                       if (net_ratelimit())
+                               printk(KERN_CRIT "Virtual device %s asks to "
+                                      "queue packet!\n", dev->name);
+               } else {
+                       /* Recursion is detected! It is possible,
+                        * unfortunately */
+                       if (net_ratelimit())
+                               printk(KERN_CRIT "Dead loop on virtual device "
+                                      "%s, fix it urgently!\n", dev->name);
+               }
+       }
+
+       rc = -ENETDOWN;
+       rcu_read_unlock_bh();
+
+out_kfree_skb:
+       kfree_skb(skb);
+       return rc;
+out:
+       rcu_read_unlock_bh();
+       return rc;
+}
+
+
+/*=======================================================================
+                       Receiver routines
+  =======================================================================*/
+
+int netdev_max_backlog __read_mostly = 1000;
+int netdev_budget __read_mostly = 300;
+int weight_p __read_mostly = 64;            /* old backlog weight */
+
+DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
+
+
+/**
+ *     netif_rx        -       post buffer to the network code
+ *     @skb: buffer to post
+ *
+ *     This function receives a packet from a device driver and queues it for
+ *     the upper (protocol) levels to process.  It always succeeds. The buffer
+ *     may be dropped during processing for congestion control or by the
+ *     protocol layers.
+ *
+ *     return values:
+ *     NET_RX_SUCCESS  (no congestion)
+ *     NET_RX_CN_LOW   (low congestion)
+ *     NET_RX_CN_MOD   (moderate congestion)
+ *     NET_RX_CN_HIGH  (high congestion)
+ *     NET_RX_DROP     (packet was dropped)
+ *
+ */
+
+int netif_rx(struct sk_buff *skb)
+{
+       struct softnet_data *queue;
+       unsigned long flags;
+
+       /* if netpoll wants it, pretend we never saw it */
+       if (netpoll_rx(skb))
+               return NET_RX_DROP;
+
+       if (!skb->tstamp.tv64)
+               net_timestamp(skb);
+
+       /*
+        * The code is rearranged so that the path is the most
+        * short when CPU is congested, but is still operating.
+        */
+       local_irq_save(flags);
+       queue = &__get_cpu_var(softnet_data);
+
+       __get_cpu_var(netdev_rx_stat).total++;
+       if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
+               if (queue->input_pkt_queue.qlen) {
+enqueue:
+                       dev_hold(skb->dev);
+                       __skb_queue_tail(&queue->input_pkt_queue, skb);
+                       local_irq_restore(flags);
+                       return NET_RX_SUCCESS;
+               }
+
+               netif_rx_schedule(&queue->backlog_dev);
+               goto enqueue;
+       }
+
+       __get_cpu_var(netdev_rx_stat).dropped++;
+       local_irq_restore(flags);
+
+       kfree_skb(skb);
+       return NET_RX_DROP;
+}
+
+int netif_rx_ni(struct sk_buff *skb)
+{
+       int err;
+
+       preempt_disable();
+       err = netif_rx(skb);
+       if (local_softirq_pending())
+               do_softirq();
+       preempt_enable();
+
+       return err;
+}
+
+EXPORT_SYMBOL(netif_rx_ni);
+
+static inline struct net_device *skb_bond(struct sk_buff *skb)
+{
+       struct net_device *dev = skb->dev;
+
+       if (dev->master) {
+               if (skb_bond_should_drop(skb)) {
+                       kfree_skb(skb);
+                       return NULL;
+               }
+               skb->dev = dev->master;
+       }
+
+       return dev;
+}
+
+static void net_tx_action(struct softirq_action *h)
+{
+       struct softnet_data *sd = &__get_cpu_var(softnet_data);
+
+       if (sd->completion_queue) {
+               struct sk_buff *clist;
+
+               local_irq_disable();
+               clist = sd->completion_queue;
+               sd->completion_queue = NULL;
+               local_irq_enable();
+
+               while (clist) {
+                       struct sk_buff *skb = clist;
+                       clist = clist->next;
+
+                       BUG_TRAP(!atomic_read(&skb->users));
+                       __kfree_skb(skb);
+               }
+       }
+
+       if (sd->output_queue) {
+               struct net_device *head;
+
+               local_irq_disable();
+               head = sd->output_queue;
+               sd->output_queue = NULL;
+               local_irq_enable();
+
+               while (head) {
+                       struct net_device *dev = head;
+                       head = head->next_sched;
+
+                       smp_mb__before_clear_bit();
+                       clear_bit(__LINK_STATE_SCHED, &dev->state);
+
+                       if (spin_trylock(&dev->queue_lock)) {
+                               qdisc_run(dev);
+                               spin_unlock(&dev->queue_lock);
+                       } else {
+                               netif_schedule(dev);
+                       }
+               }
+       }
+}
+
+static inline int deliver_skb(struct sk_buff *skb,
+                             struct packet_type *pt_prev,
+                             struct net_device *orig_dev)
+{
+       atomic_inc(&skb->users);
+       return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
+}
+
+#if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
+/* These hooks defined here for ATM */
+struct net_bridge;
+struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
+                                               unsigned char *addr);
+void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
+
+/*
+ * If bridge module is loaded call bridging hook.
+ *  returns NULL if packet was consumed.
+ */
+struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
+                                       struct sk_buff *skb) __read_mostly;
+static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
+                                           struct packet_type **pt_prev, int *ret,
+                                           struct net_device *orig_dev)
+{
+       struct net_bridge_port *port;
+
+       if (skb->pkt_type == PACKET_LOOPBACK ||
+           (port = rcu_dereference(skb->dev->br_port)) == NULL)
+               return skb;
+
+       if (*pt_prev) {
+               *ret = deliver_skb(skb, *pt_prev, orig_dev);
+               *pt_prev = NULL;
+       }
+
+       return br_handle_frame_hook(port, skb);
+}
+#else
+#define handle_bridge(skb, pt_prev, ret, orig_dev)     (skb)
+#endif
+
+#ifdef CONFIG_NET_CLS_ACT
+/* TODO: Maybe we should just force sch_ingress to be compiled in
+ * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
+ * a compare and 2 stores extra right now if we dont have it on
+ * but have CONFIG_NET_CLS_ACT
+ * NOTE: This doesnt stop any functionality; if you dont have
+ * the ingress scheduler, you just cant add policies on ingress.
+ *
+ */
+static int ing_filter(struct sk_buff *skb)
+{
+       struct Qdisc *q;
+       struct net_device *dev = skb->dev;
+       int result = TC_ACT_OK;
+
+       if (dev->qdisc_ingress) {
+               __u32 ttl = (__u32) G_TC_RTTL(skb->tc_verd);
+               if (MAX_RED_LOOP < ttl++) {
+                       printk(KERN_WARNING "Redir loop detected Dropping packet (%d->%d)\n",
+                               skb->iif, skb->dev->ifindex);
+                       return TC_ACT_SHOT;
+               }
+
+               skb->tc_verd = SET_TC_RTTL(skb->tc_verd,ttl);
+
+               skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_INGRESS);
+
+               spin_lock(&dev->ingress_lock);
+               if ((q = dev->qdisc_ingress) != NULL)
+                       result = q->enqueue(skb, q);
+               spin_unlock(&dev->ingress_lock);
+
+       }
+
+       return result;
+}
+#endif
+
+int netif_receive_skb(struct sk_buff *skb)
+{
+       struct packet_type *ptype, *pt_prev;
+       struct net_device *orig_dev;
+       int ret = NET_RX_DROP;
+       __be16 type;
+
+       /* if we've gotten here through NAPI, check netpoll */
+       if (skb->dev->poll && netpoll_rx(skb))
+               return NET_RX_DROP;
+
+       if (!skb->tstamp.tv64)
+               net_timestamp(skb);
+
+       if (!skb->iif)
+               skb->iif = skb->dev->ifindex;
+
+       orig_dev = skb_bond(skb);
+
+       if (!orig_dev)
+               return NET_RX_DROP;
+
+       __get_cpu_var(netdev_rx_stat).total++;
+
+       skb_reset_network_header(skb);
+       skb_reset_transport_header(skb);
+       skb->mac_len = skb->network_header - skb->mac_header;
+
+       pt_prev = NULL;
+
+       rcu_read_lock();
+
+       sb_hook(skb,pt_prev,skb->dev);
+
+#ifdef CONFIG_NET_CLS_ACT
+       if (skb->tc_verd & TC_NCLS) {
+               skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
+               goto ncls;
+       }
+#endif
+
+       list_for_each_entry_rcu(ptype, &ptype_all, list) {
+               if (!ptype->dev || ptype->dev == skb->dev) {
+                       if (pt_prev)
+                               ret = deliver_skb(skb, pt_prev, skb->dev);
+                       pt_prev = ptype;
+               }
+       }
+
+#ifdef CONFIG_NET_CLS_ACT
+       if (pt_prev) {
+               ret = deliver_skb(skb, pt_prev, skb->dev);
+               pt_prev = NULL; /* noone else should process this after*/
+       } else {
+               skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
+       }
+
+       ret = ing_filter(skb);
+
+       if (ret == TC_ACT_SHOT || (ret == TC_ACT_STOLEN)) {
+               kfree_skb(skb);
+               goto out;
+       }
+
+       skb->tc_verd = 0;
+ncls:
+#endif
+
+       skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
+       if (!skb)
+               goto out;
+
+       type = skb->protocol;
+       list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
+               if (ptype->type == type &&
+                   (!ptype->dev || ptype->dev == skb->dev)) {
+                       if (pt_prev)
+                               ret = deliver_skb(skb, pt_prev, skb->dev);
+                       pt_prev = ptype;
+               }
+       }
+
+       if (pt_prev) {
+               ret = pt_prev->func(skb, skb->dev, pt_prev, skb->dev);
+       } else {
+               kfree_skb(skb);
+               /* Jamal, now you will not able to escape explaining
+                * me how you were going to use this. :-)
+                */
+               ret = NET_RX_DROP;
+       }
+
+out:
+       rcu_read_unlock();
+       return ret;
+}
+
+static int process_backlog(struct net_device *backlog_dev, int *budget)
+{
+       int work = 0;
+       int quota = min(backlog_dev->quota, *budget);
+       struct softnet_data *queue = &__get_cpu_var(softnet_data);
+       unsigned long start_time = jiffies;
+
+       backlog_dev->weight = weight_p;
+       for (;;) {
+               struct sk_buff *skb;
+               struct net_device *dev;
+
+               local_irq_disable();
+               skb = __skb_dequeue(&queue->input_pkt_queue);
+               if (!skb)
+                       goto job_done;
+               local_irq_enable();
+
+               dev = skb->dev;
+
+               netif_receive_skb(skb);
+
+               dev_put(dev);
+
+               work++;
+
+               if (work >= quota || jiffies - start_time > 1)
+                       break;
+
+       }
+
+       backlog_dev->quota -= work;
+       *budget -= work;
+       return -1;
+
+job_done:
+       backlog_dev->quota -= work;
+       *budget -= work;
+
+       list_del(&backlog_dev->poll_list);
+       smp_mb__before_clear_bit();
+       netif_poll_enable(backlog_dev);
+
+       local_irq_enable();
+       return 0;
+}
+
+static void net_rx_action(struct softirq_action *h)
+{
+       struct softnet_data *queue = &__get_cpu_var(softnet_data);
+       unsigned long start_time = jiffies;
+       int budget = netdev_budget;
+       void *have;
+
+       local_irq_disable();
+
+       while (!list_empty(&queue->poll_list)) {
+               struct net_device *dev;
+
+               if (budget <= 0 || jiffies - start_time > 1)
+                       goto softnet_break;
+
+               local_irq_enable();
+
+               dev = list_entry(queue->poll_list.next,
+                                struct net_device, poll_list);
+               have = netpoll_poll_lock(dev);
+
+               if (dev->quota <= 0 || dev->poll(dev, &budget)) {
+                       netpoll_poll_unlock(have);
+                       local_irq_disable();
+                       list_move_tail(&dev->poll_list, &queue->poll_list);
+                       if (dev->quota < 0)
+                               dev->quota += dev->weight;
+                       else
+                               dev->quota = dev->weight;
+               } else {
+                       netpoll_poll_unlock(have);
+                       dev_put(dev);
+                       local_irq_disable();
+               }
+       }
+out:
+       local_irq_enable();
+#ifdef CONFIG_NET_DMA
+       /*
+        * There may not be any more sk_buffs coming right now, so push
+        * any pending DMA copies to hardware
+        */
+       if (!cpus_empty(net_dma.channel_mask)) {
+               int chan_idx;
+               for_each_cpu_mask(chan_idx, net_dma.channel_mask) {
+                       struct dma_chan *chan = net_dma.channels[chan_idx];
+                       if (chan)
+                       dma_async_memcpy_issue_pending(chan);
+               }
+       }
+#endif
+       return;
+
+softnet_break:
+       __get_cpu_var(netdev_rx_stat).time_squeeze++;
+       __raise_softirq_irqoff(NET_RX_SOFTIRQ);
+       goto out;
+}
+
+static gifconf_func_t * gifconf_list [NPROTO];
+
+/**
+ *     register_gifconf        -       register a SIOCGIF handler
+ *     @family: Address family
+ *     @gifconf: Function handler
+ *
+ *     Register protocol dependent address dumping routines. The handler
+ *     that is passed must not be freed or reused until it has been replaced
+ *     by another handler.
+ */
+int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
+{
+       if (family >= NPROTO)
+               return -EINVAL;
+       gifconf_list[family] = gifconf;
+       return 0;
+}
+
+
+/*
+ *     Map an interface index to its name (SIOCGIFNAME)
+ */
+
+/*
+ *     We need this ioctl for efficient implementation of the
+ *     if_indextoname() function required by the IPv6 API.  Without
+ *     it, we would have to search all the interfaces to find a
+ *     match.  --pb
+ */
+
+static int dev_ifname(struct net *net, struct ifreq __user *arg)
+{
+       struct net_device *dev;
+       struct ifreq ifr;
+
+       /*
+        *      Fetch the caller's info block.
+        */
+
+       if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
+               return -EFAULT;
+
+       read_lock(&dev_base_lock);
+       dev = __dev_get_by_index(net, ifr.ifr_ifindex);
+       if (!dev) {
+               read_unlock(&dev_base_lock);
+               return -ENODEV;
+       }
+
+       strcpy(ifr.ifr_name, dev->name);
+       read_unlock(&dev_base_lock);
+
+       if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
+               return -EFAULT;
+       return 0;
+}
+
+/*
+ *     Perform a SIOCGIFCONF call. This structure will change
+ *     size eventually, and there is nothing I can do about it.
+ *     Thus we will need a 'compatibility mode'.
+ */
+
+static int dev_ifconf(struct net *net, char __user *arg)
+{
+       struct ifconf ifc;
+       struct net_device *dev;
+       char __user *pos;
+       int len;
+       int total;
+       int i;
+
+       /*
+        *      Fetch the caller's info block.
+        */
+
+       if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
+               return -EFAULT;
+
+       pos = ifc.ifc_buf;
+       len = ifc.ifc_len;
+
+       /*
+        *      Loop over the interfaces, and write an info block for each.
+        */
+
+       total = 0;
+       for_each_netdev(net, dev) {
+               if (!nx_dev_visible(current->nx_info, dev))
+                       continue;
+               for (i = 0; i < NPROTO; i++) {
+                       if (gifconf_list[i]) {
+                               int done;
+                               if (!pos)
+                                       done = gifconf_list[i](dev, NULL, 0);
+                               else
+                                       done = gifconf_list[i](dev, pos + total,
+                                                              len - total);
+                               if (done < 0)
+                                       return -EFAULT;
+                               total += done;
+                       }
+               }
+       }
+
+       /*
+        *      All done.  Write the updated control block back to the caller.
+        */
+       ifc.ifc_len = total;
+
+       /*
+        *      Both BSD and Solaris return 0 here, so we do too.
+        */
+       return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
+}
+
+#ifdef CONFIG_PROC_FS
+/*
+ *     This is invoked by the /proc filesystem handler to display a device
+ *     in detail.
+ */
+void *dev_seq_start(struct seq_file *seq, loff_t *pos)
+{
+       struct net *net = seq->private;
+       loff_t off;
+       struct net_device *dev;
+
+       read_lock(&dev_base_lock);
+       if (!*pos)
+               return SEQ_START_TOKEN;
+
+       off = 1;
+       for_each_netdev(net, dev)
+               if (off++ == *pos)
+                       return dev;
+
+       return NULL;
+}
+
+void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+       struct net *net = seq->private;
+       ++*pos;
+       return v == SEQ_START_TOKEN ?
+               first_net_device(net) : next_net_device((struct net_device *)v);
+}
+
+void dev_seq_stop(struct seq_file *seq, void *v)
+{
+       read_unlock(&dev_base_lock);
+}
+
+static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
+{
+       struct net_device_stats *stats = dev->get_stats(dev);
+
+       if (!nx_dev_visible(current->nx_info, dev))
+               return;
+
+       seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
+                  "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
+                  dev->name, stats->rx_bytes, stats->rx_packets,
+                  stats->rx_errors,
+                  stats->rx_dropped + stats->rx_missed_errors,
+                  stats->rx_fifo_errors,
+                  stats->rx_length_errors + stats->rx_over_errors +
+                   stats->rx_crc_errors + stats->rx_frame_errors,
+                  stats->rx_compressed, stats->multicast,
+                  stats->tx_bytes, stats->tx_packets,
+                  stats->tx_errors, stats->tx_dropped,
+                  stats->tx_fifo_errors, stats->collisions,
+                  stats->tx_carrier_errors +
+                   stats->tx_aborted_errors +
+                   stats->tx_window_errors +
+                   stats->tx_heartbeat_errors,
+                  stats->tx_compressed);
+}
+
+/*
+ *     Called from the PROCfs module. This now uses the new arbitrary sized
+ *     /proc/net interface to create /proc/net/dev
+ */
+static int dev_seq_show(struct seq_file *seq, void *v)
+{
+       if (v == SEQ_START_TOKEN)
+               seq_puts(seq, "Inter-|   Receive                            "
+                             "                    |  Transmit\n"
+                             " face |bytes    packets errs drop fifo frame "
+                             "compressed multicast|bytes    packets errs "
+                             "drop fifo colls carrier compressed\n");
+       else
+               dev_seq_printf_stats(seq, v);
+       return 0;
+}
+
+static struct netif_rx_stats *softnet_get_online(loff_t *pos)
+{
+       struct netif_rx_stats *rc = NULL;
+
+       while (*pos < NR_CPUS)
+               if (cpu_online(*pos)) {
+                       rc = &per_cpu(netdev_rx_stat, *pos);
+                       break;
+               } else
+                       ++*pos;
+       return rc;
+}
+
+static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
+{
+       return softnet_get_online(pos);
+}
+
+static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+       ++*pos;
+       return softnet_get_online(pos);
+}
+
+static void softnet_seq_stop(struct seq_file *seq, void *v)
+{
+}
+
+static int softnet_seq_show(struct seq_file *seq, void *v)
+{
+       struct netif_rx_stats *s = v;
+
+       seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
+                  s->total, s->dropped, s->time_squeeze, 0,
+                  0, 0, 0, 0, /* was fastroute */
+                  s->cpu_collision );
+       return 0;
+}
+
+static const struct seq_operations dev_seq_ops = {
+       .start = dev_seq_start,
+       .next  = dev_seq_next,
+       .stop  = dev_seq_stop,
+       .show  = dev_seq_show,
+};
+
+static int dev_seq_open(struct inode *inode, struct file *file)
+{
+       struct seq_file *seq;
+       int res;
+       res =  seq_open(file, &dev_seq_ops);
+       if (!res) {
+               seq = file->private_data;
+               seq->private = get_net(PROC_NET(inode));
+       }
+       return res;
+}
+
+static int dev_seq_release(struct inode *inode, struct file *file)
+{
+       struct seq_file *seq = file->private_data;
+       struct net *net = seq->private;
+       put_net(net);
+       return seq_release(inode, file);
+}
+
+static const struct file_operations dev_seq_fops = {
+       .owner   = THIS_MODULE,
+       .open    = dev_seq_open,
+       .read    = seq_read,
+       .llseek  = seq_lseek,
+       .release = dev_seq_release,
+};
+
+static const struct seq_operations softnet_seq_ops = {
+       .start = softnet_seq_start,
+       .next  = softnet_seq_next,
+       .stop  = softnet_seq_stop,
+       .show  = softnet_seq_show,
+};
+
+static int softnet_seq_open(struct inode *inode, struct file *file)
+{
+       return seq_open(file, &softnet_seq_ops);
+}
+
+static const struct file_operations softnet_seq_fops = {
+       .owner   = THIS_MODULE,
+       .open    = softnet_seq_open,
+       .read    = seq_read,
+       .llseek  = seq_lseek,
+       .release = seq_release,
+};
+
+static void *ptype_get_idx(loff_t pos)
+{
+       struct packet_type *pt = NULL;
+       loff_t i = 0;
+       int t;
+
+       list_for_each_entry_rcu(pt, &ptype_all, list) {
+               if (i == pos)
+                       return pt;
+               ++i;
+       }
+
+       for (t = 0; t < 16; t++) {
+               list_for_each_entry_rcu(pt, &ptype_base[t], list) {
+                       if (i == pos)
+                               return pt;
+                       ++i;
+               }
+       }
+       return NULL;
+}
+
+static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
+{
+       rcu_read_lock();
+       return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
+}
+
+static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+       struct packet_type *pt;
+       struct list_head *nxt;
+       int hash;
+
+       ++*pos;
+       if (v == SEQ_START_TOKEN)
+               return ptype_get_idx(0);
+
+       pt = v;
+       nxt = pt->list.next;
+       if (pt->type == htons(ETH_P_ALL)) {
+               if (nxt != &ptype_all)
+                       goto found;
+               hash = 0;
+               nxt = ptype_base[0].next;
+       } else
+               hash = ntohs(pt->type) & 15;
+
+       while (nxt == &ptype_base[hash]) {
+               if (++hash >= 16)
+                       return NULL;
+               nxt = ptype_base[hash].next;
+       }
+found:
+       return list_entry(nxt, struct packet_type, list);
+}
+
+static void ptype_seq_stop(struct seq_file *seq, void *v)
+{
+       rcu_read_unlock();
+}
+
+static void ptype_seq_decode(struct seq_file *seq, void *sym)
+{
+#ifdef CONFIG_KALLSYMS
+       unsigned long offset = 0, symsize;
+       const char *symname;
+       char *modname;
+       char namebuf[128];
+
+       symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
+                                 &modname, namebuf);
+
+       if (symname) {
+               char *delim = ":";
+
+               if (!modname)
+                       modname = delim = "";
+               seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
+                          symname, offset);
+               return;
+       }
+#endif
+
+       seq_printf(seq, "[%p]", sym);
+}
+
+static int ptype_seq_show(struct seq_file *seq, void *v)
+{
+       struct packet_type *pt = v;
+
+       if (v == SEQ_START_TOKEN)
+               seq_puts(seq, "Type Device      Function\n");
+       else {
+               if (pt->type == htons(ETH_P_ALL))
+                       seq_puts(seq, "ALL ");
+               else
+                       seq_printf(seq, "%04x", ntohs(pt->type));
+
+               seq_printf(seq, " %-8s ",
+                          pt->dev ? pt->dev->name : "");
+               ptype_seq_decode(seq,  pt->func);
+               seq_putc(seq, '\n');
+       }
+
+       return 0;
+}
+
+static const struct seq_operations ptype_seq_ops = {
+       .start = ptype_seq_start,
+       .next  = ptype_seq_next,
+       .stop  = ptype_seq_stop,
+       .show  = ptype_seq_show,
+};
+
+static int ptype_seq_open(struct inode *inode, struct file *file)
+{
+       return seq_open(file, &ptype_seq_ops);
+}
+
+static const struct file_operations ptype_seq_fops = {
+       .owner   = THIS_MODULE,
+       .open    = ptype_seq_open,
+       .read    = seq_read,
+       .llseek  = seq_lseek,
+       .release = seq_release,
+};
+
+
+static int dev_proc_net_init(struct net *net)
+{
+       int rc = -ENOMEM;
+
+       if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
+               goto out;
+       if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
+               goto out_dev;
+       if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
+               goto out_softnet;
+
+       if (wext_proc_init(net))
+               goto out_ptype;
+       rc = 0;
+out:
+       return rc;
+out_ptype:
+       proc_net_remove(net, "ptype");
+out_softnet:
+       proc_net_remove(net, "softnet_stat");
+out_dev:
+       proc_net_remove(net, "dev");
+       goto out;
+}
+
+static void dev_proc_net_exit(struct net *net)
+{
+       wext_proc_exit(net);
+
+       proc_net_remove(net, "ptype");
+       proc_net_remove(net, "softnet_stat");
+       proc_net_remove(net, "dev");
+}
+
+static struct pernet_operations dev_proc_ops = {
+       .init = dev_proc_net_init,
+       .exit = dev_proc_net_exit,
+};
+
+static int __init dev_proc_init(void)
+{
+       return register_pernet_subsys(&dev_proc_ops);
+}
+#else
+#define dev_proc_init() 0
+#endif /* CONFIG_PROC_FS */
+
+
+/**
+ *     netdev_set_master       -       set up master/slave pair
+ *     @slave: slave device
+ *     @master: new master device
+ *
+ *     Changes the master device of the slave. Pass %NULL to break the
+ *     bonding. The caller must hold the RTNL semaphore. On a failure
+ *     a negative errno code is returned. On success the reference counts
+ *     are adjusted, %RTM_NEWLINK is sent to the routing socket and the
+ *     function returns zero.
+ */
+int netdev_set_master(struct net_device *slave, struct net_device *master)
+{
+       struct net_device *old = slave->master;
+
+       ASSERT_RTNL();
+
+       if (master) {
+               if (old)
+                       return -EBUSY;
+               dev_hold(master);
+       }
+
+       slave->master = master;
+
+       synchronize_net();
+
+       if (old)
+               dev_put(old);
+
+       if (master)
+               slave->flags |= IFF_SLAVE;
+       else
+               slave->flags &= ~IFF_SLAVE;
+
+       rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
+       return 0;
+}
+
+/**
+ *     dev_set_promiscuity     - update promiscuity count on a device
+ *     @dev: device
+ *     @inc: modifier
+ *
+ *     Add or remove promiscuity from a device. While the count in the device
+ *     remains above zero the interface remains promiscuous. Once it hits zero
+ *     the device reverts back to normal filtering operation. A negative inc
+ *     value is used to drop promiscuity on the device.
+ */
+void dev_set_promiscuity(struct net_device *dev, int inc)
+{
+       unsigned short old_flags = dev->flags;
+
+       if ((dev->promiscuity += inc) == 0)
+               dev->flags &= ~IFF_PROMISC;
+       else
+               dev->flags |= IFF_PROMISC;
+       if (dev->flags != old_flags) {
+               dev_mc_upload(dev);
+               printk(KERN_INFO "device %s %s promiscuous mode\n",
+                      dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
+                                                              "left");
+               audit_log(current->audit_context, GFP_ATOMIC,
+                       AUDIT_ANOM_PROMISCUOUS,
+                       "dev=%s prom=%d old_prom=%d auid=%u",
+                       dev->name, (dev->flags & IFF_PROMISC),
+                       (old_flags & IFF_PROMISC),
+                       audit_get_loginuid(current->audit_context));
+       }
+}
+
+/**
+ *     dev_set_allmulti        - update allmulti count on a device
+ *     @dev: device
+ *     @inc: modifier
+ *
+ *     Add or remove reception of all multicast frames to a device. While the
+ *     count in the device remains above zero the interface remains listening
+ *     to all interfaces. Once it hits zero the device reverts back to normal
+ *     filtering operation. A negative @inc value is used to drop the counter
+ *     when releasing a resource needing all multicasts.
+ */
+
+void dev_set_allmulti(struct net_device *dev, int inc)
+{
+       unsigned short old_flags = dev->flags;
+
+       dev->flags |= IFF_ALLMULTI;
+       if ((dev->allmulti += inc) == 0)
+               dev->flags &= ~IFF_ALLMULTI;
+       if (dev->flags ^ old_flags)
+               dev_mc_upload(dev);
+}
+
+unsigned dev_get_flags(const struct net_device *dev)
+{
+       unsigned flags;
+
+       flags = (dev->flags & ~(IFF_PROMISC |
+                               IFF_ALLMULTI |
+                               IFF_RUNNING |
+                               IFF_LOWER_UP |
+                               IFF_DORMANT)) |
+               (dev->gflags & (IFF_PROMISC |
+                               IFF_ALLMULTI));
+
+       if (netif_running(dev)) {
+               if (netif_oper_up(dev))
+                       flags |= IFF_RUNNING;
+               if (netif_carrier_ok(dev))
+                       flags |= IFF_LOWER_UP;
+               if (netif_dormant(dev))
+                       flags |= IFF_DORMANT;
+       }
+
+       return flags;
+}
+
+int dev_change_flags(struct net_device *dev, unsigned flags)
+{
+       int ret, changes;
+       int old_flags = dev->flags;
+
+       /*
+        *      Set the flags on our device.
+        */
+
+       dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
+                              IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
+                              IFF_AUTOMEDIA)) |
+                    (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
+                                   IFF_ALLMULTI));
+
+       /*
+        *      Load in the correct multicast list now the flags have changed.
+        */
+
+       dev_mc_upload(dev);
+
+       /*
+        *      Have we downed the interface. We handle IFF_UP ourselves
+        *      according to user attempts to set it, rather than blindly
+        *      setting it.
+        */
+
+       ret = 0;
+       if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
+               ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
+
+               if (!ret)
+                       dev_mc_upload(dev);
+       }
+
+       if (dev->flags & IFF_UP &&
+           ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
+                                         IFF_VOLATILE)))
+               raw_notifier_call_chain(&netdev_chain,
+                               NETDEV_CHANGE, dev);
+
+       if ((flags ^ dev->gflags) & IFF_PROMISC) {
+               int inc = (flags & IFF_PROMISC) ? +1 : -1;
+               dev->gflags ^= IFF_PROMISC;
+               dev_set_promiscuity(dev, inc);
+       }
+
+       /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
+          is important. Some (broken) drivers set IFF_PROMISC, when
+          IFF_ALLMULTI is requested not asking us and not reporting.
+        */
+       if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
+               int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
+               dev->gflags ^= IFF_ALLMULTI;
+               dev_set_allmulti(dev, inc);
+       }
+
+       /* Exclude state transition flags, already notified */
+       changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
+       if (changes)
+               rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
+
+       return ret;
+}
+
+int dev_set_mtu(struct net_device *dev, int new_mtu)
+{
+       int err;
+
+       if (new_mtu == dev->mtu)
+               return 0;
+
+       /*      MTU must be positive.    */
+       if (new_mtu < 0)
+               return -EINVAL;
+
+       if (!netif_device_present(dev))
+               return -ENODEV;
+
+       err = 0;
+       if (dev->change_mtu)
+               err = dev->change_mtu(dev, new_mtu);
+       else
+               dev->mtu = new_mtu;
+       if (!err && dev->flags & IFF_UP)
+               raw_notifier_call_chain(&netdev_chain,
+                               NETDEV_CHANGEMTU, dev);
+       return err;
+}
+
+int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
+{
+       int err;
+
+       if (!dev->set_mac_address)
+               return -EOPNOTSUPP;
+       if (sa->sa_family != dev->type)
+               return -EINVAL;
+       if (!netif_device_present(dev))
+               return -ENODEV;
+       err = dev->set_mac_address(dev, sa);
+       if (!err)
+               raw_notifier_call_chain(&netdev_chain,
+                               NETDEV_CHANGEADDR, dev);
+       return err;
+}
+
+/*
+ *     Perform the SIOCxIFxxx calls.
+ */
+static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
+{
+       int err;
+       struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
+
+       if (!dev)
+               return -ENODEV;
+
+       switch (cmd) {
+               case SIOCGIFFLAGS:      /* Get interface flags */
+                       ifr->ifr_flags = dev_get_flags(dev);
+                       return 0;
+
+               case SIOCSIFFLAGS:      /* Set interface flags */
+                       return dev_change_flags(dev, ifr->ifr_flags);
+
+               case SIOCGIFMETRIC:     /* Get the metric on the interface
+                                          (currently unused) */
+                       ifr->ifr_metric = 0;
+                       return 0;
+
+               case SIOCSIFMETRIC:     /* Set the metric on the interface
+                                          (currently unused) */
+                       return -EOPNOTSUPP;
+
+               case SIOCGIFMTU:        /* Get the MTU of a device */
+                       ifr->ifr_mtu = dev->mtu;
+                       return 0;
+
+               case SIOCSIFMTU:        /* Set the MTU of a device */
+                       return dev_set_mtu(dev, ifr->ifr_mtu);
+
+               case SIOCGIFHWADDR:
+                       if (!dev->addr_len)
+                               memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
+                       else
+                               memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
+                                      min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
+                       ifr->ifr_hwaddr.sa_family = dev->type;
+                       return 0;
+
+               case SIOCSIFHWADDR:
+                       return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
+
+               case SIOCSIFHWBROADCAST:
+                       if (ifr->ifr_hwaddr.sa_family != dev->type)
+                               return -EINVAL;
+                       memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
+                              min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
+                       raw_notifier_call_chain(&netdev_chain,
+                                           NETDEV_CHANGEADDR, dev);
+                       return 0;
+
+               case SIOCGIFMAP:
+                       ifr->ifr_map.mem_start = dev->mem_start;
+                       ifr->ifr_map.mem_end   = dev->mem_end;
+                       ifr->ifr_map.base_addr = dev->base_addr;
+                       ifr->ifr_map.irq       = dev->irq;
+                       ifr->ifr_map.dma       = dev->dma;
+                       ifr->ifr_map.port      = dev->if_port;
+                       return 0;
+
+               case SIOCSIFMAP:
+                       if (dev->set_config) {
+                               if (!netif_device_present(dev))
+                                       return -ENODEV;
+                               return dev->set_config(dev, &ifr->ifr_map);
+                       }
+                       return -EOPNOTSUPP;
+
+               case SIOCADDMULTI:
+                       if (!dev->set_multicast_list ||
+                           ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
+                               return -EINVAL;
+                       if (!netif_device_present(dev))
+                               return -ENODEV;
+                       return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
+                                         dev->addr_len, 1);
+
+               case SIOCDELMULTI:
+                       if (!dev->set_multicast_list ||
+                           ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
+                               return -EINVAL;
+                       if (!netif_device_present(dev))
+                               return -ENODEV;
+                       return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
+                                            dev->addr_len, 1);
+
+               case SIOCGIFINDEX:
+                       ifr->ifr_ifindex = dev->ifindex;
+                       return 0;
+
+               case SIOCGIFTXQLEN:
+                       ifr->ifr_qlen = dev->tx_queue_len;
+                       return 0;
+
+               case SIOCSIFTXQLEN:
+                       if (ifr->ifr_qlen < 0)
+                               return -EINVAL;
+                       dev->tx_queue_len = ifr->ifr_qlen;
+                       return 0;
+
+               case SIOCSIFNAME:
+                       ifr->ifr_newname[IFNAMSIZ-1] = '\0';
+                       return dev_change_name(dev, ifr->ifr_newname);
+
+               /*
+                *      Unknown or private ioctl
+                */
+
+               default:
+                       if ((cmd >= SIOCDEVPRIVATE &&
+                           cmd <= SIOCDEVPRIVATE + 15) ||
+                           cmd == SIOCBONDENSLAVE ||
+                           cmd == SIOCBONDRELEASE ||
+                           cmd == SIOCBONDSETHWADDR ||
+                           cmd == SIOCBONDSLAVEINFOQUERY ||
+                           cmd == SIOCBONDINFOQUERY ||
+                           cmd == SIOCBONDCHANGEACTIVE ||
+                           cmd == SIOCGMIIPHY ||
+                           cmd == SIOCGMIIREG ||
+                           cmd == SIOCSMIIREG ||
+                           cmd == SIOCBRADDIF ||
+                           cmd == SIOCBRDELIF ||
+                           cmd == SIOCWANDEV) {
+                               err = -EOPNOTSUPP;
+                               if (dev->do_ioctl) {
+                                       if (netif_device_present(dev))
+                                               err = dev->do_ioctl(dev, ifr,
+                                                                   cmd);
+                                       else
+                                               err = -ENODEV;
+                               }
+                       } else
+                               err = -EINVAL;
+
+       }
+       return err;
+}
+
+/*
+ *     This function handles all "interface"-type I/O control requests. The actual
+ *     'doing' part of this is dev_ifsioc above.
+ */
+
+/**
+ *     dev_ioctl       -       network device ioctl
+ *     @cmd: command to issue
+ *     @arg: pointer to a struct ifreq in user space
+ *
+ *     Issue ioctl functions to devices. This is normally called by the
+ *     user space syscall interfaces but can sometimes be useful for
+ *     other purposes. The return value is the return from the syscall if
+ *     positive or a negative errno code on error.
+ */
+
+int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
+{
+       struct ifreq ifr;
+       int ret;
+       char *colon;
+
+       /* One special case: SIOCGIFCONF takes ifconf argument
+          and requires shared lock, because it sleeps writing
+          to user space.
+        */
+
+       if (cmd == SIOCGIFCONF) {
+               rtnl_lock();
+               ret = dev_ifconf(net, (char __user *) arg);
+               rtnl_unlock();
+               return ret;
+       }
+       if (cmd == SIOCGIFNAME)
+               return dev_ifname(net, (struct ifreq __user *)arg);
+
+       if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
+               return -EFAULT;
+
+       ifr.ifr_name[IFNAMSIZ-1] = 0;
+
+       colon = strchr(ifr.ifr_name, ':');
+       if (colon)
+               *colon = 0;
+
+       /*
+        *      See which interface the caller is talking about.
+        */
+
+       switch (cmd) {
+               /*
+                *      These ioctl calls:
+                *      - can be done by all.
+                *      - atomic and do not require locking.
+                *      - return a value
+                */
+               case SIOCGIFFLAGS:
+               case SIOCGIFMETRIC:
+               case SIOCGIFMTU:
+               case SIOCGIFHWADDR:
+               case SIOCGIFSLAVE:
+               case SIOCGIFMAP:
+               case SIOCGIFINDEX:
+               case SIOCGIFTXQLEN:
+                       dev_load(net, ifr.ifr_name);
+                       read_lock(&dev_base_lock);
+                       ret = dev_ifsioc(net, &ifr, cmd);
+                       read_unlock(&dev_base_lock);
+                       if (!ret) {
+                               if (colon)
+                                       *colon = ':';
+                               if (copy_to_user(arg, &ifr,
+                                                sizeof(struct ifreq)))
+                                       ret = -EFAULT;
+                       }
+                       return ret;
+
+               case SIOCETHTOOL:
+                       dev_load(net, ifr.ifr_name);
+                       rtnl_lock();
+                       ret = dev_ethtool(net, &ifr);
+                       rtnl_unlock();
+                       if (!ret) {
+                               if (colon)
+                                       *colon = ':';
+                               if (copy_to_user(arg, &ifr,
+                                                sizeof(struct ifreq)))
+                                       ret = -EFAULT;
+                       }
+                       return ret;
+
+               /*
+                *      These ioctl calls:
+                *      - require superuser power.
+                *      - require strict serialization.
+                *      - return a value
+                */
+               case SIOCGMIIPHY:
+               case SIOCGMIIREG:
+               case SIOCSIFNAME:
+                       if (!capable(CAP_NET_ADMIN))
+                               return -EPERM;
+                       dev_load(net, ifr.ifr_name);
+                       rtnl_lock();
+                       ret = dev_ifsioc(net, &ifr, cmd);
+                       rtnl_unlock();
+                       if (!ret) {
+                               if (colon)
+                                       *colon = ':';
+                               if (copy_to_user(arg, &ifr,
+                                                sizeof(struct ifreq)))
+                                       ret = -EFAULT;
+                       }
+                       return ret;
+
+               /*
+                *      These ioctl calls:
+                *      - require superuser power.
+                *      - require strict serialization.
+                *      - do not return a value
+                */
+               case SIOCSIFFLAGS:
+               case SIOCSIFMETRIC:
+               case SIOCSIFMTU:
+               case SIOCSIFMAP:
+               case SIOCSIFHWADDR:
+               case SIOCSIFSLAVE:
+               case SIOCADDMULTI:
+               case SIOCDELMULTI:
+               case SIOCSIFHWBROADCAST:
+               case SIOCSIFTXQLEN:
+               case SIOCSMIIREG:
+               case SIOCBONDENSLAVE:
+               case SIOCBONDRELEASE:
+               case SIOCBONDSETHWADDR:
+               case SIOCBONDCHANGEACTIVE:
+               case SIOCBRADDIF:
+               case SIOCBRDELIF:
+                       if (!capable(CAP_NET_ADMIN))
+                               return -EPERM;
+                       /* fall through */
+               case SIOCBONDSLAVEINFOQUERY:
+               case SIOCBONDINFOQUERY:
+                       dev_load(net, ifr.ifr_name);
+                       rtnl_lock();
+                       ret = dev_ifsioc(net, &ifr, cmd);
+                       rtnl_unlock();
+                       return ret;
+
+               case SIOCGIFMEM:
+                       /* Get the per device memory space. We can add this but
+                        * currently do not support it */
+               case SIOCSIFMEM:
+                       /* Set the per device memory buffer space.
+                        * Not applicable in our case */
+               case SIOCSIFLINK:
+                       return -EINVAL;
+
+               /*
+                *      Unknown or private ioctl.
+                */
+               default:
+                       if (cmd == SIOCWANDEV ||
+                           (cmd >= SIOCDEVPRIVATE &&
+                            cmd <= SIOCDEVPRIVATE + 15)) {
+                               dev_load(net, ifr.ifr_name);
+                               rtnl_lock();
+                               ret = dev_ifsioc(net, &ifr, cmd);
+                               rtnl_unlock();
+                               if (!ret && copy_to_user(arg, &ifr,
+                                                        sizeof(struct ifreq)))
+                                       ret = -EFAULT;
+                               return ret;
+                       }
+                       /* Take care of Wireless Extensions */
+                       if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
+                               return wext_handle_ioctl(net, &ifr, cmd, arg);
+                       return -EINVAL;
+       }
+}
+
+
+/**
+ *     dev_new_index   -       allocate an ifindex
+ *
+ *     Returns a suitable unique value for a new device interface
+ *     number.  The caller must hold the rtnl semaphore or the
+ *     dev_base_lock to be sure it remains unique.
+ */
+static int dev_new_index(struct net *net)
+{
+       static int ifindex;
+       for (;;) {
+               if (++ifindex <= 0)
+                       ifindex = 1;
+               if (!__dev_get_by_index(net, ifindex))
+                       return ifindex;
+       }
+}
+
+/* Delayed registration/unregisteration */
+static DEFINE_SPINLOCK(net_todo_list_lock);
+static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
+
+static void net_set_todo(struct net_device *dev)
+{
+       spin_lock(&net_todo_list_lock);
+       list_add_tail(&dev->todo_list, &net_todo_list);
+       spin_unlock(&net_todo_list_lock);
+}
+
+/**
+ *     register_netdevice      - register a network device
+ *     @dev: device to register
+ *
+ *     Take a completed network device structure and add it to the kernel
+ *     interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
+ *     chain. 0 is returned on success. A negative errno code is returned
+ *     on a failure to set up the device, or if the name is a duplicate.
+ *
+ *     Callers must hold the rtnl semaphore. You may want
+ *     register_netdev() instead of this.
+ *
+ *     BUGS:
+ *     The locking appears insufficient to guarantee two parallel registers
+ *     will not get the same name.
+ */
+
+int register_netdevice(struct net_device *dev)
+{
+       struct hlist_head *head;
+       struct hlist_node *p;
+       int ret;
+       struct net *net;
+
+       BUG_ON(dev_boot_phase);
+       ASSERT_RTNL();
+
+       might_sleep();
+
+       /* When net_device's are persistent, this will be fatal. */
+       BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
+       BUG_ON(!dev->nd_net);
+       net = dev->nd_net;
+
+       spin_lock_init(&dev->queue_lock);
+       spin_lock_init(&dev->_xmit_lock);
+       netdev_set_lockdep_class(&dev->_xmit_lock, dev->type);
+       dev->xmit_lock_owner = -1;
+       spin_lock_init(&dev->ingress_lock);
+
+       dev->iflink = -1;
+
+       /* Init, if this function is available */
+       if (dev->init) {
+               ret = dev->init(dev);
+               if (ret) {
+                       if (ret > 0)
+                               ret = -EIO;
+                       goto out;
+               }
+       }
+
+       if (!dev_valid_name(dev->name)) {
+               ret = -EINVAL;
+               goto out;
+       }
+
+       dev->ifindex = dev_new_index(net);
+       if (dev->iflink == -1)
+               dev->iflink = dev->ifindex;
+
+       /* Check for existence of name */
+       head = dev_name_hash(net, dev->name);
+       hlist_for_each(p, head) {
+               struct net_device *d
+                       = hlist_entry(p, struct net_device, name_hlist);
+               if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
+                       ret = -EEXIST;
+                       goto out;
+               }
+       }
+
+       /* Fix illegal checksum combinations */
+       if ((dev->features & NETIF_F_HW_CSUM) &&
+           (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
+               printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
+                      dev->name);
+               dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
+       }
+
+       if ((dev->features & NETIF_F_NO_CSUM) &&
+           (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
+               printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
+                      dev->name);
+               dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
+       }
+
+
+       /* Fix illegal SG+CSUM combinations. */
+       if ((dev->features & NETIF_F_SG) &&
+           !(dev->features & NETIF_F_ALL_CSUM)) {
+               printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
+                      dev->name);
+               dev->features &= ~NETIF_F_SG;
+       }
+
+       /* TSO requires that SG is present as well. */
+       if ((dev->features & NETIF_F_TSO) &&
+           !(dev->features & NETIF_F_SG)) {
+               printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
+                      dev->name);
+               dev->features &= ~NETIF_F_TSO;
+       }
+       if (dev->features & NETIF_F_UFO) {
+               if (!(dev->features & NETIF_F_HW_CSUM)) {
+                       printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
+                                       "NETIF_F_HW_CSUM feature.\n",
+                                                       dev->name);
+                       dev->features &= ~NETIF_F_UFO;
+               }
+               if (!(dev->features & NETIF_F_SG)) {
+                       printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
+                                       "NETIF_F_SG feature.\n",
+                                       dev->name);
+                       dev->features &= ~NETIF_F_UFO;
+               }
+       }
+
+       /*
+        *      nil rebuild_header routine,
+        *      that should be never called and used as just bug trap.
+        */
+
+       if (!dev->rebuild_header)
+               dev->rebuild_header = default_rebuild_header;
+
+       ret = netdev_register_sysfs(dev);
+       if (ret)
+               goto out;
+       dev->reg_state = NETREG_REGISTERED;
+
+       /*
+        *      Default initial state at registry is that the
+        *      device is present.
+        */
+
+       set_bit(__LINK_STATE_PRESENT, &dev->state);
+
+       dev_init_scheduler(dev);
+       dev_hold(dev);
+       list_netdevice(dev);
+
+       /* Notify protocols, that a new device appeared. */
+       raw_notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev);
+
+       ret = 0;
+
+out:
+       return ret;
+}
+
+/**
+ *     register_netdev - register a network device
+ *     @dev: device to register
+ *
+ *     Take a completed network device structure and add it to the kernel
+ *     interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
+ *     chain. 0 is returned on success. A negative errno code is returned
+ *     on a failure to set up the device, or if the name is a duplicate.
+ *
+ *     This is a wrapper around register_netdevice that takes the rtnl semaphore
+ *     and expands the device name if you passed a format string to
+ *     alloc_netdev.
+ */
+int register_netdev(struct net_device *dev)
+{
+       int err;
+
+       rtnl_lock();
+
+       /*
+        * If the name is a format string the caller wants us to do a
+        * name allocation.
+        */
+       if (strchr(dev->name, '%')) {
+               err = dev_alloc_name(dev, dev->name);
+               if (err < 0)
+                       goto out;
+       }
+
+       err = register_netdevice(dev);
+out:
+       rtnl_unlock();
+       return err;
+}
+EXPORT_SYMBOL(register_netdev);
+
+/*
+ * netdev_wait_allrefs - wait until all references are gone.
+ *
+ * This is called when unregistering network devices.
+ *
+ * Any protocol or device that holds a reference should register
+ * for netdevice notification, and cleanup and put back the
+ * reference if they receive an UNREGISTER event.
+ * We can get stuck here if buggy protocols don't correctly
+ * call dev_put.
+ */
+static void netdev_wait_allrefs(struct net_device *dev)
+{
+       unsigned long rebroadcast_time, warning_time;
+
+       rebroadcast_time = warning_time = jiffies;
+       while (atomic_read(&dev->refcnt) != 0) {
+               if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
+                       rtnl_lock();
+
+                       /* Rebroadcast unregister notification */
+                       raw_notifier_call_chain(&netdev_chain,
+                                           NETDEV_UNREGISTER, dev);
+
+                       if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
+                                    &dev->state)) {
+                               /* We must not have linkwatch events
+                                * pending on unregister. If this
+                                * happens, we simply run the queue
+                                * unscheduled, resulting in a noop
+                                * for this device.
+                                */
+                               linkwatch_run_queue();
+                       }
+
+                       __rtnl_unlock();
+
+                       rebroadcast_time = jiffies;
+               }
+
+               msleep(250);
+
+               if (time_after(jiffies, warning_time + 10 * HZ)) {
+                       printk(KERN_EMERG "unregister_netdevice: "
+                              "waiting for %s to become free. Usage "
+                              "count = %d\n",
+                              dev->name, atomic_read(&dev->refcnt));
+                       warning_time = jiffies;
+               }
+       }
+}
+
+/* The sequence is:
+ *
+ *     rtnl_lock();
+ *     ...
+ *     register_netdevice(x1);
+ *     register_netdevice(x2);
+ *     ...
+ *     unregister_netdevice(y1);
+ *     unregister_netdevice(y2);
+ *      ...
+ *     rtnl_unlock();
+ *     free_netdev(y1);
+ *     free_netdev(y2);
+ *
+ * We are invoked by rtnl_unlock() after it drops the semaphore.
+ * This allows us to deal with problems:
+ * 1) We can delete sysfs objects which invoke hotplug
+ *    without deadlocking with linkwatch via keventd.
+ * 2) Since we run with the RTNL semaphore not held, we can sleep
+ *    safely in order to wait for the netdev refcnt to drop to zero.
+ */
+static DEFINE_MUTEX(net_todo_run_mutex);
+void netdev_run_todo(void)
+{
+       struct list_head list;
+
+       /* Need to guard against multiple cpu's getting out of order. */
+       mutex_lock(&net_todo_run_mutex);
+
+       /* Not safe to do outside the semaphore.  We must not return
+        * until all unregister events invoked by the local processor
+        * have been completed (either by this todo run, or one on
+        * another cpu).
+        */
+       if (list_empty(&net_todo_list))
+               goto out;
+
+       /* Snapshot list, allow later requests */
+       spin_lock(&net_todo_list_lock);
+       list_replace_init(&net_todo_list, &list);
+       spin_unlock(&net_todo_list_lock);
+
+       while (!list_empty(&list)) {
+               struct net_device *dev
+                       = list_entry(list.next, struct net_device, todo_list);
+               list_del(&dev->todo_list);
+
+               if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
+                       printk(KERN_ERR "network todo '%s' but state %d\n",
+                              dev->name, dev->reg_state);
+                       dump_stack();
+                       continue;
+               }
+
+               dev->reg_state = NETREG_UNREGISTERED;
+
+               netdev_wait_allrefs(dev);
+
+               /* paranoia */
+               BUG_ON(atomic_read(&dev->refcnt));
+               BUG_TRAP(!dev->ip_ptr);
+               BUG_TRAP(!dev->ip6_ptr);
+               BUG_TRAP(!dev->dn_ptr);
+
+               if (dev->destructor)
+                       dev->destructor(dev);
+
+               /* Free network device */
+               kobject_put(&dev->dev.kobj);
+       }
+
+out:
+       mutex_unlock(&net_todo_run_mutex);
+}
+
+static struct net_device_stats *internal_stats(struct net_device *dev)
+{
+       return &dev->stats;
+}
+
+/**
+ *     alloc_netdev - allocate network device
+ *     @sizeof_priv:   size of private data to allocate space for
+ *     @name:          device name format string
+ *     @setup:         callback to initialize device
+ *
+ *     Allocates a struct net_device with private data area for driver use
+ *     and performs basic initialization.
+ */
+struct net_device *alloc_netdev(int sizeof_priv, const char *name,
+               void (*setup)(struct net_device *))
+{
+       void *p;
+       struct net_device *dev;
+       int alloc_size;
+
+       BUG_ON(strlen(name) >= sizeof(dev->name));
+
+       /* ensure 32-byte alignment of both the device and private area */
+       alloc_size = (sizeof(*dev) + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
+       alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
+
+       p = kzalloc(alloc_size, GFP_KERNEL);
+       if (!p) {
+               printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
+               return NULL;
+       }
+
+       dev = (struct net_device *)
+               (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
+       dev->padded = (char *)dev - (char *)p;
+       dev->nd_net = &init_net;
+
+       if (sizeof_priv)
+               dev->priv = netdev_priv(dev);
+
+       dev->get_stats = internal_stats;
+       setup(dev);
+       strcpy(dev->name, name);
+       return dev;
+}
+EXPORT_SYMBOL(alloc_netdev);
+
+/**
+ *     free_netdev - free network device
+ *     @dev: device
+ *
+ *     This function does the last stage of destroying an allocated device
+ *     interface. The reference to the device object is released.
+ *     If this is the last reference then it will be freed.
+ */
+void free_netdev(struct net_device *dev)
+{
+#ifdef CONFIG_SYSFS
+       /*  Compatibility with error handling in drivers */
+       if (dev->reg_state == NETREG_UNINITIALIZED) {
+               kfree((char *)dev - dev->padded);
+               return;
+       }
+
+       BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
+       dev->reg_state = NETREG_RELEASED;
+
+       /* will free via device release */
+       put_device(&dev->dev);
+#else
+       kfree((char *)dev - dev->padded);
+#endif
+}
+
+/* Synchronize with packet receive processing. */
+void synchronize_net(void)
+{
+       might_sleep();
+       synchronize_rcu();
+}
+
+/**
+ *     unregister_netdevice - remove device from the kernel
+ *     @dev: device
+ *
+ *     This function shuts down a device interface and removes it
+ *     from the kernel tables. On success 0 is returned, on a failure
+ *     a negative errno code is returned.
+ *
+ *     Callers must hold the rtnl semaphore.  You may want
+ *     unregister_netdev() instead of this.
+ */
+
+void unregister_netdevice(struct net_device *dev)
+{
+       BUG_ON(dev_boot_phase);
+       ASSERT_RTNL();
+
+       /* Some devices call without registering for initialization unwind. */
+       if (dev->reg_state == NETREG_UNINITIALIZED) {
+               printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
+                                 "was registered\n", dev->name, dev);
+
+               WARN_ON(1);
+               return;
+       }
+
+       BUG_ON(dev->reg_state != NETREG_REGISTERED);
+
+       /* If device is running, close it first. */
+       if (dev->flags & IFF_UP)
+               dev_close(dev);
+
+       /* And unlink it from device chain. */
+       unlist_netdevice(dev);
+
+       dev->reg_state = NETREG_UNREGISTERING;
+
+       synchronize_net();
+
+       /* Shutdown queueing discipline. */
+       dev_shutdown(dev);
+
+
+       /* Notify protocols, that we are about to destroy
+          this device. They should clean all the things.
+       */
+       raw_notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
+
+       /*
+        *      Flush the multicast chain
+        */
+       dev_mc_discard(dev);
+
+       if (dev->uninit)
+               dev->uninit(dev);
+
+       /* Notifier chain MUST detach us from master device. */
+       BUG_TRAP(!dev->master);
+
+       /* Remove entries from sysfs */
+       netdev_unregister_sysfs(dev);
+
+       /* Finish processing unregister after unlock */
+       net_set_todo(dev);
+
+       synchronize_net();
+
+       dev_put(dev);
+}
+
+/**
+ *     unregister_netdev - remove device from the kernel
+ *     @dev: device
+ *
+ *     This function shuts down a device interface and removes it
+ *     from the kernel tables. On success 0 is returned, on a failure
+ *     a negative errno code is returned.
+ *
+ *     This is just a wrapper for unregister_netdevice that takes
+ *     the rtnl semaphore.  In general you want to use this and not
+ *     unregister_netdevice.
+ */
+void unregister_netdev(struct net_device *dev)
+{
+       rtnl_lock();
+       unregister_netdevice(dev);
+       rtnl_unlock();
+}
+
+EXPORT_SYMBOL(unregister_netdev);
+
+/**
+ *     dev_change_net_namespace - move device to different nethost namespace
+ *     @dev: device
+ *     @net: network namespace
+ *     @pat: If not NULL name pattern to try if the current device name
+ *           is already taken in the destination network namespace.
+ *
+ *     This function shuts down a device interface and moves it
+ *     to a new network namespace. On success 0 is returned, on
+ *     a failure a netagive errno code is returned.
+ *
+ *     Callers must hold the rtnl semaphore.
+ */
+
+int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
+{
+       char buf[IFNAMSIZ];
+       const char *destname;
+       int err;
+
+       ASSERT_RTNL();
+
+       /* Don't allow namespace local devices to be moved. */
+       err = -EINVAL;
+       if (dev->features & NETIF_F_NETNS_LOCAL)
+               goto out;
+
+       /* Ensure the device has been registrered */
+       err = -EINVAL;
+       if (dev->reg_state != NETREG_REGISTERED)
+               goto out;
+       
+       /* Get out if there is nothing todo */
+       err = 0;
+       if (dev->nd_net == net)
+               goto out;
+
+       /* Pick the destination device name, and ensure
+        * we can use it in the destination network namespace.
+        */
+       err = -EEXIST;
+       destname = dev->name;
+       if (__dev_get_by_name(net, destname)) {
+               /* We get here if we can't use the current device name */
+               if (!pat)
+                       goto out;
+               if (!dev_valid_name(pat))
+                       goto out;
+               if (strchr(pat, '%')) {
+                       if (__dev_alloc_name(net, pat, buf) < 0)
+                               goto out;
+                       destname = buf;
+               } else
+                       destname = pat;
+               if (__dev_get_by_name(net, destname))
+                       goto out;
+       }
+
+       /*
+        * And now a mini version of register_netdevice unregister_netdevice. 
+        */
+
+       /* If device is running close it first. */
+       if (dev->flags & IFF_UP)
+               dev_close(dev);
+
+       /* And unlink it from device chain */
+       err = -ENODEV;
+       unlist_netdevice(dev);
+       
+       synchronize_net();
+       
+       /* Shutdown queueing discipline. */
+       dev_shutdown(dev);
+
+       /* Notify protocols, that we are about to destroy
+          this device. They should clean all the things.
+       */
+       call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
+       
+       /*
+        *      Flush the multicast chain
+        */
+       dev_mc_discard(dev);
+
+       /* Actually switch the network namespace */
+       dev->nd_net = net;
+       
+       /* Assign the new device name */
+       if (destname != dev->name)
+               strcpy(dev->name, destname);
+
+       /* If there is an ifindex conflict assign a new one */
+       if (__dev_get_by_index(net, dev->ifindex)) {
+               int iflink = (dev->iflink == dev->ifindex);
+               dev->ifindex = dev_new_index(net);
+               if (iflink)
+                       dev->iflink = dev->ifindex;
+       }
+
+       /* Fixup sysfs */
+       err = device_rename(&dev->dev, dev->name);
+       BUG_ON(err);
+
+       /* Add the device back in the hashes */
+       list_netdevice(dev);
+
+       /* Notify protocols, that a new device appeared. */
+       call_netdevice_notifiers(NETDEV_REGISTER, dev);
+
+       synchronize_net();
+       err = 0;
+out:
+       return err;
+}
+
+static int dev_cpu_callback(struct notifier_block *nfb,
+                           unsigned long action,
+                           void *ocpu)
+{
+       struct sk_buff **list_skb;
+       struct net_device **list_net;
+       struct sk_buff *skb;
+       unsigned int cpu, oldcpu = (unsigned long)ocpu;
+       struct softnet_data *sd, *oldsd;
+
+       if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
+               return NOTIFY_OK;
+
+       local_irq_disable();
+       cpu = smp_processor_id();
+       sd = &per_cpu(softnet_data, cpu);
+       oldsd = &per_cpu(softnet_data, oldcpu);
+
+       /* Find end of our completion_queue. */
+       list_skb = &sd->completion_queue;
+       while (*list_skb)
+               list_skb = &(*list_skb)->next;
+       /* Append completion queue from offline CPU. */
+       *list_skb = oldsd->completion_queue;
+       oldsd->completion_queue = NULL;
+
+       /* Find end of our output_queue. */
+       list_net = &sd->output_queue;
+       while (*list_net)
+               list_net = &(*list_net)->next_sched;
+       /* Append output queue from offline CPU. */
+       *list_net = oldsd->output_queue;
+       oldsd->output_queue = NULL;
+
+       raise_softirq_irqoff(NET_TX_SOFTIRQ);
+       local_irq_enable();
+
+       /* Process offline CPU's input_pkt_queue */
+       while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
+               netif_rx(skb);
+
+       return NOTIFY_OK;
+}
+
+#ifdef CONFIG_NET_DMA
+/**
+ * net_dma_rebalance -
+ * This is called when the number of channels allocated to the net_dma_client
+ * changes.  The net_dma_client tries to have one DMA channel per CPU.
+ */
+
+static void net_dma_rebalance(struct net_dma *net_dma)
+{
+       unsigned int cpu, i, n, chan_idx;
+       struct dma_chan *chan;
+
+       if (cpus_empty(net_dma->channel_mask)) {
+               for_each_online_cpu(cpu)
+                       rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
+               return;
+       }
+
+       i = 0;
+       cpu = first_cpu(cpu_online_map);
+
+       for_each_cpu_mask(chan_idx, net_dma->channel_mask) {
+               chan = net_dma->channels[chan_idx];
+
+               n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
+                  + (i < (num_online_cpus() %
+                       cpus_weight(net_dma->channel_mask)) ? 1 : 0));
+
+               while(n) {
+                       per_cpu(softnet_data, cpu).net_dma = chan;
+                       cpu = next_cpu(cpu, cpu_online_map);
+                       n--;
+               }
+               i++;
+       }
+}
+
+/**
+ * netdev_dma_event - event callback for the net_dma_client
+ * @client: should always be net_dma_client
+ * @chan: DMA channel for the event
+ * @event: event type
+ */
+static enum dma_state_client
+netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
+       enum dma_state state)
+{
+       int i, found = 0, pos = -1;
+       struct net_dma *net_dma =
+               container_of(client, struct net_dma, client);
+       enum dma_state_client ack = DMA_DUP; /* default: take no action */
+
+       spin_lock(&net_dma->lock);
+       switch (state) {
+       case DMA_RESOURCE_AVAILABLE:
+               for (i = 0; i < NR_CPUS; i++)
+                       if (net_dma->channels[i] == chan) {
+                               found = 1;
+                               break;
+                       } else if (net_dma->channels[i] == NULL && pos < 0)
+                               pos = i;
+
+               if (!found && pos >= 0) {
+                       ack = DMA_ACK;
+                       net_dma->channels[pos] = chan;
+                       cpu_set(pos, net_dma->channel_mask);
+                       net_dma_rebalance(net_dma);
+               }
+               break;
+       case DMA_RESOURCE_REMOVED:
+               for (i = 0; i < NR_CPUS; i++)
+                       if (net_dma->channels[i] == chan) {
+                               found = 1;
+                               pos = i;
+                               break;
+                       }
+
+               if (found) {
+                       ack = DMA_ACK;
+                       cpu_clear(pos, net_dma->channel_mask);
+                       net_dma->channels[i] = NULL;
+                       net_dma_rebalance(net_dma);
+               }
+               break;
+       default:
+               break;
+       }
+       spin_unlock(&net_dma->lock);
+
+       return ack;
+}
+
+/**
+ * netdev_dma_regiser - register the networking subsystem as a DMA client
+ */
+static int __init netdev_dma_register(void)
+{
+       spin_lock_init(&net_dma.lock);
+       dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
+       dma_async_client_register(&net_dma.client);
+       dma_async_client_chan_request(&net_dma.client);
+       return 0;
+}
+
+#else
+static int __init netdev_dma_register(void) { return -ENODEV; }
+#endif /* CONFIG_NET_DMA */
+
+/**
+ *     netdev_compute_feature - compute conjunction of two feature sets
+ *     @all: first feature set
+ *     @one: second feature set
+ *
+ *     Computes a new feature set after adding a device with feature set
+ *     @one to the master device with current feature set @all.  Returns
+ *     the new feature set.
+ */
+int netdev_compute_features(unsigned long all, unsigned long one)
+{
+       /* if device needs checksumming, downgrade to hw checksumming */
+       if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
+               all ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
+
+       /* if device can't do all checksum, downgrade to ipv4 */
+       if (all & NETIF_F_HW_CSUM && !(one & NETIF_F_HW_CSUM))
+               all ^= NETIF_F_HW_CSUM | NETIF_F_IP_CSUM;
+
+       if (one & NETIF_F_GSO)
+               one |= NETIF_F_GSO_SOFTWARE;
+       one |= NETIF_F_GSO;
+
+       /* If even one device supports robust GSO, enable it for all. */
+       if (one & NETIF_F_GSO_ROBUST)
+               all |= NETIF_F_GSO_ROBUST;
+
+       all &= one | NETIF_F_LLTX;
+
+       if (!(all & NETIF_F_ALL_CSUM))
+               all &= ~NETIF_F_SG;
+       if (!(all & NETIF_F_SG))
+               all &= ~NETIF_F_GSO_MASK;
+
+       return all;
+}
+EXPORT_SYMBOL(netdev_compute_features);
+
+/* Initialize per network namespace state */
+static int netdev_init(struct net *net)
+{
+       int i;
+       INIT_LIST_HEAD(&net->dev_base_head);
+       rwlock_init(&dev_base_lock);
+
+       net->dev_name_head = kmalloc(
+               sizeof(*net->dev_name_head)*NETDEV_HASHENTRIES, GFP_KERNEL);
+       if (!net->dev_name_head)
+               return -ENOMEM;
+
+       net->dev_index_head = kmalloc(
+               sizeof(*net->dev_index_head)*NETDEV_HASHENTRIES, GFP_KERNEL);
+       if (!net->dev_index_head) {
+               kfree(net->dev_name_head);
+               return -ENOMEM;
+       }
+
+       for (i = 0; i < NETDEV_HASHENTRIES; i++)
+               INIT_HLIST_HEAD(&net->dev_name_head[i]);
+       
+       for (i = 0; i < NETDEV_HASHENTRIES; i++)
+               INIT_HLIST_HEAD(&net->dev_index_head[i]);
+
+       return 0;
+}
+
+static void netdev_exit(struct net *net)
+{
+       kfree(net->dev_name_head);
+       kfree(net->dev_index_head);
+}
+
+static struct pernet_operations netdev_net_ops = {
+       .init = netdev_init,
+       .exit = netdev_exit,
+};
+
+static void default_device_exit(struct net *net)
+{
+       struct net_device *dev, *next;
+       /*
+        * Push all migratable of the network devices back to the
+        * initial network namespace 
+        */
+       rtnl_lock();
+       for_each_netdev_safe(net, dev, next) {
+               int err;
+
+               /* Ignore unmoveable devices (i.e. loopback) */
+               if (dev->features & NETIF_F_NETNS_LOCAL)
+                       continue;
+
+               /* Push remaing network devices to init_net */
+               err = dev_change_net_namespace(dev, &init_net, "dev%d");
+               if (err) {
+                       printk(KERN_WARNING "%s: failed to move %s to init_net: %d\n",
+                               __func__, dev->name, err);
+                       unregister_netdevice(dev);
+               }
+       }
+       rtnl_unlock();
+}
+
+static struct pernet_operations default_device_ops = {
+       .exit = default_device_exit,
+};
+
+/*
+ *     Initialize the DEV module. At boot time this walks the device list and
+ *     unhooks any devices that fail to initialise (normally hardware not
+ *     present) and leaves us with a valid list of present and active devices.
+ *
+ */
+
+/*
+ *       This is called single threaded during boot, so no need
+ *       to take the rtnl semaphore.
+ */
+static int __init net_dev_init(void)
+{
+       int i, rc = -ENOMEM;
+
+       BUG_ON(!dev_boot_phase);
+
+       if (dev_proc_init())
+               goto out;
+
+       if (netdev_sysfs_init())
+               goto out;
+
+       INIT_LIST_HEAD(&ptype_all);
+       for (i = 0; i < 16; i++)
+               INIT_LIST_HEAD(&ptype_base[i]);
+
+       if (register_pernet_subsys(&netdev_net_ops))
+               goto out;
+
+       if (register_pernet_device(&default_device_ops))
+               goto out;
+
+       /*
+        *      Initialise the packet receive queues.
+        */
+
+       for_each_possible_cpu(i) {
+               struct softnet_data *queue;
+
+               queue = &per_cpu(softnet_data, i);
+               skb_queue_head_init(&queue->input_pkt_queue);
+               queue->completion_queue = NULL;
+               INIT_LIST_HEAD(&queue->poll_list);
+               set_bit(__LINK_STATE_START, &queue->backlog_dev.state);
+               queue->backlog_dev.weight = weight_p;
+               queue->backlog_dev.poll = process_backlog;
+               atomic_set(&queue->backlog_dev.refcnt, 1);
+       }
+
+       netdev_dma_register();
+
+       dev_boot_phase = 0;
+
+       open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
+       open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
+
+       hotcpu_notifier(dev_cpu_callback, 0);
+       dst_init();
+       dev_mcast_init();
+       rc = 0;
+out:
+       return rc;
+}
+
+subsys_initcall(net_dev_init);
+
+EXPORT_SYMBOL(__dev_get_by_index);
+EXPORT_SYMBOL(__dev_get_by_name);
+EXPORT_SYMBOL(__dev_remove_pack);
+EXPORT_SYMBOL(dev_valid_name);
+EXPORT_SYMBOL(dev_add_pack);
+EXPORT_SYMBOL(dev_alloc_name);
+EXPORT_SYMBOL(dev_close);
+EXPORT_SYMBOL(dev_get_by_flags);
+EXPORT_SYMBOL(dev_get_by_index);
+EXPORT_SYMBOL(dev_get_by_name);
+EXPORT_SYMBOL(dev_open);
+EXPORT_SYMBOL(dev_queue_xmit);
+EXPORT_SYMBOL(dev_remove_pack);
+EXPORT_SYMBOL(dev_set_allmulti);
+EXPORT_SYMBOL(dev_set_promiscuity);
+EXPORT_SYMBOL(dev_change_flags);
+EXPORT_SYMBOL(dev_set_mtu);
+EXPORT_SYMBOL(dev_set_mac_address);
+EXPORT_SYMBOL(free_netdev);
+EXPORT_SYMBOL(netdev_boot_setup_check);
+EXPORT_SYMBOL(netdev_set_master);
+EXPORT_SYMBOL(netdev_state_change);
+EXPORT_SYMBOL(netif_receive_skb);
+EXPORT_SYMBOL(netif_rx);
+EXPORT_SYMBOL(register_gifconf);
+EXPORT_SYMBOL(register_netdevice);
+EXPORT_SYMBOL(register_netdevice_notifier);
+EXPORT_SYMBOL(skb_checksum_help);
+EXPORT_SYMBOL(synchronize_net);
+EXPORT_SYMBOL(unregister_netdevice);
+EXPORT_SYMBOL(unregister_netdevice_notifier);
+EXPORT_SYMBOL(net_enable_timestamp);
+EXPORT_SYMBOL(net_disable_timestamp);
+EXPORT_SYMBOL(dev_get_flags);
+
+#if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
+EXPORT_SYMBOL(br_handle_frame_hook);
+EXPORT_SYMBOL(br_fdb_get_hook);
+EXPORT_SYMBOL(br_fdb_put_hook);
+#endif
+
+#ifdef CONFIG_KMOD
+EXPORT_SYMBOL(dev_load);
+#endif
+
+EXPORT_PER_CPU_SYMBOL(softnet_data);
diff -Nurb linux-2.6.22-594/net/core/net_namespace.c linux-2.6.22-595/net/core/net_namespace.c
--- linux-2.6.22-594/net/core/net_namespace.c   2008-03-20 01:27:51.000000000 -0400
+++ linux-2.6.22-595/net/core/net_namespace.c   2008-03-20 01:28:00.000000000 -0400
@@ -112,10 +112,12 @@
                ops = list_entry(ptr, struct pernet_operations, list);
                if (ops->init) {
                        error = ops->init(net);
-                       if (error < 0)
+                       if (error < 0) {
+                               printk(KERN_ALERT "Error setting up netns: %x\n", ops->init);
                                goto out_undo;
                }
        }
+       }
 out:
        return error;
 out_undo:
diff -Nurb linux-2.6.22-594/net/ipv4/af_inet.c.orig linux-2.6.22-595/net/ipv4/af_inet.c.orig
--- linux-2.6.22-594/net/ipv4/af_inet.c.orig    2008-03-20 01:27:51.000000000 -0400
+++ linux-2.6.22-595/net/ipv4/af_inet.c.orig    1969-12-31 19:00:00.000000000 -0500
@@ -1,1522 +0,0 @@
-/*
- * INET                An implementation of the TCP/IP protocol suite for the LINUX
- *             operating system.  INET is implemented using the  BSD Socket
- *             interface as the means of communication with the user level.
- *
- *             PF_INET protocol family socket handler.
- *
- * Version:    $Id: af_inet.c,v 1.137 2002/02/01 22:01:03 davem Exp $
- *
- * Authors:    Ross Biro
- *             Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
- *             Florian La Roche, <flla@stud.uni-sb.de>
- *             Alan Cox, <A.Cox@swansea.ac.uk>
- *
- * Changes (see also sock.c)
- *
- *             piggy,
- *             Karl Knutson    :       Socket protocol table
- *             A.N.Kuznetsov   :       Socket death error in accept().
- *             John Richardson :       Fix non blocking error in connect()
- *                                     so sockets that fail to connect
- *                                     don't return -EINPROGRESS.
- *             Alan Cox        :       Asynchronous I/O support
- *             Alan Cox        :       Keep correct socket pointer on sock
- *                                     structures
- *                                     when accept() ed
- *             Alan Cox        :       Semantics of SO_LINGER aren't state
- *                                     moved to close when you look carefully.
- *                                     With this fixed and the accept bug fixed
- *                                     some RPC stuff seems happier.
- *             Niibe Yutaka    :       4.4BSD style write async I/O
- *             Alan Cox,
- *             Tony Gale       :       Fixed reuse semantics.
- *             Alan Cox        :       bind() shouldn't abort existing but dead
- *                                     sockets. Stops FTP netin:.. I hope.
- *             Alan Cox        :       bind() works correctly for RAW sockets.
- *                                     Note that FreeBSD at least was broken
- *                                     in this respect so be careful with
- *                                     compatibility tests...
- *             Alan Cox        :       routing cache support
- *             Alan Cox        :       memzero the socket structure for
- *                                     compactness.
- *             Matt Day        :       nonblock connect error handler
- *             Alan Cox        :       Allow large numbers of pending sockets
- *                                     (eg for big web sites), but only if
- *                                     specifically application requested.
- *             Alan Cox        :       New buffering throughout IP. Used
- *                                     dumbly.
- *             Alan Cox        :       New buffering now used smartly.
- *             Alan Cox        :       BSD rather than common sense
- *                                     interpretation of listen.
- *             Germano Caronni :       Assorted small races.
- *             Alan Cox        :       sendmsg/recvmsg basic support.
- *             Alan Cox        :       Only sendmsg/recvmsg now supported.
- *             Alan Cox        :       Locked down bind (see security list).
- *             Alan Cox        :       Loosened bind a little.
- *             Mike McLagan    :       ADD/DEL DLCI Ioctls
- *     Willy Konynenberg       :       Transparent proxying support.
- *             David S. Miller :       New socket lookup architecture.
- *                                     Some other random speedups.
- *             Cyrus Durgin    :       Cleaned up file for kmod hacks.
- *             Andi Kleen      :       Fix inet_stream_connect TCP race.
- *
- *             This program is free software; you can redistribute it and/or
- *             modify it under the terms of the GNU General Public License
- *             as published by the Free Software Foundation; either version
- *             2 of the License, or (at your option) any later version.
- */
-
-#include <linux/err.h>
-#include <linux/errno.h>
-#include <linux/types.h>
-#include <linux/socket.h>
-#include <linux/in.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/sched.h>
-#include <linux/timer.h>
-#include <linux/string.h>
-#include <linux/sockios.h>
-#include <linux/net.h>
-#include <linux/capability.h>
-#include <linux/fcntl.h>
-#include <linux/mm.h>
-#include <linux/interrupt.h>
-#include <linux/stat.h>
-#include <linux/init.h>
-#include <linux/poll.h>
-#include <linux/netfilter_ipv4.h>
-#include <linux/random.h>
-
-#include <asm/uaccess.h>
-#include <asm/system.h>
-
-#include <linux/inet.h>
-#include <linux/igmp.h>
-#include <linux/inetdevice.h>
-#include <linux/netdevice.h>
-#include <net/ip.h>
-#include <net/protocol.h>
-#include <net/arp.h>
-#include <net/route.h>
-#include <net/ip_fib.h>
-#include <net/inet_connection_sock.h>
-#include <net/tcp.h>
-#include <net/udp.h>
-#include <net/udplite.h>
-#include <linux/skbuff.h>
-#include <net/sock.h>
-#include <net/raw.h>
-#include <net/icmp.h>
-#include <net/ipip.h>
-#include <net/inet_common.h>
-#include <net/xfrm.h>
-#ifdef CONFIG_IP_MROUTE
-#include <linux/mroute.h>
-#endif
-#include <linux/vs_limit.h>
-
-DEFINE_SNMP_STAT(struct linux_mib, net_statistics) __read_mostly;
-
-extern void ip_mc_drop_socket(struct sock *sk);
-
-/* The inetsw table contains everything that inet_create needs to
- * build a new socket.
- */
-static struct list_head inetsw[SOCK_MAX];
-static DEFINE_SPINLOCK(inetsw_lock);
-
-/* New destruction routine */
-
-void inet_sock_destruct(struct sock *sk)
-{
-       struct inet_sock *inet = inet_sk(sk);
-
-       __skb_queue_purge(&sk->sk_receive_queue);
-       __skb_queue_purge(&sk->sk_error_queue);
-
-       if (sk->sk_type == SOCK_STREAM && sk->sk_state != TCP_CLOSE) {
-               printk("Attempt to release TCP socket in state %d %p\n",
-                      sk->sk_state, sk);
-               return;
-       }
-       if (!sock_flag(sk, SOCK_DEAD)) {
-               printk("Attempt to release alive inet socket %p\n", sk);
-               return;
-       }
-
-       BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
-       BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
-       BUG_TRAP(!sk->sk_wmem_queued);
-       BUG_TRAP(!sk->sk_forward_alloc);
-
-       kfree(inet->opt);
-       dst_release(sk->sk_dst_cache);
-       sk_refcnt_debug_dec(sk);
-}
-
-/*
- *     The routines beyond this point handle the behaviour of an AF_INET
- *     socket object. Mostly it punts to the subprotocols of IP to do
- *     the work.
- */
-
-/*
- *     Automatically bind an unbound socket.
- */
-
-static int inet_autobind(struct sock *sk)
-{
-       struct inet_sock *inet;
-       /* We may need to bind the socket. */
-       lock_sock(sk);
-       inet = inet_sk(sk);
-       if (!inet->num) {
-               if (sk->sk_prot->get_port(sk, 0)) {
-                       release_sock(sk);
-                       return -EAGAIN;
-               }
-               inet->sport = htons(inet->num);
-               sk->sk_xid = vx_current_xid();
-               sk->sk_nid = nx_current_nid();
-       }
-       release_sock(sk);
-       return 0;
-}
-
-/*
- *     Move a socket into listening state.
- */
-int inet_listen(struct socket *sock, int backlog)
-{
-       struct sock *sk = sock->sk;
-       unsigned char old_state;
-       int err;
-
-       lock_sock(sk);
-
-       err = -EINVAL;
-       if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM)
-               goto out;
-
-       old_state = sk->sk_state;
-       if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN)))
-               goto out;
-
-       /* Really, if the socket is already in listen state
-        * we can only allow the backlog to be adjusted.
-        */
-       if (old_state != TCP_LISTEN) {
-               err = inet_csk_listen_start(sk, backlog);
-               if (err)
-                       goto out;
-       }
-       sk->sk_max_ack_backlog = backlog;
-       err = 0;
-
-out:
-       release_sock(sk);
-       return err;
-}
-
-u32 inet_ehash_secret __read_mostly;
-EXPORT_SYMBOL(inet_ehash_secret);
-
-/*
- * inet_ehash_secret must be set exactly once
- * Instead of using a dedicated spinlock, we (ab)use inetsw_lock
- */
-void build_ehash_secret(void)
-{
-       u32 rnd;
-       do {
-               get_random_bytes(&rnd, sizeof(rnd));
-       } while (rnd == 0);
-       spin_lock_bh(&inetsw_lock);
-       if (!inet_ehash_secret)
-               inet_ehash_secret = rnd;
-       spin_unlock_bh(&inetsw_lock);
-}
-EXPORT_SYMBOL(build_ehash_secret);
-
-/*
- *     Create an inet socket.
- */
-
-static int inet_create(struct socket *sock, int protocol)
-{
-       struct sock *sk;
-       struct list_head *p;
-       struct inet_protosw *answer;
-       struct inet_sock *inet;
-       struct proto *answer_prot;
-       unsigned char answer_flags;
-       char answer_no_check;
-       int try_loading_module = 0;
-       int err;
-
-       if (sock->type != SOCK_RAW &&
-           sock->type != SOCK_DGRAM &&
-           !inet_ehash_secret)
-               build_ehash_secret();
-
-       sock->state = SS_UNCONNECTED;
-
-       /* Look for the requested type/protocol pair. */
-       answer = NULL;
-lookup_protocol:
-       err = -ESOCKTNOSUPPORT;
-       rcu_read_lock();
-       list_for_each_rcu(p, &inetsw[sock->type]) {
-               answer = list_entry(p, struct inet_protosw, list);
-
-               /* Check the non-wild match. */
-               if (protocol == answer->protocol) {
-                       if (protocol != IPPROTO_IP)
-                               break;
-               } else {
-                       /* Check for the two wild cases. */
-                       if (IPPROTO_IP == protocol) {
-                               protocol = answer->protocol;
-                               break;
-                       }
-                       if (IPPROTO_IP == answer->protocol)
-                               break;
-               }
-               err = -EPROTONOSUPPORT;
-               answer = NULL;
-       }
-
-       if (unlikely(answer == NULL)) {
-               if (try_loading_module < 2) {
-                       rcu_read_unlock();
-                       /*
-                        * Be more specific, e.g. net-pf-2-proto-132-type-1
-                        * (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM)
-                        */
-                       if (++try_loading_module == 1)
-                               request_module("net-pf-%d-proto-%d-type-%d",
-                                              PF_INET, protocol, sock->type);
-                       /*
-                        * Fall back to generic, e.g. net-pf-2-proto-132
-                        * (net-pf-PF_INET-proto-IPPROTO_SCTP)
-                        */
-                       else
-                               request_module("net-pf-%d-proto-%d",
-                                              PF_INET, protocol);
-                       goto lookup_protocol;
-               } else
-                       goto out_rcu_unlock;
-       }
-
-       err = -EPERM;
-       if ((protocol == IPPROTO_ICMP) &&
-               nx_capable(answer->capability, NXC_RAW_ICMP))
-               goto override;
-       if (sock->type == SOCK_RAW &&
-               nx_capable(answer->capability, NXC_RAW_SOCKET))
-               goto override;
-       if (answer->capability > 0 && !capable(answer->capability))
-               goto out_rcu_unlock;
-override:
-       sock->ops = answer->ops;
-       answer_prot = answer->prot;
-       answer_no_check = answer->no_check;
-       answer_flags = answer->flags;
-       rcu_read_unlock();
-
-       BUG_TRAP(answer_prot->slab != NULL);
-
-       err = -ENOBUFS;
-       sk = sk_alloc(PF_INET, GFP_KERNEL, answer_prot, 1);
-       if (sk == NULL)
-               goto out;
-
-       err = 0;
-       sk->sk_no_check = answer_no_check;
-       if (INET_PROTOSW_REUSE & answer_flags)
-               sk->sk_reuse = 1;
-
-       inet = inet_sk(sk);
-       inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;
-
-       if (SOCK_RAW == sock->type) {
-               inet->num = protocol;
-               if (IPPROTO_RAW == protocol)
-                       inet->hdrincl = 1;
-       }
-
-       if (ipv4_config.no_pmtu_disc)
-               inet->pmtudisc = IP_PMTUDISC_DONT;
-       else
-               inet->pmtudisc = IP_PMTUDISC_WANT;
-
-       inet->id = 0;
-
-       sock_init_data(sock, sk);
-
-       sk->sk_destruct    = inet_sock_destruct;
-       sk->sk_family      = PF_INET;
-       sk->sk_protocol    = protocol;
-       sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
-
-       inet->uc_ttl    = -1;
-       inet->mc_loop   = 1;
-       inet->mc_ttl    = 1;
-       inet->mc_index  = 0;
-       inet->mc_list   = NULL;
-
-       sk_refcnt_debug_inc(sk);
-
-       if (inet->num) {
-               /* It assumes that any protocol which allows
-                * the user to assign a number at socket
-                * creation time automatically
-                * shares.
-                */
-               inet->sport = htons(inet->num);
-               /* Add to protocol hash chains. */
-               sk->sk_prot->hash(sk);
-       }
-
-       if (sk->sk_prot->init) {
-               err = sk->sk_prot->init(sk);
-               if (err)
-                       sk_common_release(sk);
-       }
-out:
-       return err;
-out_rcu_unlock:
-       rcu_read_unlock();
-       goto out;
-}
-
-
-/*
- *     The peer socket should always be NULL (or else). When we call this
- *     function we are destroying the object and from then on nobody
- *     should refer to it.
- */
-int inet_release(struct socket *sock)
-{
-       struct sock *sk = sock->sk;
-
-       if (sk) {
-               long timeout;
-
-               /* Applications forget to leave groups before exiting */
-               ip_mc_drop_socket(sk);
-
-               /* If linger is set, we don't return until the close
-                * is complete.  Otherwise we return immediately. The
-                * actually closing is done the same either way.
-                *
-                * If the close is due to the process exiting, we never
-                * linger..
-                */
-               timeout = 0;
-               if (sock_flag(sk, SOCK_LINGER) &&
-                   !(current->flags & PF_EXITING))
-                       timeout = sk->sk_lingertime;
-               sock->sk = NULL;
-               sk->sk_prot->close(sk, timeout);
-       }
-       return 0;
-}
-
-/* It is off by default, see below. */
-int sysctl_ip_nonlocal_bind __read_mostly;
-
-int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
-{
-       struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
-       struct sock *sk = sock->sk;
-       struct inet_sock *inet = inet_sk(sk);
-       struct nx_v4_sock_addr nsa;
-       unsigned short snum;
-       int chk_addr_ret;
-       int err;
-
-       /* If the socket has its own bind function then use it. (RAW) */
-       if (sk->sk_prot->bind) {
-               err = sk->sk_prot->bind(sk, uaddr, addr_len);
-               goto out;
-       }
-       err = -EINVAL;
-       if (addr_len < sizeof(struct sockaddr_in))
-               goto out;
-
-       err = v4_map_sock_addr(inet, addr, &nsa);
-       if (err)
-               goto out;
-
-       chk_addr_ret = inet_addr_type(nsa.saddr);
-
-       /* Not specified by any standard per-se, however it breaks too
-        * many applications when removed.  It is unfortunate since
-        * allowing applications to make a non-local bind solves
-        * several problems with systems using dynamic addressing.
-        * (ie. your servers still start up even if your ISDN link
-        *  is temporarily down)
-        */
-       err = -EADDRNOTAVAIL;
-       if (!sysctl_ip_nonlocal_bind &&
-           !inet->freebind &&
-           nsa.saddr != INADDR_ANY &&
-           chk_addr_ret != RTN_LOCAL &&
-           chk_addr_ret != RTN_MULTICAST &&
-           chk_addr_ret != RTN_BROADCAST)
-               goto out;
-
-       snum = ntohs(addr->sin_port);
-       err = -EACCES;
-       if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
-               goto out;
-
-       /*      We keep a pair of addresses. rcv_saddr is the one
-        *      used by hash lookups, and saddr is used for transmit.
-        *
-        *      In the BSD API these are the same except where it
-        *      would be illegal to use them (multicast/broadcast) in
-        *      which case the sending device address is used.
-        */
-       lock_sock(sk);
-
-       /* Check these errors (active socket, double bind). */
-       err = -EINVAL;
-       if (sk->sk_state != TCP_CLOSE || inet->num)
-               goto out_release_sock;
-
-       v4_set_sock_addr(inet, &nsa);
-       if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
-               inet->saddr = 0;  /* Use device */
-
-       /* Make sure we are allowed to bind here. */
-       if (sk->sk_prot->get_port(sk, snum)) {
-               inet->saddr = inet->rcv_saddr = 0;
-               err = -EADDRINUSE;
-               goto out_release_sock;
-       }
-
-       if (inet->rcv_saddr)
-               sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
-       if (snum)
-               sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
-       inet->sport = htons(inet->num);
-       inet->daddr = 0;
-       inet->dport = 0;
-       sk_dst_reset(sk);
-       err = 0;
-out_release_sock:
-       release_sock(sk);
-out:
-       return err;
-}
-
-int inet_dgram_connect(struct socket *sock, struct sockaddr * uaddr,
-                      int addr_len, int flags)
-{
-       struct sock *sk = sock->sk;
-
-       if (uaddr->sa_family == AF_UNSPEC)
-               return sk->sk_prot->disconnect(sk, flags);
-
-       if (!inet_sk(sk)->num && inet_autobind(sk))
-               return -EAGAIN;
-       return sk->sk_prot->connect(sk, (struct sockaddr *)uaddr, addr_len);
-}
-
-static long inet_wait_for_connect(struct sock *sk, long timeo)
-{
-       DEFINE_WAIT(wait);
-
-       prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
-
-       /* Basic assumption: if someone sets sk->sk_err, he _must_
-        * change state of the socket from TCP_SYN_*.
-        * Connect() does not allow to get error notifications
-        * without closing the socket.
-        */
-       while ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
-               release_sock(sk);
-               timeo = schedule_timeout(timeo);
-               lock_sock(sk);
-               if (signal_pending(current) || !timeo)
-                       break;
-               prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
-       }
-       finish_wait(sk->sk_sleep, &wait);
-       return timeo;
-}
-
-/*
- *     Connect to a remote host. There is regrettably still a little
- *     TCP 'magic' in here.
- */
-int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
-                       int addr_len, int flags)
-{
-       struct sock *sk = sock->sk;
-       int err;
-       long timeo;
-
-       lock_sock(sk);
-
-       if (uaddr->sa_family == AF_UNSPEC) {
-               err = sk->sk_prot->disconnect(sk, flags);
-               sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
-               goto out;
-       }
-
-       switch (sock->state) {
-       default:
-               err = -EINVAL;
-               goto out;
-       case SS_CONNECTED:
-               err = -EISCONN;
-               goto out;
-       case SS_CONNECTING:
-               err = -EALREADY;
-               /* Fall out of switch with err, set for this state */
-               break;
-       case SS_UNCONNECTED:
-               err = -EISCONN;
-               if (sk->sk_state != TCP_CLOSE)
-                       goto out;
-
-               err = sk->sk_prot->connect(sk, uaddr, addr_len);
-               if (err < 0)
-                       goto out;
-
-               sock->state = SS_CONNECTING;
-
-               /* Just entered SS_CONNECTING state; the only
-                * difference is that return value in non-blocking
-                * case is EINPROGRESS, rather than EALREADY.
-                */
-               err = -EINPROGRESS;
-               break;
-       }
-
-       timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
-
-       if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
-               /* Error code is set above */
-               if (!timeo || !inet_wait_for_connect(sk, timeo))
-                       goto out;
-
-               err = sock_intr_errno(timeo);
-               if (signal_pending(current))
-                       goto out;
-       }
-
-       /* Connection was closed by RST, timeout, ICMP error
-        * or another process disconnected us.
-        */
-       if (sk->sk_state == TCP_CLOSE)
-               goto sock_error;
-
-       /* sk->sk_err may be not zero now, if RECVERR was ordered by user
-        * and error was received after socket entered established state.
-        * Hence, it is handled normally after connect() return successfully.
-        */
-
-       sock->state = SS_CONNECTED;
-       err = 0;
-out:
-       release_sock(sk);
-       return err;
-
-sock_error:
-       err = sock_error(sk) ? : -ECONNABORTED;
-       sock->state = SS_UNCONNECTED;
-       if (sk->sk_prot->disconnect(sk, flags))
-               sock->state = SS_DISCONNECTING;
-       goto out;
-}
-
-/*
- *     Accept a pending connection. The TCP layer now gives BSD semantics.
- */
-
-int inet_accept(struct socket *sock, struct socket *newsock, int flags)
-{
-       struct sock *sk1 = sock->sk;
-       int err = -EINVAL;
-       struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err);
-
-       if (!sk2)
-               goto do_err;
-
-       lock_sock(sk2);
-
-       BUG_TRAP((1 << sk2->sk_state) &
-                (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE));
-
-       sock_graft(sk2, newsock);
-
-       newsock->state = SS_CONNECTED;
-       err = 0;
-       release_sock(sk2);
-do_err:
-       return err;
-}
-
-
-/*
- *     This does both peername and sockname.
- */
-int inet_getname(struct socket *sock, struct sockaddr *uaddr,
-                       int *uaddr_len, int peer)
-{
-       struct sock *sk         = sock->sk;
-       struct inet_sock *inet  = inet_sk(sk);
-       struct sockaddr_in *sin = (struct sockaddr_in *)uaddr;
-
-       sin->sin_family = AF_INET;
-       if (peer) {
-               if (!inet->dport ||
-                   (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) &&
-                    peer == 1))
-                       return -ENOTCONN;
-               sin->sin_port = inet->dport;
-               sin->sin_addr.s_addr =
-                       nx_map_sock_lback(sk->sk_nx_info, inet->daddr);
-       } else {
-               __be32 addr = inet->rcv_saddr;
-               if (!addr)
-                       addr = inet->saddr;
-               addr = nx_map_sock_lback(sk->sk_nx_info, addr);
-               sin->sin_port = inet->sport;
-               sin->sin_addr.s_addr = addr;
-       }
-       memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
-       *uaddr_len = sizeof(*sin);
-       return 0;
-}
-
-int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
-                size_t size)
-{
-       struct sock *sk = sock->sk;
-
-       /* We may need to bind the socket. */
-       if (!inet_sk(sk)->num && inet_autobind(sk))
-               return -EAGAIN;
-
-       return sk->sk_prot->sendmsg(iocb, sk, msg, size);
-}
-
-
-static ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
-{
-       struct sock *sk = sock->sk;
-
-       /* We may need to bind the socket. */
-       if (!inet_sk(sk)->num && inet_autobind(sk))
-               return -EAGAIN;
-
-       if (sk->sk_prot->sendpage)
-               return sk->sk_prot->sendpage(sk, page, offset, size, flags);
-       return sock_no_sendpage(sock, page, offset, size, flags);
-}
-
-
-int inet_shutdown(struct socket *sock, int how)
-{
-       struct sock *sk = sock->sk;
-       int err = 0;
-
-       /* This should really check to make sure
-        * the socket is a TCP socket. (WHY AC...)
-        */
-       how++; /* maps 0->1 has the advantage of making bit 1 rcvs and
-                      1->2 bit 2 snds.
-                      2->3 */
-       if ((how & ~SHUTDOWN_MASK) || !how)     /* MAXINT->0 */
-               return -EINVAL;
-
-       lock_sock(sk);
-       if (sock->state == SS_CONNECTING) {
-               if ((1 << sk->sk_state) &
-                   (TCPF_SYN_SENT | TCPF_SYN_RECV | TCPF_CLOSE))
-                       sock->state = SS_DISCONNECTING;
-               else
-                       sock->state = SS_CONNECTED;
-       }
-
-       switch (sk->sk_state) {
-       case TCP_CLOSE:
-               err = -ENOTCONN;
-               /* Hack to wake up other listeners, who can poll for
-                  POLLHUP, even on eg. unconnected UDP sockets -- RR */
-       default:
-               sk->sk_shutdown |= how;
-               if (sk->sk_prot->shutdown)
-                       sk->sk_prot->shutdown(sk, how);
-               break;
-
-       /* Remaining two branches are temporary solution for missing
-        * close() in multithreaded environment. It is _not_ a good idea,
-        * but we have no choice until close() is repaired at VFS level.
-        */
-       case TCP_LISTEN:
-               if (!(how & RCV_SHUTDOWN))
-                       break;
-               /* Fall through */
-       case TCP_SYN_SENT:
-               err = sk->sk_prot->disconnect(sk, O_NONBLOCK);
-               sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
-               break;
-       }
-
-       /* Wake up anyone sleeping in poll. */
-       sk->sk_state_change(sk);
-       release_sock(sk);
-       return err;
-}
-
-/*
- *     ioctl() calls you can issue on an INET socket. Most of these are
- *     device configuration and stuff and very rarely used. Some ioctls
- *     pass on to the socket itself.
- *
- *     NOTE: I like the idea of a module for the config stuff. ie ifconfig
- *     loads the devconfigure module does its configuring and unloads it.
- *     There's a good 20K of config code hanging around the kernel.
- */
-
-int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
-{
-       struct sock *sk = sock->sk;
-       int err = 0;
-
-       switch (cmd) {
-               case SIOCGSTAMP:
-                       err = sock_get_timestamp(sk, (struct timeval __user *)arg);
-                       break;
-               case SIOCGSTAMPNS:
-                       err = sock_get_timestampns(sk, (struct timespec __user *)arg);
-                       break;
-               case SIOCADDRT:
-               case SIOCDELRT:
-               case SIOCRTMSG:
-                       err = ip_rt_ioctl(cmd, (void __user *)arg);
-                       break;
-               case SIOCDARP:
-               case SIOCGARP:
-               case SIOCSARP:
-                       err = arp_ioctl(cmd, (void __user *)arg);
-                       break;
-               case SIOCGIFADDR:
-               case SIOCSIFADDR:
-               case SIOCGIFBRDADDR:
-               case SIOCSIFBRDADDR:
-               case SIOCGIFNETMASK:
-               case SIOCSIFNETMASK:
-               case SIOCGIFDSTADDR:
-               case SIOCSIFDSTADDR:
-               case SIOCSIFPFLAGS:
-               case SIOCGIFPFLAGS:
-               case SIOCSIFFLAGS:
-                       err = devinet_ioctl(cmd, (void __user *)arg);
-                       break;
-               default:
-                       if (sk->sk_prot->ioctl)
-                               err = sk->sk_prot->ioctl(sk, cmd, arg);
-                       else
-                               err = -ENOIOCTLCMD;
-                       break;
-       }
-       return err;
-}
-
-const struct proto_ops inet_stream_ops = {
-       .family            = PF_INET,
-       .owner             = THIS_MODULE,
-       .release           = inet_release,
-       .bind              = inet_bind,
-       .connect           = inet_stream_connect,
-       .socketpair        = sock_no_socketpair,
-       .accept            = inet_accept,
-       .getname           = inet_getname,
-       .poll              = tcp_poll,
-       .ioctl             = inet_ioctl,
-       .listen            = inet_listen,
-       .shutdown          = inet_shutdown,
-       .setsockopt        = sock_common_setsockopt,
-       .getsockopt        = sock_common_getsockopt,
-       .sendmsg           = tcp_sendmsg,
-       .recvmsg           = sock_common_recvmsg,
-       .mmap              = sock_no_mmap,
-       .sendpage          = tcp_sendpage,
-#ifdef CONFIG_COMPAT
-       .compat_setsockopt = compat_sock_common_setsockopt,
-       .compat_getsockopt = compat_sock_common_getsockopt,
-#endif
-};
-
-const struct proto_ops inet_dgram_ops = {
-       .family            = PF_INET,
-       .owner             = THIS_MODULE,
-       .release           = inet_release,
-       .bind              = inet_bind,
-       .connect           = inet_dgram_connect,
-       .socketpair        = sock_no_socketpair,
-       .accept            = sock_no_accept,
-       .getname           = inet_getname,
-       .poll              = udp_poll,
-       .ioctl             = inet_ioctl,
-       .listen            = sock_no_listen,
-       .shutdown          = inet_shutdown,
-       .setsockopt        = sock_common_setsockopt,
-       .getsockopt        = sock_common_getsockopt,
-       .sendmsg           = inet_sendmsg,
-       .recvmsg           = sock_common_recvmsg,
-       .mmap              = sock_no_mmap,
-       .sendpage          = inet_sendpage,
-#ifdef CONFIG_COMPAT
-       .compat_setsockopt = compat_sock_common_setsockopt,
-       .compat_getsockopt = compat_sock_common_getsockopt,
-#endif
-};
-
-/*
- * For SOCK_RAW sockets; should be the same as inet_dgram_ops but without
- * udp_poll
- */
-static const struct proto_ops inet_sockraw_ops = {
-       .family            = PF_INET,
-       .owner             = THIS_MODULE,
-       .release           = inet_release,
-       .bind              = inet_bind,
-       .connect           = inet_dgram_connect,
-       .socketpair        = sock_no_socketpair,
-       .accept            = sock_no_accept,
-       .getname           = inet_getname,
-       .poll              = datagram_poll,
-       .ioctl             = inet_ioctl,
-       .listen            = sock_no_listen,
-       .shutdown          = inet_shutdown,
-       .setsockopt        = sock_common_setsockopt,
-       .getsockopt        = sock_common_getsockopt,
-       .sendmsg           = inet_sendmsg,
-       .recvmsg           = sock_common_recvmsg,
-       .mmap              = sock_no_mmap,
-       .sendpage          = inet_sendpage,
-#ifdef CONFIG_COMPAT
-       .compat_setsockopt = compat_sock_common_setsockopt,
-       .compat_getsockopt = compat_sock_common_getsockopt,
-#endif
-};
-
-static struct net_proto_family inet_family_ops = {
-       .family = PF_INET,
-       .create = inet_create,
-       .owner  = THIS_MODULE,
-};
-
-/* Upon startup we insert all the elements in inetsw_array[] into
- * the linked list inetsw.
- */
-static struct inet_protosw inetsw_array[] =
-{
-       {
-               .type =       SOCK_STREAM,
-               .protocol =   IPPROTO_TCP,
-               .prot =       &tcp_prot,
-               .ops =        &inet_stream_ops,
-               .capability = -1,
-               .no_check =   0,
-               .flags =      INET_PROTOSW_PERMANENT |
-                             INET_PROTOSW_ICSK,
-       },
-
-       {
-               .type =       SOCK_DGRAM,
-               .protocol =   IPPROTO_UDP,
-               .prot =       &udp_prot,
-               .ops =        &inet_dgram_ops,
-               .capability = -1,
-               .no_check =   UDP_CSUM_DEFAULT,
-               .flags =      INET_PROTOSW_PERMANENT,
-       },
-
-
-       {
-              .type =       SOCK_RAW,
-              .protocol =   IPPROTO_IP,        /* wild card */
-              .prot =       &raw_prot,
-              .ops =        &inet_sockraw_ops,
-              .capability = CAP_NET_RAW,
-              .no_check =   UDP_CSUM_DEFAULT,
-              .flags =      INET_PROTOSW_REUSE,
-       }
-};
-
-#define INETSW_ARRAY_LEN (sizeof(inetsw_array) / sizeof(struct inet_protosw))
-
-void inet_register_protosw(struct inet_protosw *p)
-{
-       struct list_head *lh;
-       struct inet_protosw *answer;
-       int protocol = p->protocol;
-       struct list_head *last_perm;
-
-       spin_lock_bh(&inetsw_lock);
-
-       if (p->type >= SOCK_MAX)
-               goto out_illegal;
-
-       /* If we are trying to override a permanent protocol, bail. */
-       answer = NULL;
-       last_perm = &inetsw[p->type];
-       list_for_each(lh, &inetsw[p->type]) {
-               answer = list_entry(lh, struct inet_protosw, list);
-
-               /* Check only the non-wild match. */
-               if (INET_PROTOSW_PERMANENT & answer->flags) {
-                       if (protocol == answer->protocol)
-                               break;
-                       last_perm = lh;
-               }
-
-               answer = NULL;
-       }
-       if (answer)
-               goto out_permanent;
-
-       /* Add the new entry after the last permanent entry if any, so that
-        * the new entry does not override a permanent entry when matched with
-        * a wild-card protocol. But it is allowed to override any existing
-        * non-permanent entry.  This means that when we remove this entry, the
-        * system automatically returns to the old behavior.
-        */
-       list_add_rcu(&p->list, last_perm);
-out:
-       spin_unlock_bh(&inetsw_lock);
-
-       synchronize_net();
-
-       return;
-
-out_permanent:
-       printk(KERN_ERR "Attempt to override permanent protocol %d.\n",
-              protocol);
-       goto out;
-
-out_illegal:
-       printk(KERN_ERR
-              "Ignoring attempt to register invalid socket type %d.\n",
-              p->type);
-       goto out;
-}
-
-void inet_unregister_protosw(struct inet_protosw *p)
-{
-       if (INET_PROTOSW_PERMANENT & p->flags) {
-               printk(KERN_ERR
-                      "Attempt to unregister permanent protocol %d.\n",
-                      p->protocol);
-       } else {
-               spin_lock_bh(&inetsw_lock);
-               list_del_rcu(&p->list);
-               spin_unlock_bh(&inetsw_lock);
-
-               synchronize_net();
-       }
-}
-
-/*
- *      Shall we try to damage output packets if routing dev changes?
- */
-
-int sysctl_ip_dynaddr __read_mostly;
-
-static int inet_sk_reselect_saddr(struct sock *sk)
-{
-       struct inet_sock *inet = inet_sk(sk);
-       int err;
-       struct rtable *rt;
-       __be32 old_saddr = inet->saddr;
-       __be32 new_saddr;
-       __be32 daddr = inet->daddr;
-
-       if (inet->opt && inet->opt->srr)
-               daddr = inet->opt->faddr;
-
-       /* Query new route. */
-       err = ip_route_connect(&rt, daddr, 0,
-                              RT_CONN_FLAGS(sk),
-                              sk->sk_bound_dev_if,
-                              sk->sk_protocol,
-                              inet->sport, inet->dport, sk, 0);
-       if (err)
-               return err;
-
-       sk_setup_caps(sk, &rt->u.dst);
-
-       new_saddr = rt->rt_src;
-
-       if (new_saddr == old_saddr)
-               return 0;
-
-       if (sysctl_ip_dynaddr > 1) {
-               printk(KERN_INFO "%s(): shifting inet->"
-                                "saddr from %d.%d.%d.%d to %d.%d.%d.%d\n",
-                      __FUNCTION__,
-                      NIPQUAD(old_saddr),
-                      NIPQUAD(new_saddr));
-       }
-
-       inet->saddr = inet->rcv_saddr = new_saddr;
-
-       /*
-        * XXX The only one ugly spot where we need to
-        * XXX really change the sockets identity after
-        * XXX it has entered the hashes. -DaveM
-        *
-        * Besides that, it does not check for connection
-        * uniqueness. Wait for troubles.
-        */
-       __sk_prot_rehash(sk);
-       return 0;
-}
-
-int inet_sk_rebuild_header(struct sock *sk)
-{
-       struct inet_sock *inet = inet_sk(sk);
-       struct rtable *rt = (struct rtable *)__sk_dst_check(sk, 0);
-       __be32 daddr;
-       int err;
-
-       /* Route is OK, nothing to do. */
-       if (rt)
-               return 0;
-
-       /* Reroute. */
-       daddr = inet->daddr;
-       if (inet->opt && inet->opt->srr)
-               daddr = inet->opt->faddr;
-{
-       struct flowi fl = {
-               .oif = sk->sk_bound_dev_if,
-               .nl_u = {
-                       .ip4_u = {
-                               .daddr  = daddr,
-                               .saddr  = inet->saddr,
-                               .tos    = RT_CONN_FLAGS(sk),
-                       },
-               },
-               .proto = sk->sk_protocol,
-               .uli_u = {
-                       .ports = {
-                               .sport = inet->sport,
-                               .dport = inet->dport,
-                       },
-               },
-       };
-
-       security_sk_classify_flow(sk, &fl);
-       err = ip_route_output_flow(&rt, &fl, sk, 0);
-}
-       if (!err)
-               sk_setup_caps(sk, &rt->u.dst);
-       else {
-               /* Routing failed... */
-               sk->sk_route_caps = 0;
-               /*
-                * Other protocols have to map its equivalent state to TCP_SYN_SENT.
-                * DCCP maps its DCCP_REQUESTING state to TCP_SYN_SENT. -acme
-                */
-               if (!sysctl_ip_dynaddr ||
-                   sk->sk_state != TCP_SYN_SENT ||
-                   (sk->sk_userlocks & SOCK_BINDADDR_LOCK) ||
-                   (err = inet_sk_reselect_saddr(sk)) != 0)
-                       sk->sk_err_soft = -err;
-       }
-
-       return err;
-}
-
-EXPORT_SYMBOL(inet_sk_rebuild_header);
-
-static int inet_gso_send_check(struct sk_buff *skb)
-{
-       struct iphdr *iph;
-       struct net_protocol *ops;
-       int proto;
-       int ihl;
-       int err = -EINVAL;
-
-       if (unlikely(!pskb_may_pull(skb, sizeof(*iph))))
-               goto out;
-
-       iph = ip_hdr(skb);
-       ihl = iph->ihl * 4;
-       if (ihl < sizeof(*iph))
-               goto out;
-
-       if (unlikely(!pskb_may_pull(skb, ihl)))
-               goto out;
-
-       __skb_pull(skb, ihl);
-       skb_reset_transport_header(skb);
-       iph = ip_hdr(skb);
-       proto = iph->protocol & (MAX_INET_PROTOS - 1);
-       err = -EPROTONOSUPPORT;
-
-       rcu_read_lock();
-       ops = rcu_dereference(inet_protos[proto]);
-       if (likely(ops && ops->gso_send_check))
-               err = ops->gso_send_check(skb);
-       rcu_read_unlock();
-
-out:
-       return err;
-}
-
-static struct sk_buff *inet_gso_segment(struct sk_buff *skb, int features)
-{
-       struct sk_buff *segs = ERR_PTR(-EINVAL);
-       struct iphdr *iph;
-       struct net_protocol *ops;
-       int proto;
-       int ihl;
-       int id;
-
-       if (unlikely(skb_shinfo(skb)->gso_type &
-                    ~(SKB_GSO_TCPV4 |
-                      SKB_GSO_UDP |
-                      SKB_GSO_DODGY |
-                      SKB_GSO_TCP_ECN |
-                      0)))
-               goto out;
-
-       if (unlikely(!pskb_may_pull(skb, sizeof(*iph))))
-               goto out;
-
-       iph = ip_hdr(skb);
-       ihl = iph->ihl * 4;
-       if (ihl < sizeof(*iph))
-               goto out;
-
-       if (unlikely(!pskb_may_pull(skb, ihl)))
-               goto out;
-
-       __skb_pull(skb, ihl);
-       skb_reset_transport_header(skb);
-       iph = ip_hdr(skb);
-       id = ntohs(iph->id);
-       proto = iph->protocol & (MAX_INET_PROTOS - 1);
-       segs = ERR_PTR(-EPROTONOSUPPORT);
-
-       rcu_read_lock();
-       ops = rcu_dereference(inet_protos[proto]);
-       if (likely(ops && ops->gso_segment))
-               segs = ops->gso_segment(skb, features);
-       rcu_read_unlock();
-
-       if (!segs || unlikely(IS_ERR(segs)))
-               goto out;
-
-       skb = segs;
-       do {
-               iph = ip_hdr(skb);
-               iph->id = htons(id++);
-               iph->tot_len = htons(skb->len - skb->mac_len);
-               iph->check = 0;
-               iph->check = ip_fast_csum(skb_network_header(skb), iph->ihl);
-       } while ((skb = skb->next));
-
-out:
-       return segs;
-}
-
-unsigned long snmp_fold_field(void *mib[], int offt)
-{
-       unsigned long res = 0;
-       int i;
-
-       for_each_possible_cpu(i) {
-               res += *(((unsigned long *) per_cpu_ptr(mib[0], i)) + offt);
-               res += *(((unsigned long *) per_cpu_ptr(mib[1], i)) + offt);
-       }
-       return res;
-}
-EXPORT_SYMBOL_GPL(snmp_fold_field);
-
-int snmp_mib_init(void *ptr[2], size_t mibsize, size_t mibalign)
-{
-       BUG_ON(ptr == NULL);
-       ptr[0] = __alloc_percpu(mibsize);
-       if (!ptr[0])
-               goto err0;
-       ptr[1] = __alloc_percpu(mibsize);
-       if (!ptr[1])
-               goto err1;
-       return 0;
-err1:
-       free_percpu(ptr[0]);
-       ptr[0] = NULL;
-err0:
-       return -ENOMEM;
-}
-EXPORT_SYMBOL_GPL(snmp_mib_init);
-
-void snmp_mib_free(void *ptr[2])
-{
-       BUG_ON(ptr == NULL);
-       free_percpu(ptr[0]);
-       free_percpu(ptr[1]);
-       ptr[0] = ptr[1] = NULL;
-}
-EXPORT_SYMBOL_GPL(snmp_mib_free);
-
-#ifdef CONFIG_IP_MULTICAST
-static struct net_protocol igmp_protocol = {
-       .handler =      igmp_rcv,
-};
-#endif
-
-static struct net_protocol tcp_protocol = {
-       .handler =      tcp_v4_rcv,
-       .err_handler =  tcp_v4_err,
-       .gso_send_check = tcp_v4_gso_send_check,
-       .gso_segment =  tcp_tso_segment,
-       .no_policy =    1,
-};
-
-static struct net_protocol udp_protocol = {
-       .handler =      udp_rcv,
-       .err_handler =  udp_err,
-       .no_policy =    1,
-};
-
-static struct net_protocol icmp_protocol = {
-       .handler =      icmp_rcv,
-};
-
-static int __init init_ipv4_mibs(void)
-{
-       if (snmp_mib_init((void **)net_statistics,
-                         sizeof(struct linux_mib),
-                         __alignof__(struct linux_mib)) < 0)
-               goto err_net_mib;
-       if (snmp_mib_init((void **)ip_statistics,
-                         sizeof(struct ipstats_mib),
-                         __alignof__(struct ipstats_mib)) < 0)
-               goto err_ip_mib;
-       if (snmp_mib_init((void **)icmp_statistics,
-                         sizeof(struct icmp_mib),
-                         __alignof__(struct icmp_mib)) < 0)
-               goto err_icmp_mib;
-       if (snmp_mib_init((void **)tcp_statistics,
-                         sizeof(struct tcp_mib),
-                         __alignof__(struct tcp_mib)) < 0)
-               goto err_tcp_mib;
-       if (snmp_mib_init((void **)udp_statistics,
-                         sizeof(struct udp_mib),
-                         __alignof__(struct udp_mib)) < 0)
-               goto err_udp_mib;
-       if (snmp_mib_init((void **)udplite_statistics,
-                         sizeof(struct udp_mib),
-                         __alignof__(struct udp_mib)) < 0)
-               goto err_udplite_mib;
-
-       tcp_mib_init();
-
-       return 0;
-
-err_udplite_mib:
-       snmp_mib_free((void **)udp_statistics);
-err_udp_mib:
-       snmp_mib_free((void **)tcp_statistics);
-err_tcp_mib:
-       snmp_mib_free((void **)icmp_statistics);
-err_icmp_mib:
-       snmp_mib_free((void **)ip_statistics);
-err_ip_mib:
-       snmp_mib_free((void **)net_statistics);
-err_net_mib:
-       return -ENOMEM;
-}
-
-static int ipv4_proc_init(void);
-
-/*
- *     IP protocol layer initialiser
- */
-
-static struct packet_type ip_packet_type = {
-       .type = __constant_htons(ETH_P_IP),
-       .func = ip_rcv,
-       .gso_send_check = inet_gso_send_check,
-       .gso_segment = inet_gso_segment,
-};
-
-static int __init inet_init(void)
-{
-       struct sk_buff *dummy_skb;
-       struct inet_protosw *q;
-       struct list_head *r;
-       int rc = -EINVAL;
-
-       BUILD_BUG_ON(sizeof(struct inet_skb_parm) > sizeof(dummy_skb->cb));
-
-       rc = proto_register(&tcp_prot, 1);
-       if (rc)
-               goto out;
-
-       rc = proto_register(&udp_prot, 1);
-       if (rc)
-               goto out_unregister_tcp_proto;
-
-       rc = proto_register(&raw_prot, 1);
-       if (rc)
-               goto out_unregister_udp_proto;
-
-       /*
-        *      Tell SOCKET that we are alive...
-        */
-
-       (void)sock_register(&inet_family_ops);
-
-       /*
-        *      Add all the base protocols.
-        */
-
-       if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
-               printk(KERN_CRIT "inet_init: Cannot add ICMP protocol\n");
-       if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
-               printk(KERN_CRIT "inet_init: Cannot add UDP protocol\n");
-       if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
-               printk(KERN_CRIT "inet_init: Cannot add TCP protocol\n");
-#ifdef CONFIG_IP_MULTICAST
-       if (inet_add_protocol(&igmp_protocol, IPPROTO_IGMP) < 0)
-               printk(KERN_CRIT "inet_init: Cannot add IGMP protocol\n");
-#endif
-
-       /* Register the socket-side information for inet_create. */
-       for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
-               INIT_LIST_HEAD(r);
-
-       for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
-               inet_register_protosw(q);
-
-       /*
-        *      Set the ARP module up
-        */
-
-       arp_init();
-
-       /*
-        *      Set the IP module up
-        */
-
-       ip_init();
-
-       tcp_v4_init(&inet_family_ops);
-
-       /* Setup TCP slab cache for open requests. */
-       tcp_init();
-
-       /* Add UDP-Lite (RFC 3828) */
-       udplite4_register();
-
-       /*
-        *      Set the ICMP layer up
-        */
-
-       icmp_init(&inet_family_ops);
-
-       /*
-        *      Initialise the multicast router
-        */
-#if defined(CONFIG_IP_MROUTE)
-       ip_mr_init();
-#endif
-       /*
-        *      Initialise per-cpu ipv4 mibs
-        */
-
-       if (init_ipv4_mibs())
-               printk(KERN_CRIT "inet_init: Cannot init ipv4 mibs\n"); ;
-
-       ipv4_proc_init();
-
-       ipfrag_init();
-
-       dev_add_pack(&ip_packet_type);
-
-       rc = 0;
-out:
-       return rc;
-out_unregister_udp_proto:
-       proto_unregister(&udp_prot);
-out_unregister_tcp_proto:
-       proto_unregister(&tcp_prot);
-       goto out;
-}
-
-fs_initcall(inet_init);
-
-/* ------------------------------------------------------------------------ */
-
-#ifdef CONFIG_PROC_FS
-static int __init ipv4_proc_init(void)
-{
-       int rc = 0;
-
-       if (raw_proc_init())
-               goto out_raw;
-       if (tcp4_proc_init())
-               goto out_tcp;
-       if (udp4_proc_init())
-               goto out_udp;
-       if (fib_proc_init())
-               goto out_fib;
-       if (ip_misc_proc_init())
-               goto out_misc;
-out:
-       return rc;
-out_misc:
-       fib_proc_exit();
-out_fib:
-       udp4_proc_exit();
-out_udp:
-       tcp4_proc_exit();
-out_tcp:
-       raw_proc_exit();
-out_raw:
-       rc = -ENOMEM;
-       goto out;
-}
-
-#else /* CONFIG_PROC_FS */
-static int __init ipv4_proc_init(void)
-{
-       return 0;
-}
-#endif /* CONFIG_PROC_FS */
-
-MODULE_ALIAS_NETPROTO(PF_INET);
-
-EXPORT_SYMBOL(inet_accept);
-EXPORT_SYMBOL(inet_bind);
-EXPORT_SYMBOL(inet_dgram_connect);
-EXPORT_SYMBOL(inet_dgram_ops);
-EXPORT_SYMBOL(inet_getname);
-EXPORT_SYMBOL(inet_ioctl);
-EXPORT_SYMBOL(inet_listen);
-EXPORT_SYMBOL(inet_register_protosw);
-EXPORT_SYMBOL(inet_release);
-EXPORT_SYMBOL(inet_sendmsg);
-EXPORT_SYMBOL(inet_shutdown);
-EXPORT_SYMBOL(inet_sock_destruct);
-EXPORT_SYMBOL(inet_stream_connect);
-EXPORT_SYMBOL(inet_stream_ops);
-EXPORT_SYMBOL(inet_unregister_protosw);
-EXPORT_SYMBOL(net_statistics);
-EXPORT_SYMBOL(sysctl_ip_nonlocal_bind);
diff -Nurb linux-2.6.22-594/net/netfilter/xt_MARK.c.orig linux-2.6.22-595/net/netfilter/xt_MARK.c.orig
--- linux-2.6.22-594/net/netfilter/xt_MARK.c.orig       2008-03-20 01:27:52.000000000 -0400
+++ linux-2.6.22-595/net/netfilter/xt_MARK.c.orig       1969-12-31 19:00:00.000000000 -0500
@@ -1,283 +0,0 @@
-/* This is a module which is used for setting the NFMARK field of an skb. */
-
-/* (C) 1999-2001 Marc Boucher <marc@mbsi.ca>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-#include <linux/module.h>
-#include <linux/version.h>
-#include <linux/skbuff.h>
-#include <linux/ip.h>
-#include <net/checksum.h>
-#include <net/route.h>
-#include <net/inet_hashtables.h>
-
-#include <net/netfilter/nf_conntrack.h>
-#include <linux/netfilter/x_tables.h>
-#include <linux/netfilter/xt_MARK.h>
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Marc Boucher <marc@mbsi.ca>");
-MODULE_DESCRIPTION("ip[6]tables MARK modification module");
-MODULE_ALIAS("ipt_MARK");
-MODULE_ALIAS("ip6t_MARK");
-
-static inline u_int16_t
-get_dst_port(struct nf_conntrack_tuple *tuple)
-{
-       switch (tuple->dst.protonum) {
-       case IPPROTO_GRE:
-               /* XXX Truncate 32-bit GRE key to 16 bits */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11)
-               return tuple->dst.u.gre.key;
-#else
-               return htons(ntohl(tuple->dst.u.gre.key));
-#endif  
-       case IPPROTO_ICMP:
-               /* Bind on ICMP echo ID */
-               return tuple->src.u.icmp.id;
-       case IPPROTO_TCP:
-               return tuple->dst.u.tcp.port;
-       case IPPROTO_UDP:
-               return tuple->dst.u.udp.port;
-       default:
-               return tuple->dst.u.all;
-       }
-}
-
-static inline u_int16_t
-get_src_port(struct nf_conntrack_tuple *tuple)
-{
-       switch (tuple->dst.protonum) {
-       case IPPROTO_GRE:
-               /* XXX Truncate 32-bit GRE key to 16 bits */
-               return htons(ntohl(tuple->src.u.gre.key));
-       case IPPROTO_ICMP:
-               /* Bind on ICMP echo ID */
-               return tuple->src.u.icmp.id;
-       case IPPROTO_TCP:
-               return tuple->src.u.tcp.port;
-       case IPPROTO_UDP:
-               return tuple->src.u.udp.port;
-       default:
-               return tuple->src.u.all;
-       }
-}
-
-static unsigned int
-target_v0(struct sk_buff **pskb,
-         const struct net_device *in,
-         const struct net_device *out,
-         unsigned int hooknum,
-         const struct xt_target *target,
-         const void *targinfo)
-{
-       const struct xt_mark_target_info *markinfo = targinfo;
-
-       (*pskb)->mark = markinfo->mark;
-       return XT_CONTINUE;
-}
-
-static unsigned int
-target_v1(struct sk_buff **pskb,
-         const struct net_device *in,
-         const struct net_device *out,
-         unsigned int hooknum,
-         const struct xt_target *target,
-         const void *targinfo)
-{
-       const struct xt_mark_target_info_v1 *markinfo = targinfo;
-       int mark = -1;
-
-       switch (markinfo->mode) {
-       case XT_MARK_SET:
-               mark = markinfo->mark;
-               break;
-
-       case XT_MARK_AND:
-               mark = (*pskb)->mark & markinfo->mark;
-               break;
-
-       case XT_MARK_OR:
-               mark = (*pskb)->mark | markinfo->mark;
-               break;
-
-       case XT_MARK_COPYXID: {
-               enum ip_conntrack_info ctinfo;
-               struct sock *connection_sk=NULL;
-               int dif;
-
-               struct nf_conn *ct = nf_ct_get((*pskb), &ctinfo);
-               extern struct inet_hashinfo tcp_hashinfo;
-               enum ip_conntrack_dir dir;
-               if (!ct) 
-                       break;
-
-               dir = CTINFO2DIR(ctinfo);
-               u_int32_t src_ip = ct->tuplehash[dir].tuple.src.u3.ip;
-               u_int16_t src_port = get_src_port(&ct->tuplehash[dir].tuple);
-               u_int16_t proto = ct->tuplehash[dir].tuple.dst.protonum;
-
-               u_int32_t ip;
-               u_int16_t port;
-
-               dif = ((struct rtable *)(*pskb)->dst)->rt_iif;
-               ip = ct->tuplehash[dir].tuple.dst.u3.ip;
-               port = get_dst_port(&ct->tuplehash[dir].tuple);
-
-               if (proto == 1 || proto == 17) {
-                       if (((*pskb)->mark!=-1) && (*pskb)->mark)
-                               ct->xid[0]=(*pskb)->mark;
-                       if (ct->xid[0]) 
-                               mark = ct->xid[0];
-
-               }
-               else if (proto == 6) {
-                               if ((*pskb)->sk) 
-                                       connection_sk = (*pskb)->sk;
-                               else {
-                                       connection_sk = inet_lookup(&tcp_hashinfo, src_ip, src_port, ip, port, dif);
-                               }
-
-                               if (connection_sk) {
-                                       connection_sk->sk_peercred.gid = connection_sk->sk_peercred.uid = ct->xid[dir];
-                                       ct->xid[!dir]=connection_sk->sk_xid;
-                                       if (connection_sk->sk_xid != 0) 
-                                               mark = connection_sk->sk_xid;
-                                       if (connection_sk != (*pskb)->sk)
-                                               sock_put(connection_sk);
-                               }
-                               break;
-                               }
-                             }
-       }
-
-       if (mark != -1)
-       (*pskb)->mark = mark;
-       return XT_CONTINUE;
-}
-
-
-static int
-checkentry_v0(const char *tablename,
-             const void *entry,
-             const struct xt_target *target,
-             void *targinfo,
-             unsigned int hook_mask)
-{
-       struct xt_mark_target_info *markinfo = targinfo;
-
-       if (markinfo->mark > 0xffffffff) {
-               printk(KERN_WARNING "MARK: Only supports 32bit wide mark\n");
-               return 0;
-       }
-       return 1;
-}
-
-static int
-checkentry_v1(const char *tablename,
-             const void *entry,
-             const struct xt_target *target,
-             void *targinfo,
-             unsigned int hook_mask)
-{
-       struct xt_mark_target_info_v1 *markinfo = targinfo;
-
-       if (markinfo->mode != XT_MARK_SET
-           && markinfo->mode != XT_MARK_AND
-           && markinfo->mode != XT_MARK_OR
-           && markinfo->mode != XT_MARK_COPYXID) {
-               printk(KERN_WARNING "MARK: unknown mode %u\n",
-                      markinfo->mode);
-               return 0;
-       }
-       if (markinfo->mark > 0xffffffff) {
-               printk(KERN_WARNING "MARK: Only supports 32bit wide mark\n");
-               return 0;
-       }
-       return 1;
-}
-
-#ifdef CONFIG_COMPAT
-struct compat_xt_mark_target_info_v1 {
-       compat_ulong_t  mark;
-       u_int8_t        mode;
-       u_int8_t        __pad1;
-       u_int16_t       __pad2;
-};
-
-static void compat_from_user_v1(void *dst, void *src)
-{
-       struct compat_xt_mark_target_info_v1 *cm = src;
-       struct xt_mark_target_info_v1 m = {
-               .mark   = cm->mark,
-               .mode   = cm->mode,
-       };
-       memcpy(dst, &m, sizeof(m));
-}
-
-static int compat_to_user_v1(void __user *dst, void *src)
-{
-       struct xt_mark_target_info_v1 *m = src;
-       struct compat_xt_mark_target_info_v1 cm = {
-               .mark   = m->mark,
-               .mode   = m->mode,
-       };
-       return copy_to_user(dst, &cm, sizeof(cm)) ? -EFAULT : 0;
-}
-#endif /* CONFIG_COMPAT */
-
-static struct xt_target xt_mark_target[] = {
-       {
-               .name           = "MARK",
-               .family         = AF_INET,
-               .revision       = 0,
-               .checkentry     = checkentry_v0,
-               .target         = target_v0,
-               .targetsize     = sizeof(struct xt_mark_target_info),
-               .table          = "mangle",
-               .me             = THIS_MODULE,
-       },
-       {
-               .name           = "MARK",
-               .family         = AF_INET,
-               .revision       = 1,
-               .checkentry     = checkentry_v1,
-               .target         = target_v1,
-               .targetsize     = sizeof(struct xt_mark_target_info_v1),
-#ifdef CONFIG_COMPAT
-               .compatsize     = sizeof(struct compat_xt_mark_target_info_v1),
-               .compat_from_user = compat_from_user_v1,
-               .compat_to_user = compat_to_user_v1,
-#endif
-               .table          = "mangle",
-               .me             = THIS_MODULE,
-       },
-       {
-               .name           = "MARK",
-               .family         = AF_INET6,
-               .revision       = 0,
-               .checkentry     = checkentry_v0,
-               .target         = target_v0,
-               .targetsize     = sizeof(struct xt_mark_target_info),
-               .table          = "mangle",
-               .me             = THIS_MODULE,
-       },
-};
-
-static int __init xt_mark_init(void)
-{
-       return xt_register_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
-}
-
-static void __exit xt_mark_fini(void)
-{
-       xt_unregister_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
-}
-
-module_init(xt_mark_init);
-module_exit(xt_mark_fini);
diff -Nurb linux-2.6.22-594/net/packet/af_packet.c.orig linux-2.6.22-595/net/packet/af_packet.c.orig
--- linux-2.6.22-594/net/packet/af_packet.c.orig        2008-03-20 01:27:52.000000000 -0400
+++ linux-2.6.22-595/net/packet/af_packet.c.orig        1969-12-31 19:00:00.000000000 -0500
@@ -1,1989 +0,0 @@
-/*
- * INET                An implementation of the TCP/IP protocol suite for the LINUX
- *             operating system.  INET is implemented using the  BSD Socket
- *             interface as the means of communication with the user level.
- *
- *             PACKET - implements raw packet sockets.
- *
- * Version:    $Id: af_packet.c,v 1.61 2002/02/08 03:57:19 davem Exp $
- *
- * Authors:    Ross Biro
- *             Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
- *             Alan Cox, <gw4pts@gw4pts.ampr.org>
- *
- * Fixes:
- *             Alan Cox        :       verify_area() now used correctly
- *             Alan Cox        :       new skbuff lists, look ma no backlogs!
- *             Alan Cox        :       tidied skbuff lists.
- *             Alan Cox        :       Now uses generic datagram routines I
- *                                     added. Also fixed the peek/read crash
- *                                     from all old Linux datagram code.
- *             Alan Cox        :       Uses the improved datagram code.
- *             Alan Cox        :       Added NULL's for socket options.
- *             Alan Cox        :       Re-commented the code.
- *             Alan Cox        :       Use new kernel side addressing
- *             Rob Janssen     :       Correct MTU usage.
- *             Dave Platt      :       Counter leaks caused by incorrect
- *                                     interrupt locking and some slightly
- *                                     dubious gcc output. Can you read
- *                                     compiler: it said _VOLATILE_
- *     Richard Kooijman        :       Timestamp fixes.
- *             Alan Cox        :       New buffers. Use sk->mac.raw.
- *             Alan Cox        :       sendmsg/recvmsg support.
- *             Alan Cox        :       Protocol setting support
- *     Alexey Kuznetsov        :       Untied from IPv4 stack.
- *     Cyrus Durgin            :       Fixed kerneld for kmod.
- *     Michal Ostrowski        :       Module initialization cleanup.
- *         Ulises Alonso        :       Frame number limit removal and
- *                                      packet_set_ring memory leak.
- *             Eric Biederman  :       Allow for > 8 byte hardware addresses.
- *                                     The convention is that longer addresses
- *                                     will simply extend the hardware address
- *                                     byte arrays at the end of sockaddr_ll
- *                                     and packet_mreq.
- *
- *             This program is free software; you can redistribute it and/or
- *             modify it under the terms of the GNU General Public License
- *             as published by the Free Software Foundation; either version
- *             2 of the License, or (at your option) any later version.
- *
- */
-
-#include <linux/types.h>
-#include <linux/mm.h>
-#include <linux/capability.h>
-#include <linux/fcntl.h>
-#include <linux/socket.h>
-#include <linux/in.h>
-#include <linux/inet.h>
-#include <linux/netdevice.h>
-#include <linux/if_packet.h>
-#include <linux/wireless.h>
-#include <linux/kernel.h>
-#include <linux/kmod.h>
-#include <net/ip.h>
-#include <net/protocol.h>
-#include <linux/skbuff.h>
-#include <net/sock.h>
-#include <linux/errno.h>
-#include <linux/timer.h>
-#include <asm/system.h>
-#include <asm/uaccess.h>
-#include <asm/ioctls.h>
-#include <asm/page.h>
-#include <asm/cacheflush.h>
-#include <asm/io.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-#include <linux/poll.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/vs_network.h>
-
-#ifdef CONFIG_INET
-#include <net/inet_common.h>
-#endif
-
-/*
-   Assumptions:
-   - if device has no dev->hard_header routine, it adds and removes ll header
-     inside itself. In this case ll header is invisible outside of device,
-     but higher levels still should reserve dev->hard_header_len.
-     Some devices are enough clever to reallocate skb, when header
-     will not fit to reserved space (tunnel), another ones are silly
-     (PPP).
-   - packet socket receives packets with pulled ll header,
-     so that SOCK_RAW should push it back.
-
-On receive:
------------
-
-Incoming, dev->hard_header!=NULL
-   mac_header -> ll header
-   data       -> data
-
-Outgoing, dev->hard_header!=NULL
-   mac_header -> ll header
-   data       -> ll header
-
-Incoming, dev->hard_header==NULL
-   mac_header -> UNKNOWN position. It is very likely, that it points to ll
-                header.  PPP makes it, that is wrong, because introduce
-                 assymetry between rx and tx paths.
-   data       -> data
-
-Outgoing, dev->hard_header==NULL
-   mac_header -> data. ll header is still not built!
-   data       -> data
-
-Resume
-  If dev->hard_header==NULL we are unlikely to restore sensible ll header.
-
-
-On transmit:
-------------
-
-dev->hard_header != NULL
-   mac_header -> ll header
-   data       -> ll header
-
-dev->hard_header == NULL (ll header is added by device, we cannot control it)
-   mac_header -> data
-   data       -> data
-
-   We should set nh.raw on output to correct posistion,
-   packet classifier depends on it.
- */
-
-/* List of all packet sockets. */
-static HLIST_HEAD(packet_sklist);
-static DEFINE_RWLOCK(packet_sklist_lock);
-
-static atomic_t packet_socks_nr;
-
-
-/* Private packet socket structures. */
-
-struct packet_mclist
-{
-       struct packet_mclist    *next;
-       int                     ifindex;
-       int                     count;
-       unsigned short          type;
-       unsigned short          alen;
-       unsigned char           addr[MAX_ADDR_LEN];
-};
-/* identical to struct packet_mreq except it has
- * a longer address field.
- */
-struct packet_mreq_max
-{
-       int             mr_ifindex;
-       unsigned short  mr_type;
-       unsigned short  mr_alen;
-       unsigned char   mr_address[MAX_ADDR_LEN];
-};
-
-#ifdef CONFIG_PACKET_MMAP
-static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing);
-#endif
-
-static void packet_flush_mclist(struct sock *sk);
-
-struct packet_sock {
-       /* struct sock has to be the first member of packet_sock */
-       struct sock             sk;
-       struct tpacket_stats    stats;
-#ifdef CONFIG_PACKET_MMAP
-       char *                  *pg_vec;
-       unsigned int            head;
-       unsigned int            frames_per_block;
-       unsigned int            frame_size;
-       unsigned int            frame_max;
-       int                     copy_thresh;
-#endif
-       struct packet_type      prot_hook;
-       spinlock_t              bind_lock;
-       unsigned int            running:1,      /* prot_hook is attached*/
-                               auxdata:1,
-                               origdev:1;
-       int                     ifindex;        /* bound device         */
-       __be16                  num;
-       struct packet_mclist    *mclist;
-#ifdef CONFIG_PACKET_MMAP
-       atomic_t                mapped;
-       unsigned int            pg_vec_order;
-       unsigned int            pg_vec_pages;
-       unsigned int            pg_vec_len;
-#endif
-};
-
-struct packet_skb_cb {
-       unsigned int origlen;
-       union {
-               struct sockaddr_pkt pkt;
-               struct sockaddr_ll ll;
-       } sa;
-};
-
-#define PACKET_SKB_CB(__skb)   ((struct packet_skb_cb *)((__skb)->cb))
-
-#ifdef CONFIG_PACKET_MMAP
-
-static inline struct tpacket_hdr *packet_lookup_frame(struct packet_sock *po, unsigned int position)
-{
-       unsigned int pg_vec_pos, frame_offset;
-
-       pg_vec_pos = position / po->frames_per_block;
-       frame_offset = position % po->frames_per_block;
-
-       return (struct tpacket_hdr *)(po->pg_vec[pg_vec_pos] + (frame_offset * po->frame_size));
-}
-#endif
-
-static inline struct packet_sock *pkt_sk(struct sock *sk)
-{
-       return (struct packet_sock *)sk;
-}
-
-static void packet_sock_destruct(struct sock *sk)
-{
-       BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
-       BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
-
-       if (!sock_flag(sk, SOCK_DEAD)) {
-               printk("Attempt to release alive packet socket: %p\n", sk);
-               return;
-       }
-
-       atomic_dec(&packet_socks_nr);
-#ifdef PACKET_REFCNT_DEBUG
-       printk(KERN_DEBUG "PACKET socket %p is free, %d are alive\n", sk, atomic_read(&packet_socks_nr));
-#endif
-}
-
-
-static const struct proto_ops packet_ops;
-
-static const struct proto_ops packet_ops_spkt;
-
-static int packet_rcv_spkt(struct sk_buff *skb, struct net_device *dev,  struct packet_type *pt, struct net_device *orig_dev)
-{
-       struct sock *sk;
-       struct sockaddr_pkt *spkt;
-
-       /*
-        *      When we registered the protocol we saved the socket in the data
-        *      field for just this event.
-        */
-
-       sk = pt->af_packet_priv;
-
-       /*
-        *      Yank back the headers [hope the device set this
-        *      right or kerboom...]
-        *
-        *      Incoming packets have ll header pulled,
-        *      push it back.
-        *
-        *      For outgoing ones skb->data == skb_mac_header(skb)
-        *      so that this procedure is noop.
-        */
-
-       if (skb->pkt_type == PACKET_LOOPBACK)
-               goto out;
-
-       if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
-               goto oom;
-
-       /* drop any routing info */
-       dst_release(skb->dst);
-       skb->dst = NULL;
-
-       /* drop conntrack reference */
-       nf_reset(skb);
-
-       spkt = &PACKET_SKB_CB(skb)->sa.pkt;
-
-       skb_push(skb, skb->data - skb_mac_header(skb));
-
-       /*
-        *      The SOCK_PACKET socket receives _all_ frames.
-        */
-
-       spkt->spkt_family = dev->type;
-       strlcpy(spkt->spkt_device, dev->name, sizeof(spkt->spkt_device));
-       spkt->spkt_protocol = skb->protocol;
-
-       /*
-        *      Charge the memory to the socket. This is done specifically
-        *      to prevent sockets using all the memory up.
-        */
-
-       if (sock_queue_rcv_skb(sk,skb) == 0)
-               return 0;
-
-out:
-       kfree_skb(skb);
-oom:
-       return 0;
-}
-
-
-/*
- *     Output a raw packet to a device layer. This bypasses all the other
- *     protocol layers and you must therefore supply it with a complete frame
- */
-
-static int packet_sendmsg_spkt(struct kiocb *iocb, struct socket *sock,
-                              struct msghdr *msg, size_t len)
-{
-       struct sock *sk = sock->sk;
-       struct sockaddr_pkt *saddr=(struct sockaddr_pkt *)msg->msg_name;
-       struct sk_buff *skb;
-       struct net_device *dev;
-       __be16 proto=0;
-       int err;
-
-       if (!nx_capable(CAP_NET_RAW, NXC_RAW_SEND))
-               return -EPERM;
-
-       /*
-        *      Get and verify the address.
-        */
-
-       if (saddr)
-       {
-               if (msg->msg_namelen < sizeof(struct sockaddr))
-                       return(-EINVAL);
-               if (msg->msg_namelen==sizeof(struct sockaddr_pkt))
-                       proto=saddr->spkt_protocol;
-       }
-       else
-               return(-ENOTCONN);      /* SOCK_PACKET must be sent giving an address */
-
-       /*
-        *      Find the device first to size check it
-        */
-
-       saddr->spkt_device[13] = 0;
-       dev = dev_get_by_name(saddr->spkt_device);
-       err = -ENODEV;
-       if (dev == NULL)
-               goto out_unlock;
-
-       err = -ENETDOWN;
-       if (!(dev->flags & IFF_UP))
-               goto out_unlock;
-
-       /*
-        *      You may not queue a frame bigger than the mtu. This is the lowest level
-        *      raw protocol and you must do your own fragmentation at this level.
-        */
-
-       err = -EMSGSIZE;
-       if (len > dev->mtu + dev->hard_header_len)
-               goto out_unlock;
-
-       err = -ENOBUFS;
-       skb = sock_wmalloc(sk, len + LL_RESERVED_SPACE(dev), 0, GFP_KERNEL);
-
-       /*
-        *      If the write buffer is full, then tough. At this level the user gets to
-        *      deal with the problem - do your own algorithmic backoffs. That's far
-        *      more flexible.
-        */
-
-       if (skb == NULL)
-               goto out_unlock;
-
-       /*
-        *      Fill it in
-        */
-
-       /* FIXME: Save some space for broken drivers that write a
-        * hard header at transmission time by themselves. PPP is the
-        * notable one here. This should really be fixed at the driver level.
-        */
-       skb_reserve(skb, LL_RESERVED_SPACE(dev));
-       skb_reset_network_header(skb);
-
-       /* Try to align data part correctly */
-       if (dev->hard_header) {
-               skb->data -= dev->hard_header_len;
-               skb->tail -= dev->hard_header_len;
-               if (len < dev->hard_header_len)
-                       skb_reset_network_header(skb);
-       }
-
-       /* Returns -EFAULT on error */
-       err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
-       skb->protocol = proto;
-       skb->dev = dev;
-       skb->priority = sk->sk_priority;
-       if (err)
-               goto out_free;
-
-       /*
-        *      Now send it
-        */
-
-       dev_queue_xmit(skb);
-       dev_put(dev);
-       return(len);
-
-out_free:
-       kfree_skb(skb);
-out_unlock:
-       if (dev)
-               dev_put(dev);
-       return err;
-}
-
-static inline unsigned int run_filter(struct sk_buff *skb, struct sock *sk,
-                                     unsigned int res)
-{
-       struct sk_filter *filter;
-       int tag = skb->skb_tag;
-
-       if (sk->sk_nx_info && !(tag == 1 || sk->sk_nid == tag))
-               return 0;
-
-       rcu_read_lock_bh();
-       filter = rcu_dereference(sk->sk_filter);
-       if (filter != NULL)
-               res = sk_run_filter(skb, filter->insns, filter->len);
-       rcu_read_unlock_bh();
-
-       return res;
-}
-
-/*
-   This function makes lazy skb cloning in hope that most of packets
-   are discarded by BPF.
-
-   Note tricky part: we DO mangle shared skb! skb->data, skb->len
-   and skb->cb are mangled. It works because (and until) packets
-   falling here are owned by current CPU. Output packets are cloned
-   by dev_queue_xmit_nit(), input packets are processed by net_bh
-   sequencially, so that if we return skb to original state on exit,
-   we will not harm anyone.
- */
-
-static int packet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
-{
-       struct sock *sk;
-       struct sockaddr_ll *sll;
-       struct packet_sock *po;
-       u8 * skb_head = skb->data;
-       int skb_len = skb->len;
-       unsigned int snaplen, res;
-
-       if (skb->pkt_type == PACKET_LOOPBACK)
-               goto drop;
-
-       sk = pt->af_packet_priv;
-       po = pkt_sk(sk);
-
-       skb->dev = dev;
-
-       if (dev->hard_header) {
-               /* The device has an explicit notion of ll header,
-                  exported to higher levels.
-
-                  Otherwise, the device hides datails of it frame
-                  structure, so that corresponding packet head
-                  never delivered to user.
-                */
-               if (sk->sk_type != SOCK_DGRAM)
-                       skb_push(skb, skb->data - skb_mac_header(skb));
-               else if (skb->pkt_type == PACKET_OUTGOING) {
-                       /* Special case: outgoing packets have ll header at head */
-                       skb_pull(skb, skb_network_offset(skb));
-               }
-       }
-
-       snaplen = skb->len;
-
-       res = run_filter(skb, sk, snaplen);
-       if (!res)
-               goto drop_n_restore;
-       if (snaplen > res)
-               snaplen = res;
-
-       if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
-           (unsigned)sk->sk_rcvbuf)
-               goto drop_n_acct;
-
-       if (skb_shared(skb)) {
-               struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);
-               if (nskb == NULL)
-                       goto drop_n_acct;
-
-               if (skb_head != skb->data) {
-                       skb->data = skb_head;
-                       skb->len = skb_len;
-               }
-               kfree_skb(skb);
-               skb = nskb;
-       }
-
-       BUILD_BUG_ON(sizeof(*PACKET_SKB_CB(skb)) + MAX_ADDR_LEN - 8 >
-                    sizeof(skb->cb));
-
-       sll = &PACKET_SKB_CB(skb)->sa.ll;
-       sll->sll_family = AF_PACKET;
-       sll->sll_hatype = dev->type;
-       sll->sll_protocol = skb->protocol;
-       sll->sll_pkttype = skb->pkt_type;
-       if (unlikely(po->origdev) && skb->pkt_type == PACKET_HOST)
-               sll->sll_ifindex = orig_dev->ifindex;
-       else
-               sll->sll_ifindex = dev->ifindex;
-       sll->sll_halen = 0;
-
-       if (dev->hard_header_parse)
-               sll->sll_halen = dev->hard_header_parse(skb, sll->sll_addr);
-
-       PACKET_SKB_CB(skb)->origlen = skb->len;
-
-       if (pskb_trim(skb, snaplen))
-               goto drop_n_acct;
-
-       skb_set_owner_r(skb, sk);
-       skb->dev = NULL;
-       dst_release(skb->dst);
-       skb->dst = NULL;
-
-       /* drop conntrack reference */
-       nf_reset(skb);
-
-       spin_lock(&sk->sk_receive_queue.lock);
-       po->stats.tp_packets++;
-       __skb_queue_tail(&sk->sk_receive_queue, skb);
-       spin_unlock(&sk->sk_receive_queue.lock);
-       sk->sk_data_ready(sk, skb->len);
-       return 0;
-
-drop_n_acct:
-       spin_lock(&sk->sk_receive_queue.lock);
-       po->stats.tp_drops++;
-       spin_unlock(&sk->sk_receive_queue.lock);
-
-drop_n_restore:
-       if (skb_head != skb->data && skb_shared(skb)) {
-               skb->data = skb_head;
-               skb->len = skb_len;
-       }
-drop:
-       kfree_skb(skb);
-       return 0;
-}
-
-#ifdef CONFIG_PACKET_MMAP
-static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
-{
-       struct sock *sk;
-       struct packet_sock *po;
-       struct sockaddr_ll *sll;
-       struct tpacket_hdr *h;
-       u8 * skb_head = skb->data;
-       int skb_len = skb->len;
-       unsigned int snaplen, res;
-       unsigned long status = TP_STATUS_LOSING|TP_STATUS_USER;
-       unsigned short macoff, netoff;
-       struct sk_buff *copy_skb = NULL;
-       struct timeval tv;
-
-       if (skb->pkt_type == PACKET_LOOPBACK)
-               goto drop;
-
-       sk = pt->af_packet_priv;
-       po = pkt_sk(sk);
-
-       if (dev->hard_header) {
-               if (sk->sk_type != SOCK_DGRAM)
-                       skb_push(skb, skb->data - skb_mac_header(skb));
-               else if (skb->pkt_type == PACKET_OUTGOING) {
-                       /* Special case: outgoing packets have ll header at head */
-                       skb_pull(skb, skb_network_offset(skb));
-               }
-       }
-
-       if (skb->ip_summed == CHECKSUM_PARTIAL)
-               status |= TP_STATUS_CSUMNOTREADY;
-
-       snaplen = skb->len;
-
-       res = run_filter(skb, sk, snaplen);
-       if (!res)
-               goto drop_n_restore;
-       if (snaplen > res)
-               snaplen = res;
-
-       if (sk->sk_type == SOCK_DGRAM) {
-               macoff = netoff = TPACKET_ALIGN(TPACKET_HDRLEN) + 16;
-       } else {
-               unsigned maclen = skb_network_offset(skb);
-               netoff = TPACKET_ALIGN(TPACKET_HDRLEN + (maclen < 16 ? 16 : maclen));
-               macoff = netoff - maclen;
-       }
-
-       if (macoff + snaplen > po->frame_size) {
-               if (po->copy_thresh &&
-                   atomic_read(&sk->sk_rmem_alloc) + skb->truesize <
-                   (unsigned)sk->sk_rcvbuf) {
-                       if (skb_shared(skb)) {
-                               copy_skb = skb_clone(skb, GFP_ATOMIC);
-                       } else {
-                               copy_skb = skb_get(skb);
-                               skb_head = skb->data;
-                       }
-                       if (copy_skb)
-                               skb_set_owner_r(copy_skb, sk);
-               }
-               snaplen = po->frame_size - macoff;
-               if ((int)snaplen < 0)
-                       snaplen = 0;
-       }
-
-       spin_lock(&sk->sk_receive_queue.lock);
-       h = packet_lookup_frame(po, po->head);
-
-       if (h->tp_status)
-               goto ring_is_full;
-       po->head = po->head != po->frame_max ? po->head+1 : 0;
-       po->stats.tp_packets++;
-       if (copy_skb) {
-               status |= TP_STATUS_COPY;
-               __skb_queue_tail(&sk->sk_receive_queue, copy_skb);
-       }
-       if (!po->stats.tp_drops)
-               status &= ~TP_STATUS_LOSING;
-       spin_unlock(&sk->sk_receive_queue.lock);
-
-       skb_copy_bits(skb, 0, (u8*)h + macoff, snaplen);
-
-       h->tp_len = skb->len;
-       h->tp_snaplen = snaplen;
-       h->tp_mac = macoff;
-       h->tp_net = netoff;
-       if (skb->tstamp.tv64 == 0) {
-               __net_timestamp(skb);
-               sock_enable_timestamp(sk);
-       }
-       tv = ktime_to_timeval(skb->tstamp);
-       h->tp_sec = tv.tv_sec;
-       h->tp_usec = tv.tv_usec;
-
-       sll = (struct sockaddr_ll*)((u8*)h + TPACKET_ALIGN(sizeof(*h)));
-       sll->sll_halen = 0;
-       if (dev->hard_header_parse)
-               sll->sll_halen = dev->hard_header_parse(skb, sll->sll_addr);
-       sll->sll_family = AF_PACKET;
-       sll->sll_hatype = dev->type;
-       sll->sll_protocol = skb->protocol;
-       sll->sll_pkttype = skb->pkt_type;
-       if (unlikely(po->origdev) && skb->pkt_type == PACKET_HOST)
-               sll->sll_ifindex = orig_dev->ifindex;
-       else
-               sll->sll_ifindex = dev->ifindex;
-
-       h->tp_status = status;
-       smp_mb();
-
-       {
-               struct page *p_start, *p_end;
-               u8 *h_end = (u8 *)h + macoff + snaplen - 1;
-
-               p_start = virt_to_page(h);
-               p_end = virt_to_page(h_end);
-               while (p_start <= p_end) {
-                       flush_dcache_page(p_start);
-                       p_start++;
-               }
-       }
-
-       sk->sk_data_ready(sk, 0);
-
-drop_n_restore:
-       if (skb_head != skb->data && skb_shared(skb)) {
-               skb->data = skb_head;
-               skb->len = skb_len;
-       }
-drop:
-       kfree_skb(skb);
-       return 0;
-
-ring_is_full:
-       po->stats.tp_drops++;
-       spin_unlock(&sk->sk_receive_queue.lock);
-
-       sk->sk_data_ready(sk, 0);
-       if (copy_skb)
-               kfree_skb(copy_skb);
-       goto drop_n_restore;
-}
-
-#endif
-
-
-static int packet_sendmsg(struct kiocb *iocb, struct socket *sock,
-                         struct msghdr *msg, size_t len)
-{
-       struct sock *sk = sock->sk;
-       struct sockaddr_ll *saddr=(struct sockaddr_ll *)msg->msg_name;
-       struct sk_buff *skb;
-       struct net_device *dev;
-       __be16 proto;
-       unsigned char *addr;
-       int ifindex, err, reserve = 0;
-
-       if (!nx_capable(CAP_NET_RAW, NXC_RAW_SEND))
-               return -EPERM;
-
-       /*
-        *      Get and verify the address.
-        */
-
-       if (saddr == NULL) {
-               struct packet_sock *po = pkt_sk(sk);
-
-               ifindex = po->ifindex;
-               proto   = po->num;
-               addr    = NULL;
-       } else {
-               err = -EINVAL;
-               if (msg->msg_namelen < sizeof(struct sockaddr_ll))
-                       goto out;
-               if (msg->msg_namelen < (saddr->sll_halen + offsetof(struct sockaddr_ll, sll_addr)))
-                       goto out;
-               ifindex = saddr->sll_ifindex;
-               proto   = saddr->sll_protocol;
-               addr    = saddr->sll_addr;
-       }
-
-
-       dev = dev_get_by_index(ifindex);
-       err = -ENXIO;
-       if (dev == NULL)
-               goto out_unlock;
-       if (sock->type == SOCK_RAW)
-               reserve = dev->hard_header_len;
-
-       err = -ENETDOWN;
-       if (!(dev->flags & IFF_UP))
-               goto out_unlock;
-
-       err = -EMSGSIZE;
-       if (len > dev->mtu+reserve)
-               goto out_unlock;
-
-       skb = sock_alloc_send_skb(sk, len + LL_RESERVED_SPACE(dev),
-                               msg->msg_flags & MSG_DONTWAIT, &err);
-       if (skb==NULL)
-               goto out_unlock;
-
-       skb_reserve(skb, LL_RESERVED_SPACE(dev));
-       skb_reset_network_header(skb);
-
-       if (dev->hard_header) {
-               int res;
-               err = -EINVAL;
-               res = dev->hard_header(skb, dev, ntohs(proto), addr, NULL, len);
-               if (sock->type != SOCK_DGRAM) {
-                       skb_reset_tail_pointer(skb);
-                       skb->len = 0;
-               } else if (res < 0)
-                       goto out_free;
-       }
-
-       /* Returns -EFAULT on error */
-       err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
-       if (err)
-               goto out_free;
-
-       skb->protocol = proto;
-       skb->dev = dev;
-       skb->priority = sk->sk_priority;
-
-       /*
-        *      Now send it
-        */
-
-       err = dev_queue_xmit(skb);
-       if (err > 0 && (err = net_xmit_errno(err)) != 0)
-               goto out_unlock;
-
-       dev_put(dev);
-
-       return(len);
-
-out_free:
-       kfree_skb(skb);
-out_unlock:
-       if (dev)
-               dev_put(dev);
-out:
-       return err;
-}
-
-/*
- *     Close a PACKET socket. This is fairly simple. We immediately go
- *     to 'closed' state and remove our protocol entry in the device list.
- */
-
-static int packet_release(struct socket *sock)
-{
-       struct sock *sk = sock->sk;
-       struct packet_sock *po;
-
-       if (!sk)
-               return 0;
-
-       po = pkt_sk(sk);
-
-       write_lock_bh(&packet_sklist_lock);
-       sk_del_node_init(sk);
-       write_unlock_bh(&packet_sklist_lock);
-
-       /*
-        *      Unhook packet receive handler.
-        */
-
-       if (po->running) {
-               /*
-                *      Remove the protocol hook
-                */
-               dev_remove_pack(&po->prot_hook);
-               po->running = 0;
-               po->num = 0;
-               __sock_put(sk);
-       }
-
-       packet_flush_mclist(sk);
-
-#ifdef CONFIG_PACKET_MMAP
-       if (po->pg_vec) {
-               struct tpacket_req req;
-               memset(&req, 0, sizeof(req));
-               packet_set_ring(sk, &req, 1);
-       }
-#endif
-
-       /*
-        *      Now the socket is dead. No more input will appear.
-        */
-
-       sock_orphan(sk);
-       sock->sk = NULL;
-
-       /* Purge queues */
-
-       skb_queue_purge(&sk->sk_receive_queue);
-
-       sock_put(sk);
-       return 0;
-}
-
-/*
- *     Attach a packet hook.
- */
-
-static int packet_do_bind(struct sock *sk, struct net_device *dev, __be16 protocol)
-{
-       struct packet_sock *po = pkt_sk(sk);
-       /*
-        *      Detach an existing hook if present.
-        */
-
-       lock_sock(sk);
-
-       spin_lock(&po->bind_lock);
-       if (po->running) {
-               __sock_put(sk);
-               po->running = 0;
-               po->num = 0;
-               spin_unlock(&po->bind_lock);
-               dev_remove_pack(&po->prot_hook);
-               spin_lock(&po->bind_lock);
-       }
-
-       po->num = protocol;
-       po->prot_hook.type = protocol;
-       po->prot_hook.dev = dev;
-
-       po->ifindex = dev ? dev->ifindex : 0;
-
-       if (protocol == 0)
-               goto out_unlock;
-
-       if (dev) {
-               if (dev->flags&IFF_UP) {
-                       dev_add_pack(&po->prot_hook);
-                       sock_hold(sk);
-                       po->running = 1;
-               } else {
-                       sk->sk_err = ENETDOWN;
-                       if (!sock_flag(sk, SOCK_DEAD))
-                               sk->sk_error_report(sk);
-               }
-       } else {
-               dev_add_pack(&po->prot_hook);
-               sock_hold(sk);
-               po->running = 1;
-       }
-
-out_unlock:
-       spin_unlock(&po->bind_lock);
-       release_sock(sk);
-       return 0;
-}
-
-/*
- *     Bind a packet socket to a device
- */
-
-static int packet_bind_spkt(struct socket *sock, struct sockaddr *uaddr, int addr_len)
-{
-       struct sock *sk=sock->sk;
-       char name[15];
-       struct net_device *dev;
-       int err = -ENODEV;
-
-       /*
-        *      Check legality
-        */
-
-       if (addr_len != sizeof(struct sockaddr))
-               return -EINVAL;
-       strlcpy(name,uaddr->sa_data,sizeof(name));
-
-       dev = dev_get_by_name(name);
-       if (dev) {
-               err = packet_do_bind(sk, dev, pkt_sk(sk)->num);
-               dev_put(dev);
-       }
-       return err;
-}
-
-static int packet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
-{
-       struct sockaddr_ll *sll = (struct sockaddr_ll*)uaddr;
-       struct sock *sk=sock->sk;
-       struct net_device *dev = NULL;
-       int err;
-
-
-       /*
-        *      Check legality
-        */
-
-       if (addr_len < sizeof(struct sockaddr_ll))
-               return -EINVAL;
-       if (sll->sll_family != AF_PACKET)
-               return -EINVAL;
-
-       if (sll->sll_ifindex) {
-               err = -ENODEV;
-               dev = dev_get_by_index(sll->sll_ifindex);
-               if (dev == NULL)
-                       goto out;
-       }
-       err = packet_do_bind(sk, dev, sll->sll_protocol ? : pkt_sk(sk)->num);
-       if (dev)
-               dev_put(dev);
-
-out:
-       return err;
-}
-
-static struct proto packet_proto = {
-       .name     = "PACKET",
-       .owner    = THIS_MODULE,
-       .obj_size = sizeof(struct packet_sock),
-};
-
-/*
- *     Create a packet of type SOCK_PACKET.
- */
-
-static int packet_create(struct socket *sock, int protocol)
-{
-       struct sock *sk;
-       struct packet_sock *po;
-       __be16 proto = (__force __be16)protocol; /* weird, but documented */
-       int err;
-
-       if (!nx_capable(CAP_NET_RAW, NXC_RAW_SOCKET))
-               return -EPERM;
-       if (sock->type != SOCK_DGRAM && sock->type != SOCK_RAW &&
-           sock->type != SOCK_PACKET)
-               return -ESOCKTNOSUPPORT;
-
-       sock->state = SS_UNCONNECTED;
-
-       err = -ENOBUFS;
-       sk = sk_alloc(PF_PACKET, GFP_KERNEL, &packet_proto, 1);
-       if (sk == NULL)
-               goto out;
-
-       sock->ops = &packet_ops;
-       if (sock->type == SOCK_PACKET)
-               sock->ops = &packet_ops_spkt;
-
-       sock_init_data(sock, sk);
-
-       po = pkt_sk(sk);
-       sk->sk_family = PF_PACKET;
-       po->num = proto;
-
-       sk->sk_destruct = packet_sock_destruct;
-       atomic_inc(&packet_socks_nr);
-
-       /*
-        *      Attach a protocol block
-        */
-
-       spin_lock_init(&po->bind_lock);
-       po->prot_hook.func = packet_rcv;
-
-       if (sock->type == SOCK_PACKET)
-               po->prot_hook.func = packet_rcv_spkt;
-
-       po->prot_hook.af_packet_priv = sk;
-
-       if (proto) {
-               po->prot_hook.type = proto;
-               dev_add_pack(&po->prot_hook);
-               sock_hold(sk);
-               po->running = 1;
-       }
-
-       write_lock_bh(&packet_sklist_lock);
-       sk_add_node(sk, &packet_sklist);
-       write_unlock_bh(&packet_sklist_lock);
-       return(0);
-out:
-       return err;
-}
-
-/*
- *     Pull a packet from our receive queue and hand it to the user.
- *     If necessary we block.
- */
-
-static int packet_recvmsg(struct kiocb *iocb, struct socket *sock,
-                         struct msghdr *msg, size_t len, int flags)
-{
-       struct sock *sk = sock->sk;
-       struct sk_buff *skb;
-       int copied, err;
-       struct sockaddr_ll *sll;
-
-       err = -EINVAL;
-       if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT))
-               goto out;
-
-#if 0
-       /* What error should we return now? EUNATTACH? */
-       if (pkt_sk(sk)->ifindex < 0)
-               return -ENODEV;
-#endif
-
-       /*
-        *      Call the generic datagram receiver. This handles all sorts
-        *      of horrible races and re-entrancy so we can forget about it
-        *      in the protocol layers.
-        *
-        *      Now it will return ENETDOWN, if device have just gone down,
-        *      but then it will block.
-        */
-
-       skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
-
-       /*
-        *      An error occurred so return it. Because skb_recv_datagram()
-        *      handles the blocking we don't see and worry about blocking
-        *      retries.
-        */
-
-       if (skb == NULL)
-               goto out;
-
-       /*
-        *      If the address length field is there to be filled in, we fill
-        *      it in now.
-        */
-
-       sll = &PACKET_SKB_CB(skb)->sa.ll;
-       if (sock->type == SOCK_PACKET)
-               msg->msg_namelen = sizeof(struct sockaddr_pkt);
-       else
-               msg->msg_namelen = sll->sll_halen + offsetof(struct sockaddr_ll, sll_addr);
-
-       /*
-        *      You lose any data beyond the buffer you gave. If it worries a
-        *      user program they can ask the device for its MTU anyway.
-        */
-
-       copied = skb->len;
-       if (copied > len)
-       {
-               copied=len;
-               msg->msg_flags|=MSG_TRUNC;
-       }
-
-       err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
-       if (err)
-               goto out_free;
-
-       sock_recv_timestamp(msg, sk, skb);
-
-       if (msg->msg_name)
-               memcpy(msg->msg_name, &PACKET_SKB_CB(skb)->sa,
-                      msg->msg_namelen);
-
-       if (pkt_sk(sk)->auxdata) {
-               struct tpacket_auxdata aux;
-
-               aux.tp_status = TP_STATUS_USER;
-               if (skb->ip_summed == CHECKSUM_PARTIAL)
-                       aux.tp_status |= TP_STATUS_CSUMNOTREADY;
-               aux.tp_len = PACKET_SKB_CB(skb)->origlen;
-               aux.tp_snaplen = skb->len;
-               aux.tp_mac = 0;
-               aux.tp_net = skb_network_offset(skb);
-
-               put_cmsg(msg, SOL_PACKET, PACKET_AUXDATA, sizeof(aux), &aux);
-       }
-
-       /*
-        *      Free or return the buffer as appropriate. Again this
-        *      hides all the races and re-entrancy issues from us.
-        */
-       err = (flags&MSG_TRUNC) ? skb->len : copied;
-
-out_free:
-       skb_free_datagram(sk, skb);
-out:
-       return err;
-}
-
-static int packet_getname_spkt(struct socket *sock, struct sockaddr *uaddr,
-                              int *uaddr_len, int peer)
-{
-       struct net_device *dev;
-       struct sock *sk = sock->sk;
-
-       if (peer)
-               return -EOPNOTSUPP;
-
-       uaddr->sa_family = AF_PACKET;
-       dev = dev_get_by_index(pkt_sk(sk)->ifindex);
-       if (dev) {
-               strlcpy(uaddr->sa_data, dev->name, 15);
-               dev_put(dev);
-       } else
-               memset(uaddr->sa_data, 0, 14);
-       *uaddr_len = sizeof(*uaddr);
-
-       return 0;
-}
-
-static int packet_getname(struct socket *sock, struct sockaddr *uaddr,
-                         int *uaddr_len, int peer)
-{
-       struct net_device *dev;
-       struct sock *sk = sock->sk;
-       struct packet_sock *po = pkt_sk(sk);
-       struct sockaddr_ll *sll = (struct sockaddr_ll*)uaddr;
-
-       if (peer)
-               return -EOPNOTSUPP;
-
-       sll->sll_family = AF_PACKET;
-       sll->sll_ifindex = po->ifindex;
-       sll->sll_protocol = po->num;
-       dev = dev_get_by_index(po->ifindex);
-       if (dev) {
-               sll->sll_hatype = dev->type;
-               sll->sll_halen = dev->addr_len;
-               memcpy(sll->sll_addr, dev->dev_addr, dev->addr_len);
-               dev_put(dev);
-       } else {
-               sll->sll_hatype = 0;    /* Bad: we have no ARPHRD_UNSPEC */
-               sll->sll_halen = 0;
-       }
-       *uaddr_len = offsetof(struct sockaddr_ll, sll_addr) + sll->sll_halen;
-
-       return 0;
-}
-
-static void packet_dev_mc(struct net_device *dev, struct packet_mclist *i, int what)
-{
-       switch (i->type) {
-       case PACKET_MR_MULTICAST:
-               if (what > 0)
-                       dev_mc_add(dev, i->addr, i->alen, 0);
-               else
-                       dev_mc_delete(dev, i->addr, i->alen, 0);
-               break;
-       case PACKET_MR_PROMISC:
-               dev_set_promiscuity(dev, what);
-               break;
-       case PACKET_MR_ALLMULTI:
-               dev_set_allmulti(dev, what);
-               break;
-       default:;
-       }
-}
-
-static void packet_dev_mclist(struct net_device *dev, struct packet_mclist *i, int what)
-{
-       for ( ; i; i=i->next) {
-               if (i->ifindex == dev->ifindex)
-                       packet_dev_mc(dev, i, what);
-       }
-}
-
-static int packet_mc_add(struct sock *sk, struct packet_mreq_max *mreq)
-{
-       struct packet_sock *po = pkt_sk(sk);
-       struct packet_mclist *ml, *i;
-       struct net_device *dev;
-       int err;
-
-       rtnl_lock();
-
-       err = -ENODEV;
-       dev = __dev_get_by_index(mreq->mr_ifindex);
-       if (!dev)
-               goto done;
-
-       err = -EINVAL;
-       if (mreq->mr_alen > dev->addr_len)
-               goto done;
-
-       err = -ENOBUFS;
-       i = kmalloc(sizeof(*i), GFP_KERNEL);
-       if (i == NULL)
-               goto done;
-
-       err = 0;
-       for (ml = po->mclist; ml; ml = ml->next) {
-               if (ml->ifindex == mreq->mr_ifindex &&
-                   ml->type == mreq->mr_type &&
-                   ml->alen == mreq->mr_alen &&
-                   memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
-                       ml->count++;
-                       /* Free the new element ... */
-                       kfree(i);
-                       goto done;
-               }
-       }
-
-       i->type = mreq->mr_type;
-       i->ifindex = mreq->mr_ifindex;
-       i->alen = mreq->mr_alen;
-       memcpy(i->addr, mreq->mr_address, i->alen);
-       i->count = 1;
-       i->next = po->mclist;
-       po->mclist = i;
-       packet_dev_mc(dev, i, +1);
-
-done:
-       rtnl_unlock();
-       return err;
-}
-
-static int packet_mc_drop(struct sock *sk, struct packet_mreq_max *mreq)
-{
-       struct packet_mclist *ml, **mlp;
-
-       rtnl_lock();
-
-       for (mlp = &pkt_sk(sk)->mclist; (ml = *mlp) != NULL; mlp = &ml->next) {
-               if (ml->ifindex == mreq->mr_ifindex &&
-                   ml->type == mreq->mr_type &&
-                   ml->alen == mreq->mr_alen &&
-                   memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
-                       if (--ml->count == 0) {
-                               struct net_device *dev;
-                               *mlp = ml->next;
-                               dev = dev_get_by_index(ml->ifindex);
-                               if (dev) {
-                                       packet_dev_mc(dev, ml, -1);
-                                       dev_put(dev);
-                               }
-                               kfree(ml);
-                       }
-                       rtnl_unlock();
-                       return 0;
-               }
-       }
-       rtnl_unlock();
-       return -EADDRNOTAVAIL;
-}
-
-static void packet_flush_mclist(struct sock *sk)
-{
-       struct packet_sock *po = pkt_sk(sk);
-       struct packet_mclist *ml;
-
-       if (!po->mclist)
-               return;
-
-       rtnl_lock();
-       while ((ml = po->mclist) != NULL) {
-               struct net_device *dev;
-
-               po->mclist = ml->next;
-               if ((dev = dev_get_by_index(ml->ifindex)) != NULL) {
-                       packet_dev_mc(dev, ml, -1);
-                       dev_put(dev);
-               }
-               kfree(ml);
-       }
-       rtnl_unlock();
-}
-
-static int
-packet_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
-{
-       struct sock *sk = sock->sk;
-       struct packet_sock *po = pkt_sk(sk);
-       int ret;
-
-       if (level != SOL_PACKET)
-               return -ENOPROTOOPT;
-
-       switch(optname) {
-       case PACKET_ADD_MEMBERSHIP:
-       case PACKET_DROP_MEMBERSHIP:
-       {
-               struct packet_mreq_max mreq;
-               int len = optlen;
-               memset(&mreq, 0, sizeof(mreq));
-               if (len < sizeof(struct packet_mreq))
-                       return -EINVAL;
-               if (len > sizeof(mreq))
-                       len = sizeof(mreq);
-               if (copy_from_user(&mreq,optval,len))
-                       return -EFAULT;
-               if (len < (mreq.mr_alen + offsetof(struct packet_mreq, mr_address)))
-                       return -EINVAL;
-               if (optname == PACKET_ADD_MEMBERSHIP)
-                       ret = packet_mc_add(sk, &mreq);
-               else
-                       ret = packet_mc_drop(sk, &mreq);
-               return ret;
-       }
-
-#ifdef CONFIG_PACKET_MMAP
-       case PACKET_RX_RING:
-       {
-               struct tpacket_req req;
-
-               if (optlen<sizeof(req))
-                       return -EINVAL;
-               if (copy_from_user(&req,optval,sizeof(req)))
-                       return -EFAULT;
-               return packet_set_ring(sk, &req, 0);
-       }
-       case PACKET_COPY_THRESH:
-       {
-               int val;
-
-               if (optlen!=sizeof(val))
-                       return -EINVAL;
-               if (copy_from_user(&val,optval,sizeof(val)))
-                       return -EFAULT;
-
-               pkt_sk(sk)->copy_thresh = val;
-               return 0;
-       }
-#endif
-       case PACKET_AUXDATA:
-       {
-               int val;
-
-               if (optlen < sizeof(val))
-                       return -EINVAL;
-               if (copy_from_user(&val, optval, sizeof(val)))
-                       return -EFAULT;
-
-               po->auxdata = !!val;
-               return 0;
-       }
-       case PACKET_ORIGDEV:
-       {
-               int val;
-
-               if (optlen < sizeof(val))
-                       return -EINVAL;
-               if (copy_from_user(&val, optval, sizeof(val)))
-                       return -EFAULT;
-
-               po->origdev = !!val;
-               return 0;
-       }
-       default:
-               return -ENOPROTOOPT;
-       }
-}
-
-static int packet_getsockopt(struct socket *sock, int level, int optname,
-                            char __user *optval, int __user *optlen)
-{
-       int len;
-       int val;
-       struct sock *sk = sock->sk;
-       struct packet_sock *po = pkt_sk(sk);
-       void *data;
-       struct tpacket_stats st;
-
-       if (level != SOL_PACKET)
-               return -ENOPROTOOPT;
-
-       if (get_user(len, optlen))
-               return -EFAULT;
-
-       if (len < 0)
-               return -EINVAL;
-
-       switch(optname) {
-       case PACKET_STATISTICS:
-               if (len > sizeof(struct tpacket_stats))
-                       len = sizeof(struct tpacket_stats);
-               spin_lock_bh(&sk->sk_receive_queue.lock);
-               st = po->stats;
-               memset(&po->stats, 0, sizeof(st));
-               spin_unlock_bh(&sk->sk_receive_queue.lock);
-               st.tp_packets += st.tp_drops;
-
-               data = &st;
-               break;
-       case PACKET_AUXDATA:
-               if (len > sizeof(int))
-                       len = sizeof(int);
-               val = po->auxdata;
-
-               data = &val;
-               break;
-       case PACKET_ORIGDEV:
-               if (len > sizeof(int))
-                       len = sizeof(int);
-               val = po->origdev;
-
-               data = &val;
-               break;
-       default:
-               return -ENOPROTOOPT;
-       }
-
-       if (put_user(len, optlen))
-               return -EFAULT;
-       if (copy_to_user(optval, data, len))
-               return -EFAULT;
-       return 0;
-}
-
-
-static int packet_notifier(struct notifier_block *this, unsigned long msg, void *data)
-{
-       struct sock *sk;
-       struct hlist_node *node;
-       struct net_device *dev = data;
-
-       read_lock(&packet_sklist_lock);
-       sk_for_each(sk, node, &packet_sklist) {
-               struct packet_sock *po = pkt_sk(sk);
-
-               switch (msg) {
-               case NETDEV_UNREGISTER:
-                       if (po->mclist)
-                               packet_dev_mclist(dev, po->mclist, -1);
-                       /* fallthrough */
-
-               case NETDEV_DOWN:
-                       if (dev->ifindex == po->ifindex) {
-                               spin_lock(&po->bind_lock);
-                               if (po->running) {
-                                       __dev_remove_pack(&po->prot_hook);
-                                       __sock_put(sk);
-                                       po->running = 0;
-                                       sk->sk_err = ENETDOWN;
-                                       if (!sock_flag(sk, SOCK_DEAD))
-                                               sk->sk_error_report(sk);
-                               }
-                               if (msg == NETDEV_UNREGISTER) {
-                                       po->ifindex = -1;
-                                       po->prot_hook.dev = NULL;
-                               }
-                               spin_unlock(&po->bind_lock);
-                       }
-                       break;
-               case NETDEV_UP:
-                       spin_lock(&po->bind_lock);
-                       if (dev->ifindex == po->ifindex && po->num &&
-                           !po->running) {
-                               dev_add_pack(&po->prot_hook);
-                               sock_hold(sk);
-                               po->running = 1;
-                       }
-                       spin_unlock(&po->bind_lock);
-                       break;
-               }
-       }
-       read_unlock(&packet_sklist_lock);
-       return NOTIFY_DONE;
-}
-
-
-static int packet_ioctl(struct socket *sock, unsigned int cmd,
-                       unsigned long arg)
-{
-       struct sock *sk = sock->sk;
-
-       switch(cmd) {
-               case SIOCOUTQ:
-               {
-                       int amount = atomic_read(&sk->sk_wmem_alloc);
-                       return put_user(amount, (int __user *)arg);
-               }
-               case SIOCINQ:
-               {
-                       struct sk_buff *skb;
-                       int amount = 0;
-
-                       spin_lock_bh(&sk->sk_receive_queue.lock);
-                       skb = skb_peek(&sk->sk_receive_queue);
-                       if (skb)
-                               amount = skb->len;
-                       spin_unlock_bh(&sk->sk_receive_queue.lock);
-                       return put_user(amount, (int __user *)arg);
-               }
-               case SIOCGSTAMP:
-                       return sock_get_timestamp(sk, (struct timeval __user *)arg);
-               case SIOCGSTAMPNS:
-                       return sock_get_timestampns(sk, (struct timespec __user *)arg);
-
-#ifdef CONFIG_INET
-               case SIOCADDRT:
-               case SIOCDELRT:
-               case SIOCDARP:
-               case SIOCGARP:
-               case SIOCSARP:
-               case SIOCGIFADDR:
-               case SIOCSIFADDR:
-               case SIOCGIFBRDADDR:
-               case SIOCSIFBRDADDR:
-               case SIOCGIFNETMASK:
-               case SIOCSIFNETMASK:
-               case SIOCGIFDSTADDR:
-               case SIOCSIFDSTADDR:
-               case SIOCSIFFLAGS:
-                       return inet_dgram_ops.ioctl(sock, cmd, arg);
-#endif
-
-               default:
-                       return -ENOIOCTLCMD;
-       }
-       return 0;
-}
-
-#ifndef CONFIG_PACKET_MMAP
-#define packet_mmap sock_no_mmap
-#define packet_poll datagram_poll
-#else
-
-static unsigned int packet_poll(struct file * file, struct socket *sock,
-                               poll_table *wait)
-{
-       struct sock *sk = sock->sk;
-       struct packet_sock *po = pkt_sk(sk);
-       unsigned int mask = datagram_poll(file, sock, wait);
-
-       spin_lock_bh(&sk->sk_receive_queue.lock);
-       if (po->pg_vec) {
-               unsigned last = po->head ? po->head-1 : po->frame_max;
-               struct tpacket_hdr *h;
-
-               h = packet_lookup_frame(po, last);
-
-               if (h->tp_status)
-                       mask |= POLLIN | POLLRDNORM;
-       }
-       spin_unlock_bh(&sk->sk_receive_queue.lock);
-       return mask;
-}
-
-
-/* Dirty? Well, I still did not learn better way to account
- * for user mmaps.
- */
-
-static void packet_mm_open(struct vm_area_struct *vma)
-{
-       struct file *file = vma->vm_file;
-       struct socket * sock = file->private_data;
-       struct sock *sk = sock->sk;
-
-       if (sk)
-               atomic_inc(&pkt_sk(sk)->mapped);
-}
-
-static void packet_mm_close(struct vm_area_struct *vma)
-{
-       struct file *file = vma->vm_file;
-       struct socket * sock = file->private_data;
-       struct sock *sk = sock->sk;
-
-       if (sk)
-               atomic_dec(&pkt_sk(sk)->mapped);
-}
-
-static struct vm_operations_struct packet_mmap_ops = {
-       .open = packet_mm_open,
-       .close =packet_mm_close,
-};
-
-static inline struct page *pg_vec_endpage(char *one_pg_vec, unsigned int order)
-{
-       return virt_to_page(one_pg_vec + (PAGE_SIZE << order) - 1);
-}
-
-static void free_pg_vec(char **pg_vec, unsigned int order, unsigned int len)
-{
-       int i;
-
-       for (i = 0; i < len; i++) {
-               if (likely(pg_vec[i]))
-                       free_pages((unsigned long) pg_vec[i], order);
-       }
-       kfree(pg_vec);
-}
-
-static inline char *alloc_one_pg_vec_page(unsigned long order)
-{
-       return (char *) __get_free_pages(GFP_KERNEL | __GFP_COMP | __GFP_ZERO,
-                                        order);
-}
-
-static char **alloc_pg_vec(struct tpacket_req *req, int order)
-{
-       unsigned int block_nr = req->tp_block_nr;
-       char **pg_vec;
-       int i;
-
-       pg_vec = kzalloc(block_nr * sizeof(char *), GFP_KERNEL);
-       if (unlikely(!pg_vec))
-               goto out;
-
-       for (i = 0; i < block_nr; i++) {
-               pg_vec[i] = alloc_one_pg_vec_page(order);
-               if (unlikely(!pg_vec[i]))
-                       goto out_free_pgvec;
-       }
-
-out:
-       return pg_vec;
-
-out_free_pgvec:
-       free_pg_vec(pg_vec, order, block_nr);
-       pg_vec = NULL;
-       goto out;
-}
-
-static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing)
-{
-       char **pg_vec = NULL;
-       struct packet_sock *po = pkt_sk(sk);
-       int was_running, order = 0;
-       __be16 num;
-       int err = 0;
-
-       if (req->tp_block_nr) {
-               int i, l;
-
-               /* Sanity tests and some calculations */
-
-               if (unlikely(po->pg_vec))
-                       return -EBUSY;
-
-               if (unlikely((int)req->tp_block_size <= 0))
-                       return -EINVAL;
-               if (unlikely(req->tp_block_size & (PAGE_SIZE - 1)))
-                       return -EINVAL;
-               if (unlikely(req->tp_frame_size < TPACKET_HDRLEN))
-                       return -EINVAL;
-               if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
-                       return -EINVAL;
-
-               po->frames_per_block = req->tp_block_size/req->tp_frame_size;
-               if (unlikely(po->frames_per_block <= 0))
-                       return -EINVAL;
-               if (unlikely((po->frames_per_block * req->tp_block_nr) !=
-                            req->tp_frame_nr))
-                       return -EINVAL;
-
-               err = -ENOMEM;
-               order = get_order(req->tp_block_size);
-               pg_vec = alloc_pg_vec(req, order);
-               if (unlikely(!pg_vec))
-                       goto out;
-
-               l = 0;
-               for (i = 0; i < req->tp_block_nr; i++) {
-                       char *ptr = pg_vec[i];
-                       struct tpacket_hdr *header;
-                       int k;
-
-                       for (k = 0; k < po->frames_per_block; k++) {
-                               header = (struct tpacket_hdr *) ptr;
-                               header->tp_status = TP_STATUS_KERNEL;
-                               ptr += req->tp_frame_size;
-                       }
-               }
-               /* Done */
-       } else {
-               if (unlikely(req->tp_frame_nr))
-                       return -EINVAL;
-       }
-
-       lock_sock(sk);
-
-       /* Detach socket from network */
-       spin_lock(&po->bind_lock);
-       was_running = po->running;
-       num = po->num;
-       if (was_running) {
-               __dev_remove_pack(&po->prot_hook);
-               po->num = 0;
-               po->running = 0;
-               __sock_put(sk);
-       }
-       spin_unlock(&po->bind_lock);
-
-       synchronize_net();
-
-       err = -EBUSY;
-       if (closing || atomic_read(&po->mapped) == 0) {
-               err = 0;
-#define XC(a, b) ({ __typeof__ ((a)) __t; __t = (a); (a) = (b); __t; })
-
-               spin_lock_bh(&sk->sk_receive_queue.lock);
-               pg_vec = XC(po->pg_vec, pg_vec);
-               po->frame_max = (req->tp_frame_nr - 1);
-               po->head = 0;
-               po->frame_size = req->tp_frame_size;
-               spin_unlock_bh(&sk->sk_receive_queue.lock);
-
-               order = XC(po->pg_vec_order, order);
-               req->tp_block_nr = XC(po->pg_vec_len, req->tp_block_nr);
-
-               po->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
-               po->prot_hook.func = po->pg_vec ? tpacket_rcv : packet_rcv;
-               skb_queue_purge(&sk->sk_receive_queue);
-#undef XC
-               if (atomic_read(&po->mapped))
-                       printk(KERN_DEBUG "packet_mmap: vma is busy: %d\n", atomic_read(&po->mapped));
-       }
-
-       spin_lock(&po->bind_lock);
-       if (was_running && !po->running) {
-               sock_hold(sk);
-               po->running = 1;
-               po->num = num;
-               dev_add_pack(&po->prot_hook);
-       }
-       spin_unlock(&po->bind_lock);
-
-       release_sock(sk);
-
-       if (pg_vec)
-               free_pg_vec(pg_vec, order, req->tp_block_nr);
-out:
-       return err;
-}
-
-static int packet_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
-{
-       struct sock *sk = sock->sk;
-       struct packet_sock *po = pkt_sk(sk);
-       unsigned long size;
-       unsigned long start;
-       int err = -EINVAL;
-       int i;
-
-       if (vma->vm_pgoff)
-               return -EINVAL;
-
-       size = vma->vm_end - vma->vm_start;
-
-       lock_sock(sk);
-       if (po->pg_vec == NULL)
-               goto out;
-       if (size != po->pg_vec_len*po->pg_vec_pages*PAGE_SIZE)
-               goto out;
-
-       start = vma->vm_start;
-       for (i = 0; i < po->pg_vec_len; i++) {
-               struct page *page = virt_to_page(po->pg_vec[i]);
-               int pg_num;
-
-               for (pg_num = 0; pg_num < po->pg_vec_pages; pg_num++, page++) {
-                       err = vm_insert_page(vma, start, page);
-                       if (unlikely(err))
-                               goto out;
-                       start += PAGE_SIZE;
-               }
-       }
-       atomic_inc(&po->mapped);
-       vma->vm_ops = &packet_mmap_ops;
-       err = 0;
-
-out:
-       release_sock(sk);
-       return err;
-}
-#endif
-
-
-static const struct proto_ops packet_ops_spkt = {
-       .family =       PF_PACKET,
-       .owner =        THIS_MODULE,
-       .release =      packet_release,
-       .bind =         packet_bind_spkt,
-       .connect =      sock_no_connect,
-       .socketpair =   sock_no_socketpair,
-       .accept =       sock_no_accept,
-       .getname =      packet_getname_spkt,
-       .poll =         datagram_poll,
-       .ioctl =        packet_ioctl,
-       .listen =       sock_no_listen,
-       .shutdown =     sock_no_shutdown,
-       .setsockopt =   sock_no_setsockopt,
-       .getsockopt =   sock_no_getsockopt,
-       .sendmsg =      packet_sendmsg_spkt,
-       .recvmsg =      packet_recvmsg,
-       .mmap =         sock_no_mmap,
-       .sendpage =     sock_no_sendpage,
-};
-
-static const struct proto_ops packet_ops = {
-       .family =       PF_PACKET,
-       .owner =        THIS_MODULE,
-       .release =      packet_release,
-       .bind =         packet_bind,
-       .connect =      sock_no_connect,
-       .socketpair =   sock_no_socketpair,
-       .accept =       sock_no_accept,
-       .getname =      packet_getname,
-       .poll =         packet_poll,
-       .ioctl =        packet_ioctl,
-       .listen =       sock_no_listen,
-       .shutdown =     sock_no_shutdown,
-       .setsockopt =   packet_setsockopt,
-       .getsockopt =   packet_getsockopt,
-       .sendmsg =      packet_sendmsg,
-       .recvmsg =      packet_recvmsg,
-       .mmap =         packet_mmap,
-       .sendpage =     sock_no_sendpage,
-};
-
-static struct net_proto_family packet_family_ops = {
-       .family =       PF_PACKET,
-       .create =       packet_create,
-       .owner  =       THIS_MODULE,
-};
-
-static struct notifier_block packet_netdev_notifier = {
-       .notifier_call =packet_notifier,
-};
-
-#ifdef CONFIG_PROC_FS
-static inline struct sock *packet_seq_idx(loff_t off)
-{
-       struct sock *s;
-       struct hlist_node *node;
-
-       sk_for_each(s, node, &packet_sklist) {
-               if (!off--)
-                       return s;
-       }
-       return NULL;
-}
-
-static void *packet_seq_start(struct seq_file *seq, loff_t *pos)
-{
-       read_lock(&packet_sklist_lock);
-       return *pos ? packet_seq_idx(*pos - 1) : SEQ_START_TOKEN;
-}
-
-static void *packet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
-{
-       ++*pos;
-       return  (v == SEQ_START_TOKEN)
-               ? sk_head(&packet_sklist)
-               : sk_next((struct sock*)v) ;
-}
-
-static void packet_seq_stop(struct seq_file *seq, void *v)
-{
-       read_unlock(&packet_sklist_lock);
-}
-
-static int packet_seq_show(struct seq_file *seq, void *v)
-{
-       if (v == SEQ_START_TOKEN)
-               seq_puts(seq, "sk       RefCnt Type Proto  Iface R Rmem   User   Inode\n");
-       else {
-               struct sock *s = v;
-               const struct packet_sock *po = pkt_sk(s);
-
-               seq_printf(seq,
-                          "%p %-6d %-4d %04x   %-5d %1d %-6u %-6u %-6lu\n",
-                          s,
-                          atomic_read(&s->sk_refcnt),
-                          s->sk_type,
-                          ntohs(po->num),
-                          po->ifindex,
-                          po->running,
-                          atomic_read(&s->sk_rmem_alloc),
-                          sock_i_uid(s),
-                          sock_i_ino(s) );
-       }
-
-       return 0;
-}
-
-static struct seq_operations packet_seq_ops = {
-       .start  = packet_seq_start,
-       .next   = packet_seq_next,
-       .stop   = packet_seq_stop,
-       .show   = packet_seq_show,
-};
-
-static int packet_seq_open(struct inode *inode, struct file *file)
-{
-       return seq_open(file, &packet_seq_ops);
-}
-
-static const struct file_operations packet_seq_fops = {
-       .owner          = THIS_MODULE,
-       .open           = packet_seq_open,
-       .read           = seq_read,
-       .llseek         = seq_lseek,
-       .release        = seq_release,
-};
-
-#endif
-
-static void __exit packet_exit(void)
-{
-       proc_net_remove("packet");
-       unregister_netdevice_notifier(&packet_netdev_notifier);
-       sock_unregister(PF_PACKET);
-       proto_unregister(&packet_proto);
-}
-
-static int __init packet_init(void)
-{
-       int rc = proto_register(&packet_proto, 0);
-
-       if (rc != 0)
-               goto out;
-
-       sock_register(&packet_family_ops);
-       register_netdevice_notifier(&packet_netdev_notifier);
-       proc_net_fops_create("packet", 0, &packet_seq_fops);
-out:
-       return rc;
-}
-
-module_init(packet_init);
-module_exit(packet_exit);
-MODULE_LICENSE("GPL");
-MODULE_ALIAS_NETPROTO(PF_PACKET);
diff -Nurb linux-2.6.22-594/net/socket.c linux-2.6.22-595/net/socket.c
--- linux-2.6.22-594/net/socket.c       2008-03-20 01:27:52.000000000 -0400
+++ linux-2.6.22-595/net/socket.c       2008-03-20 01:28:00.000000000 -0400
@@ -1122,12 +1122,17 @@
        if (type < 0 || type >= SOCK_MAX)
                return -EINVAL;
 
+       /*
+        * Hack no. 2 - Sapan
+        * Clean this up later
+        *
        if (!nx_check(0, VS_ADMIN)) {
                if (family == PF_INET && !current_nx_info_has_v4())
                        return -EAFNOSUPPORT;
                if (family == PF_INET6 && !current_nx_info_has_v6())
                        return -EAFNOSUPPORT;
        }
+       */
 
        /* Compatibility.