2 * TUN - Universal TUN/TAP device driver.
3 * Copyright (C) 1999-2002 Maxim Krasnyansky <maxk@qualcomm.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * $Id: tun.c,v 1.15 2002/03/01 02:44:24 maxk Exp $
21 * Brian Braunstein <linuxkernel@bristyle.com> 2007/03/23
22 * Fixed hw address handling. Now net_device.dev_addr is kept consistent
23 * with tun.dev_addr when the address is set by this module.
25 * Mike Kershaw <dragorn@kismetwireless.net> 2005/08/14
26 * Add TUNSETLINK ioctl to set the link encapsulation
28 * Mark Smith <markzzzsmith@yahoo.com.au>
29 * Use random_ether_addr() for tap MAC address.
31 * Harald Roelle <harald.roelle@ifi.lmu.de> 2004/04/20
32 * Fixes in packet dropping, queue length setting and queue wakeup.
33 * Increased default tx queue length.
37 * Daniel Podlejski <underley@underley.eu.org>
38 * Modifications for 2.3.99-pre5 kernel.
41 #define DRV_NAME "tun"
42 #define DRV_VERSION "1.6"
43 #define DRV_DESCRIPTION "Universal TUN/TAP device driver"
44 #define DRV_COPYRIGHT "(C) 1999-2004 Max Krasnyansky <maxk@qualcomm.com>"
46 #include <linux/module.h>
47 #include <linux/errno.h>
48 #include <linux/kernel.h>
49 #include <linux/major.h>
50 #include <linux/slab.h>
51 #include <linux/poll.h>
52 #include <linux/fcntl.h>
53 #include <linux/init.h>
54 #include <linux/skbuff.h>
55 #include <linux/netdevice.h>
56 #include <linux/etherdevice.h>
57 #include <linux/miscdevice.h>
58 #include <linux/ethtool.h>
59 #include <linux/rtnetlink.h>
61 #include <linux/if_arp.h>
62 #include <linux/if_ether.h>
63 #include <linux/if_tun.h>
64 #include <linux/crc32.h>
65 #include <net/net_namespace.h>
67 #include <asm/system.h>
68 #include <asm/uaccess.h>
74 /* Network device part of the driver */
76 static LIST_HEAD(tun_dev_list
);
77 static const struct ethtool_ops tun_ethtool_ops
;
79 /* Net device open. */
80 static int tun_net_open(struct net_device
*dev
)
82 netif_start_queue(dev
);
86 /* Net device close. */
87 static int tun_net_close(struct net_device
*dev
)
89 netif_stop_queue(dev
);
93 /* Net device start xmit */
94 static int tun_net_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
96 struct tun_struct
*tun
= netdev_priv(dev
);
98 DBG(KERN_INFO
"%s: tun_net_xmit %d\n", tun
->dev
->name
, skb
->len
);
100 /* Drop packet if interface is not attached */
104 /* Packet dropping */
105 if (skb_queue_len(&tun
->readq
) >= dev
->tx_queue_len
) {
106 if (!(tun
->flags
& TUN_ONE_QUEUE
)) {
107 /* Normal queueing mode. */
108 /* Packet scheduler handles dropping of further packets. */
109 netif_stop_queue(dev
);
111 /* We won't see all dropped packets individually, so overrun
112 * error is more appropriate. */
113 tun
->stats
.tx_fifo_errors
++;
115 /* Single queue mode.
116 * Driver handles dropping of all packets itself. */
122 skb_queue_tail(&tun
->readq
, skb
);
123 dev
->trans_start
= jiffies
;
125 /* Notify and wake up reader process */
126 if (tun
->flags
& TUN_FASYNC
)
127 kill_fasync(&tun
->fasync
, SIGIO
, POLL_IN
);
128 wake_up_interruptible(&tun
->read_wait
);
132 tun
->stats
.tx_dropped
++;
137 /** Add the specified Ethernet address to this multicast filter. */
139 add_multi(u32
* filter
, const u8
* addr
)
141 int bit_nr
= ether_crc(ETH_ALEN
, addr
) >> 26;
142 filter
[bit_nr
>> 5] |= 1 << (bit_nr
& 31);
145 /** Remove the specified Ethernet addres from this multicast filter. */
147 del_multi(u32
* filter
, const u8
* addr
)
149 int bit_nr
= ether_crc(ETH_ALEN
, addr
) >> 26;
150 filter
[bit_nr
>> 5] &= ~(1 << (bit_nr
& 31));
153 /** Update the list of multicast groups to which the network device belongs.
154 * This list is used to filter packets being sent from the character device to
155 * the network device. */
157 tun_net_mclist(struct net_device
*dev
)
159 struct tun_struct
*tun
= netdev_priv(dev
);
160 const struct dev_mc_list
*mclist
;
162 DBG(KERN_DEBUG
"%s: tun_net_mclist: mc_count %d\n",
163 dev
->name
, dev
->mc_count
);
164 memset(tun
->chr_filter
, 0, sizeof tun
->chr_filter
);
165 for (i
= 0, mclist
= dev
->mc_list
; i
< dev
->mc_count
&& mclist
!= NULL
;
166 i
++, mclist
= mclist
->next
) {
167 add_multi(tun
->net_filter
, mclist
->dmi_addr
);
168 DBG(KERN_DEBUG
"%s: tun_net_mclist: %x:%x:%x:%x:%x:%x\n",
170 mclist
->dmi_addr
[0], mclist
->dmi_addr
[1], mclist
->dmi_addr
[2],
171 mclist
->dmi_addr
[3], mclist
->dmi_addr
[4], mclist
->dmi_addr
[5]);
175 static struct net_device_stats
*tun_net_stats(struct net_device
*dev
)
177 struct tun_struct
*tun
= netdev_priv(dev
);
181 /* Initialize net device. */
182 static void tun_net_init(struct net_device
*dev
)
184 struct tun_struct
*tun
= netdev_priv(dev
);
186 switch (tun
->flags
& TUN_TYPE_MASK
) {
188 /* Point-to-Point TUN Device */
189 dev
->hard_header_len
= 0;
193 /* Zero header length */
194 dev
->type
= ARPHRD_NONE
;
195 dev
->flags
= IFF_POINTOPOINT
| IFF_NOARP
| IFF_MULTICAST
;
196 dev
->tx_queue_len
= TUN_READQ_SIZE
; /* We prefer our own queue length */
200 /* Ethernet TAP Device */
201 dev
->set_multicast_list
= tun_net_mclist
;
205 /* random address already created for us by tun_set_iff, use it */
206 memcpy(dev
->dev_addr
, tun
->dev_addr
, min(sizeof(tun
->dev_addr
), sizeof(dev
->dev_addr
)) );
208 dev
->tx_queue_len
= TUN_READQ_SIZE
; /* We prefer our own queue length */
213 /* Character device part */
216 static unsigned int tun_chr_poll(struct file
*file
, poll_table
* wait
)
218 struct tun_struct
*tun
= file
->private_data
;
219 unsigned int mask
= POLLOUT
| POLLWRNORM
;
224 DBG(KERN_INFO
"%s: tun_chr_poll\n", tun
->dev
->name
);
226 poll_wait(file
, &tun
->read_wait
, wait
);
228 if (!skb_queue_empty(&tun
->readq
))
229 mask
|= POLLIN
| POLLRDNORM
;
234 /* Get packet from user space buffer */
235 static __inline__ ssize_t
tun_get_user(struct tun_struct
*tun
, struct iovec
*iv
, size_t count
)
237 struct tun_pi pi
= { 0, __constant_htons(ETH_P_IP
) };
239 size_t len
= count
, align
= 0;
241 if (!(tun
->flags
& TUN_NO_PI
)) {
242 if ((len
-= sizeof(pi
)) > count
)
245 if(memcpy_fromiovec((void *)&pi
, iv
, sizeof(pi
)))
249 if ((tun
->flags
& TUN_TYPE_MASK
) == TUN_TAP_DEV
)
250 align
= NET_IP_ALIGN
;
252 if (!(skb
= alloc_skb(len
+ align
, GFP_KERNEL
))) {
253 tun
->stats
.rx_dropped
++;
258 skb_reserve(skb
, align
);
259 if (memcpy_fromiovec(skb_put(skb
, len
), iv
, len
)) {
260 tun
->stats
.rx_dropped
++;
265 switch (tun
->flags
& TUN_TYPE_MASK
) {
267 skb_reset_mac_header(skb
);
268 skb
->protocol
= pi
.proto
;
272 skb
->protocol
= eth_type_trans(skb
, tun
->dev
);
276 if (tun
->flags
& TUN_NOCHECKSUM
)
277 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
280 tun
->dev
->last_rx
= jiffies
;
282 tun
->stats
.rx_packets
++;
283 tun
->stats
.rx_bytes
+= len
;
288 static inline size_t iov_total(const struct iovec
*iv
, unsigned long count
)
293 for (i
= 0, len
= 0; i
< count
; i
++)
294 len
+= iv
[i
].iov_len
;
299 static ssize_t
tun_chr_aio_write(struct kiocb
*iocb
, const struct iovec
*iv
,
300 unsigned long count
, loff_t pos
)
302 struct tun_struct
*tun
= iocb
->ki_filp
->private_data
;
307 DBG(KERN_INFO
"%s: tun_chr_write %ld\n", tun
->dev
->name
, count
);
309 return tun_get_user(tun
, (struct iovec
*) iv
, iov_total(iv
, count
));
312 /* Put packet to the user space buffer */
313 static __inline__ ssize_t
tun_put_user(struct tun_struct
*tun
,
315 struct iovec
*iv
, int len
)
317 struct tun_pi pi
= { 0, skb
->protocol
};
320 if (!(tun
->flags
& TUN_NO_PI
)) {
321 if ((len
-= sizeof(pi
)) < 0)
324 if (len
< skb
->len
) {
325 /* Packet will be striped */
326 pi
.flags
|= TUN_PKT_STRIP
;
329 if (memcpy_toiovec(iv
, (void *) &pi
, sizeof(pi
)))
334 len
= min_t(int, skb
->len
, len
);
336 skb_copy_datagram_iovec(skb
, 0, iv
, len
);
339 tun
->stats
.tx_packets
++;
340 tun
->stats
.tx_bytes
+= len
;
345 static ssize_t
tun_chr_aio_read(struct kiocb
*iocb
, const struct iovec
*iv
,
346 unsigned long count
, loff_t pos
)
348 struct file
*file
= iocb
->ki_filp
;
349 struct tun_struct
*tun
= file
->private_data
;
350 DECLARE_WAITQUEUE(wait
, current
);
352 ssize_t len
, ret
= 0;
357 DBG(KERN_INFO
"%s: tun_chr_read\n", tun
->dev
->name
);
359 len
= iov_total(iv
, count
);
363 add_wait_queue(&tun
->read_wait
, &wait
);
365 const u8 ones
[ ETH_ALEN
] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
369 current
->state
= TASK_INTERRUPTIBLE
;
371 /* Read frames from the queue */
372 if (!(skb
=skb_dequeue(&tun
->readq
))) {
373 if (file
->f_flags
& O_NONBLOCK
) {
377 if (signal_pending(current
)) {
382 /* Nothing to read, let's sleep */
386 netif_wake_queue(tun
->dev
);
388 /** Decide whether to accept this packet. This code is designed to
389 * behave identically to an Ethernet interface. Accept the packet if
390 * - we are promiscuous.
391 * - the packet is addressed to us.
392 * - the packet is broadcast.
393 * - the packet is multicast and
394 * - we are multicast promiscous.
395 * - we belong to the multicast group.
397 skb_copy_from_linear_data(skb
, addr
, min_t(size_t, sizeof addr
,
399 bit_nr
= ether_crc(sizeof addr
, addr
) >> 26;
400 if ((tun
->if_flags
& IFF_PROMISC
) ||
401 memcmp(addr
, tun
->dev_addr
, sizeof addr
) == 0 ||
402 memcmp(addr
, ones
, sizeof addr
) == 0 ||
403 (((addr
[0] == 1 && addr
[1] == 0 && addr
[2] == 0x5e) ||
404 (addr
[0] == 0x33 && addr
[1] == 0x33)) &&
405 ((tun
->if_flags
& IFF_ALLMULTI
) ||
406 (tun
->chr_filter
[bit_nr
>> 5] & (1 << (bit_nr
& 31)))))) {
407 DBG(KERN_DEBUG
"%s: tun_chr_readv: accepted: %x:%x:%x:%x:%x:%x\n",
408 tun
->dev
->name
, addr
[0], addr
[1], addr
[2],
409 addr
[3], addr
[4], addr
[5]);
410 ret
= tun_put_user(tun
, skb
, (struct iovec
*) iv
, len
);
414 DBG(KERN_DEBUG
"%s: tun_chr_readv: rejected: %x:%x:%x:%x:%x:%x\n",
415 tun
->dev
->name
, addr
[0], addr
[1], addr
[2],
416 addr
[3], addr
[4], addr
[5]);
422 current
->state
= TASK_RUNNING
;
423 remove_wait_queue(&tun
->read_wait
, &wait
);
428 static void tun_setup(struct net_device
*dev
)
430 struct tun_struct
*tun
= netdev_priv(dev
);
432 skb_queue_head_init(&tun
->readq
);
433 init_waitqueue_head(&tun
->read_wait
);
438 dev
->open
= tun_net_open
;
439 dev
->hard_start_xmit
= tun_net_xmit
;
440 dev
->stop
= tun_net_close
;
441 dev
->get_stats
= tun_net_stats
;
442 dev
->ethtool_ops
= &tun_ethtool_ops
;
443 dev
->destructor
= free_netdev
;
446 static struct tun_struct
*tun_get_by_name(const char *name
)
448 struct tun_struct
*tun
;
451 list_for_each_entry(tun
, &tun_dev_list
, list
) {
452 if (!strncmp(tun
->dev
->name
, name
, IFNAMSIZ
))
459 static int tun_set_iff(struct file
*file
, struct ifreq
*ifr
)
461 struct tun_struct
*tun
;
462 struct net_device
*dev
;
465 tun
= tun_get_by_name(ifr
->ifr_name
);
470 /* Check permissions */
471 if (((tun
->owner
!= -1 &&
472 current
->euid
!= tun
->owner
) ||
474 current
->egid
!= tun
->group
)) &&
475 !capable(CAP_NET_ADMIN
))
478 else if (__dev_get_by_name(&init_net
, ifr
->ifr_name
))
482 unsigned long flags
= 0;
486 if (!capable(CAP_NET_ADMIN
))
490 if (ifr
->ifr_flags
& IFF_TUN
) {
492 flags
|= TUN_TUN_DEV
;
494 } else if (ifr
->ifr_flags
& IFF_TAP
) {
496 flags
|= TUN_TAP_DEV
;
502 name
= ifr
->ifr_name
;
504 dev
= alloc_netdev(sizeof(struct tun_struct
), name
,
509 tun
= netdev_priv(dev
);
512 /* Be promiscuous by default to maintain previous behaviour. */
513 tun
->if_flags
= IFF_PROMISC
;
514 /* Generate random Ethernet address. */
515 *(u16
*)tun
->dev_addr
= htons(0x00FF);
516 get_random_bytes(tun
->dev_addr
+ sizeof(u16
), 4);
517 memset(tun
->chr_filter
, 0, sizeof tun
->chr_filter
);
521 if (strchr(dev
->name
, '%')) {
522 err
= dev_alloc_name(dev
, dev
->name
);
527 err
= register_netdevice(tun
->dev
);
531 list_add(&tun
->list
, &tun_dev_list
);
534 DBG(KERN_INFO
"%s: tun_set_iff\n", tun
->dev
->name
);
536 if (ifr
->ifr_flags
& IFF_NO_PI
)
537 tun
->flags
|= TUN_NO_PI
;
539 if (ifr
->ifr_flags
& IFF_ONE_QUEUE
)
540 tun
->flags
|= TUN_ONE_QUEUE
;
542 file
->private_data
= tun
;
545 strcpy(ifr
->ifr_name
, tun
->dev
->name
);
554 static int tun_chr_ioctl(struct inode
*inode
, struct file
*file
,
555 unsigned int cmd
, unsigned long arg
)
557 struct tun_struct
*tun
= file
->private_data
;
558 void __user
* argp
= (void __user
*)arg
;
561 if (cmd
== TUNSETIFF
|| _IOC_TYPE(cmd
) == 0x89)
562 if (copy_from_user(&ifr
, argp
, sizeof ifr
))
565 if (cmd
== TUNSETIFF
&& !tun
) {
568 ifr
.ifr_name
[IFNAMSIZ
-1] = '\0';
571 err
= tun_set_iff(file
, &ifr
);
577 if (copy_to_user(argp
, &ifr
, sizeof(ifr
)))
585 DBG(KERN_INFO
"%s: tun_chr_ioctl cmd %d\n", tun
->dev
->name
, cmd
);
589 /* Disable/Enable checksum */
591 tun
->flags
|= TUN_NOCHECKSUM
;
593 tun
->flags
&= ~TUN_NOCHECKSUM
;
595 DBG(KERN_INFO
"%s: checksum %s\n",
596 tun
->dev
->name
, arg
? "disabled" : "enabled");
600 /* Disable/Enable persist mode */
602 tun
->flags
|= TUN_PERSIST
;
604 tun
->flags
&= ~TUN_PERSIST
;
606 DBG(KERN_INFO
"%s: persist %s\n",
607 tun
->dev
->name
, arg
? "disabled" : "enabled");
611 /* Set owner of the device */
612 tun
->owner
= (uid_t
) arg
;
614 DBG(KERN_INFO
"%s: owner set to %d\n", tun
->dev
->name
, tun
->owner
);
618 /* Set group of the device */
619 tun
->group
= (gid_t
) arg
;
621 DBG(KERN_INFO
"%s: group set to %d\n", tun
->dev
->name
, tun
->group
);
625 /* Only allow setting the type when the interface is down */
626 if (tun
->dev
->flags
& IFF_UP
) {
627 DBG(KERN_INFO
"%s: Linktype set failed because interface is up\n",
631 tun
->dev
->type
= (int) arg
;
632 DBG(KERN_INFO
"%s: linktype set to %d\n", tun
->dev
->name
, tun
->dev
->type
);
643 ifr
.ifr_flags
= tun
->if_flags
;
644 if (copy_to_user( argp
, &ifr
, sizeof ifr
))
649 /** Set the character device's interface flags. Currently only
650 * IFF_PROMISC and IFF_ALLMULTI are used. */
651 tun
->if_flags
= ifr
.ifr_flags
;
652 DBG(KERN_INFO
"%s: interface flags 0x%lx\n",
653 tun
->dev
->name
, tun
->if_flags
);
657 /* Note: the actual net device's address may be different */
658 memcpy(ifr
.ifr_hwaddr
.sa_data
, tun
->dev_addr
,
659 min(sizeof ifr
.ifr_hwaddr
.sa_data
, sizeof tun
->dev_addr
));
660 if (copy_to_user( argp
, &ifr
, sizeof ifr
))
666 /* try to set the actual net device's hw address */
667 int ret
= dev_set_mac_address(tun
->dev
, &ifr
.ifr_hwaddr
);
670 /** Set the character device's hardware address. This is used when
671 * filtering packets being sent from the network device to the character
673 memcpy(tun
->dev_addr
, ifr
.ifr_hwaddr
.sa_data
,
674 min(sizeof ifr
.ifr_hwaddr
.sa_data
, sizeof tun
->dev_addr
));
675 DBG(KERN_DEBUG
"%s: set hardware address: %x:%x:%x:%x:%x:%x\n",
677 tun
->dev_addr
[0], tun
->dev_addr
[1], tun
->dev_addr
[2],
678 tun
->dev_addr
[3], tun
->dev_addr
[4], tun
->dev_addr
[5]);
685 /** Add the specified group to the character device's multicast filter
687 add_multi(tun
->chr_filter
, ifr
.ifr_hwaddr
.sa_data
);
688 DBG(KERN_DEBUG
"%s: add multi: %x:%x:%x:%x:%x:%x\n",
690 (u8
)ifr
.ifr_hwaddr
.sa_data
[0], (u8
)ifr
.ifr_hwaddr
.sa_data
[1],
691 (u8
)ifr
.ifr_hwaddr
.sa_data
[2], (u8
)ifr
.ifr_hwaddr
.sa_data
[3],
692 (u8
)ifr
.ifr_hwaddr
.sa_data
[4], (u8
)ifr
.ifr_hwaddr
.sa_data
[5]);
696 /** Remove the specified group from the character device's multicast
698 del_multi(tun
->chr_filter
, ifr
.ifr_hwaddr
.sa_data
);
699 DBG(KERN_DEBUG
"%s: del multi: %x:%x:%x:%x:%x:%x\n",
701 (u8
)ifr
.ifr_hwaddr
.sa_data
[0], (u8
)ifr
.ifr_hwaddr
.sa_data
[1],
702 (u8
)ifr
.ifr_hwaddr
.sa_data
[2], (u8
)ifr
.ifr_hwaddr
.sa_data
[3],
703 (u8
)ifr
.ifr_hwaddr
.sa_data
[4], (u8
)ifr
.ifr_hwaddr
.sa_data
[5]);
713 static int tun_chr_fasync(int fd
, struct file
*file
, int on
)
715 struct tun_struct
*tun
= file
->private_data
;
721 DBG(KERN_INFO
"%s: tun_chr_fasync %d\n", tun
->dev
->name
, on
);
723 if ((ret
= fasync_helper(fd
, file
, on
, &tun
->fasync
)) < 0)
727 ret
= __f_setown(file
, task_pid(current
), PIDTYPE_PID
, 0);
730 tun
->flags
|= TUN_FASYNC
;
732 tun
->flags
&= ~TUN_FASYNC
;
737 static int tun_chr_open(struct inode
*inode
, struct file
* file
)
739 DBG1(KERN_INFO
"tunX: tun_chr_open\n");
740 file
->private_data
= NULL
;
744 static int tun_chr_close(struct inode
*inode
, struct file
*file
)
746 struct tun_struct
*tun
= file
->private_data
;
751 DBG(KERN_INFO
"%s: tun_chr_close\n", tun
->dev
->name
);
753 tun_chr_fasync(-1, file
, 0);
757 /* Detach from net device */
758 file
->private_data
= NULL
;
761 /* Drop read queue */
762 skb_queue_purge(&tun
->readq
);
764 if (!(tun
->flags
& TUN_PERSIST
)) {
765 list_del(&tun
->list
);
766 unregister_netdevice(tun
->dev
);
774 static const struct file_operations tun_fops
= {
775 .owner
= THIS_MODULE
,
777 .read
= do_sync_read
,
778 .aio_read
= tun_chr_aio_read
,
779 .write
= do_sync_write
,
780 .aio_write
= tun_chr_aio_write
,
781 .poll
= tun_chr_poll
,
782 .ioctl
= tun_chr_ioctl
,
783 .open
= tun_chr_open
,
784 .release
= tun_chr_close
,
785 .fasync
= tun_chr_fasync
788 static struct miscdevice tun_miscdev
= {
794 /* ethtool interface */
796 static int tun_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
799 cmd
->advertising
= 0;
800 cmd
->speed
= SPEED_10
;
801 cmd
->duplex
= DUPLEX_FULL
;
803 cmd
->phy_address
= 0;
804 cmd
->transceiver
= XCVR_INTERNAL
;
805 cmd
->autoneg
= AUTONEG_DISABLE
;
811 static void tun_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
813 struct tun_struct
*tun
= netdev_priv(dev
);
815 strcpy(info
->driver
, DRV_NAME
);
816 strcpy(info
->version
, DRV_VERSION
);
817 strcpy(info
->fw_version
, "N/A");
819 switch (tun
->flags
& TUN_TYPE_MASK
) {
821 strcpy(info
->bus_info
, "tun");
824 strcpy(info
->bus_info
, "tap");
829 static u32
tun_get_msglevel(struct net_device
*dev
)
832 struct tun_struct
*tun
= netdev_priv(dev
);
839 static void tun_set_msglevel(struct net_device
*dev
, u32 value
)
842 struct tun_struct
*tun
= netdev_priv(dev
);
847 static u32
tun_get_link(struct net_device
*dev
)
849 struct tun_struct
*tun
= netdev_priv(dev
);
850 return tun
->attached
;
853 static u32
tun_get_rx_csum(struct net_device
*dev
)
855 struct tun_struct
*tun
= netdev_priv(dev
);
856 return (tun
->flags
& TUN_NOCHECKSUM
) == 0;
859 static int tun_set_rx_csum(struct net_device
*dev
, u32 data
)
861 struct tun_struct
*tun
= netdev_priv(dev
);
863 tun
->flags
&= ~TUN_NOCHECKSUM
;
865 tun
->flags
|= TUN_NOCHECKSUM
;
869 static const struct ethtool_ops tun_ethtool_ops
= {
870 .get_settings
= tun_get_settings
,
871 .get_drvinfo
= tun_get_drvinfo
,
872 .get_msglevel
= tun_get_msglevel
,
873 .set_msglevel
= tun_set_msglevel
,
874 .get_link
= tun_get_link
,
875 .get_rx_csum
= tun_get_rx_csum
,
876 .set_rx_csum
= tun_set_rx_csum
879 static int __init
tun_init(void)
883 printk(KERN_INFO
"tun: %s, %s\n", DRV_DESCRIPTION
, DRV_VERSION
);
884 printk(KERN_INFO
"tun: %s\n", DRV_COPYRIGHT
);
886 ret
= misc_register(&tun_miscdev
);
888 printk(KERN_ERR
"tun: Can't register misc device %d\n", TUN_MINOR
);
892 static void tun_cleanup(void)
894 struct tun_struct
*tun
, *nxt
;
896 misc_deregister(&tun_miscdev
);
899 list_for_each_entry_safe(tun
, nxt
, &tun_dev_list
, list
) {
900 DBG(KERN_INFO
"%s cleaned up\n", tun
->dev
->name
);
901 unregister_netdevice(tun
->dev
);
907 module_init(tun_init
);
908 module_exit(tun_cleanup
);
909 MODULE_DESCRIPTION(DRV_DESCRIPTION
);
910 MODULE_AUTHOR(DRV_COPYRIGHT
);
911 MODULE_LICENSE("GPL");
912 MODULE_ALIAS_MISCDEV(TUN_MINOR
);