uid_t                   owner;
        gid_t                   group;
 
-       struct sk_buff_head     readq;
-
        struct net_device       *dev;
        struct fasync_struct    *fasync;
 
        struct tap_filter       txflt;
-       struct sock             *sk;
        struct socket           socket;
 
 #ifdef TUN_DEBUG
        tfile->tun = tun;
        tun->tfile = tfile;
        dev_hold(tun->dev);
-       sock_hold(tun->sk);
+       sock_hold(tun->socket.sk);
        atomic_inc(&tfile->count);
 
 out:
        netif_tx_unlock_bh(tun->dev);
 
        /* Drop read queue */
-       skb_queue_purge(&tun->readq);
+       skb_queue_purge(&tun->socket.sk->sk_receive_queue);
 
        /* Drop the extra count on the net device */
        dev_put(tun->dev);
 {
        struct tun_struct *tun = netdev_priv(dev);
 
-       sock_put(tun->sk);
+       sock_put(tun->socket.sk);
 }
 
 /* Net device open. */
        if (!check_filter(&tun->txflt, skb))
                goto drop;
 
-       if (skb_queue_len(&tun->readq) >= dev->tx_queue_len) {
+       if (skb_queue_len(&tun->socket.sk->sk_receive_queue) >= dev->tx_queue_len) {
                if (!(tun->flags & TUN_ONE_QUEUE)) {
                        /* Normal queueing mode. */
                        /* Packet scheduler handles dropping of further packets. */
        }
 
        /* Enqueue packet */
-       skb_queue_tail(&tun->readq, skb);
+       skb_queue_tail(&tun->socket.sk->sk_receive_queue, skb);
        dev->trans_start = jiffies;
 
        /* Notify and wake up reader process */
        if (!tun)
                return POLLERR;
 
-       sk = tun->sk;
+       sk = tun->socket.sk;
 
        DBG(KERN_INFO "%s: tun_chr_poll\n", tun->dev->name);
 
        poll_wait(file, &tun->socket.wait, wait);
 
-       if (!skb_queue_empty(&tun->readq))
+       if (!skb_queue_empty(&sk->sk_receive_queue))
                mask |= POLLIN | POLLRDNORM;
 
        if (sock_writeable(sk) ||
                                            size_t prepad, size_t len,
                                            size_t linear, int noblock)
 {
-       struct sock *sk = tun->sk;
+       struct sock *sk = tun->socket.sk;
        struct sk_buff *skb;
        int err;
 
                current->state = TASK_INTERRUPTIBLE;
 
                /* Read frames from the queue */
-               if (!(skb=skb_dequeue(&tun->readq))) {
+               if (!(skb=skb_dequeue(&tun->socket.sk->sk_receive_queue))) {
                        if (file->f_flags & O_NONBLOCK) {
                                ret = -EAGAIN;
                                break;
 {
        struct tun_struct *tun = netdev_priv(dev);
 
-       skb_queue_head_init(&tun->readq);
-
        tun->owner = -1;
        tun->group = -1;
 
                sk->sk_write_space = tun_sock_write_space;
                sk->sk_sndbuf = INT_MAX;
 
-               tun->sk = sk;
                container_of(sk, struct tun_sock, sk)->tun = tun;
 
                tun_net_init(dev);
                break;
 
        case TUNGETSNDBUF:
-               sndbuf = tun->sk->sk_sndbuf;
+               sndbuf = tun->socket.sk->sk_sndbuf;
                if (copy_to_user(argp, &sndbuf, sizeof(sndbuf)))
                        ret = -EFAULT;
                break;
                        break;
                }
 
-               tun->sk->sk_sndbuf = sndbuf;
+               tun->socket.sk->sk_sndbuf = sndbuf;
                break;
 
        default:
 
        tun = tfile->tun;
        if (tun)
-               sock_put(tun->sk);
+               sock_put(tun->socket.sk);
 
        put_net(tfile->net);
        kfree(tfile);