?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.4.102
[linux/fpc-iii.git] / drivers / net / tun.c
blob5b1a1b51fdb0aaccd4ee5301ff66e57ffbc9dab9
1 /*
2 * TUN - Universal TUN/TAP device driver.
3 * Copyright (C) 1999-2002 Maxim Krasnyansky <maxk@qualcomm.com>
4 *
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.
9 *
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.
14 *
15 * $Id: tun.c,v 1.15 2002/03/01 02:44:24 maxk Exp $
16 */
17
18 /*
19 * Changes:
20 *
21 * Mike Kershaw <dragorn@kismetwireless.net> 2005/08/14
22 * Add TUNSETLINK ioctl to set the link encapsulation
23 *
24 * Mark Smith <markzzzsmith@yahoo.com.au>
25 * Use random_ether_addr() for tap MAC address.
26 *
27 * Harald Roelle <harald.roelle@ifi.lmu.de> 2004/04/20
28 * Fixes in packet dropping, queue length setting and queue wakeup.
29 * Increased default tx queue length.
30 * Added ethtool API.
31 * Minor cleanups
32 *
33 * Daniel Podlejski <underley@underley.eu.org>
34 * Modifications for 2.3.99-pre5 kernel.
35 */
36
37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
38
39 #define DRV_NAME "tun"
40 #define DRV_VERSION "1.6"
41 #define DRV_DESCRIPTION "Universal TUN/TAP device driver"
42 #define DRV_COPYRIGHT "(C) 1999-2004 Max Krasnyansky <maxk@qualcomm.com>"
43
44 #include <linux/module.h>
45 #include <linux/errno.h>
46 #include <linux/kernel.h>
47 #include <linux/major.h>
48 #include <linux/slab.h>
49 #include <linux/poll.h>
50 #include <linux/fcntl.h>
51 #include <linux/init.h>
52 #include <linux/skbuff.h>
53 #include <linux/netdevice.h>
54 #include <linux/etherdevice.h>
55 #include <linux/miscdevice.h>
56 #include <linux/ethtool.h>
57 #include <linux/rtnetlink.h>
58 #include <linux/compat.h>
59 #include <linux/if.h>
60 #include <linux/if_arp.h>
61 #include <linux/if_ether.h>
62 #include <linux/if_tun.h>
63 #include <linux/crc32.h>
64 #include <linux/nsproxy.h>
65 #include <linux/virtio_net.h>
66 #include <linux/rcupdate.h>
67 #include <net/net_namespace.h>
68 #include <net/netns/generic.h>
69 #include <net/rtnetlink.h>
70 #include <net/sock.h>
71
72 #include <asm/uaccess.h>
73
74 /* Uncomment to enable debugging */
75 /* #define TUN_DEBUG 1 */
76
77 #ifdef TUN_DEBUG
78 static int debug;
79
80 #define tun_debug(level, tun, fmt, args...) \
81 do { \
82 if (tun->debug) \
83 netdev_printk(level, tun->dev, fmt, ##args); \
84 } while (0)
85 #define DBG1(level, fmt, args...) \
86 do { \
87 if (debug == 2) \
88 printk(level fmt, ##args); \
89 } while (0)
90 #else
91 #define tun_debug(level, tun, fmt, args...) \
92 do { \
93 if (0) \
94 netdev_printk(level, tun->dev, fmt, ##args); \
95 } while (0)
96 #define DBG1(level, fmt, args...) \
97 do { \
98 if (0) \
99 printk(level fmt, ##args); \
100 } while (0)
101 #endif
102
103 #define FLT_EXACT_COUNT 8
104 struct tap_filter {
105 unsigned int count; /* Number of addrs. Zero means disabled */
106 u32 mask[2]; /* Mask of the hashed addrs */
107 unsigned char addr[FLT_EXACT_COUNT][ETH_ALEN];
108 };
109
110 struct tun_file {
111 atomic_t count;
112 struct tun_struct *tun;
113 struct net *net;
114 };
115
116 struct tun_sock;
117
118 struct tun_struct {
119 struct tun_file *tfile;
120 unsigned int flags;
121 uid_t owner;
122 gid_t group;
123
124 struct net_device *dev;
125 netdev_features_t set_features;
126 #define TUN_USER_FEATURES (NETIF_F_HW_CSUM|NETIF_F_TSO_ECN|NETIF_F_TSO| \
127 NETIF_F_TSO6|NETIF_F_UFO)
128 struct fasync_struct *fasync;
129
130 struct tap_filter txflt;
131 struct socket socket;
132 struct socket_wq wq;
133
134 int vnet_hdr_sz;
135
136 #ifdef TUN_DEBUG
137 int debug;
138 #endif
139 };
140
141 struct tun_sock {
142 struct sock sk;
143 struct tun_struct *tun;
144 };
145
146 static inline struct tun_sock *tun_sk(struct sock *sk)
147 {
148 return container_of(sk, struct tun_sock, sk);
149 }
150
151 static int tun_attach(struct tun_struct *tun, struct file *file)
152 {
153 struct tun_file *tfile = file->private_data;
154 int err;
155
156 ASSERT_RTNL();
157
158 netif_tx_lock_bh(tun->dev);
159
160 err = -EINVAL;
161 if (tfile->tun)
162 goto out;
163
164 err = -EBUSY;
165 if (tun->tfile)
166 goto out;
167
168 err = 0;
169 tfile->tun = tun;
170 tun->tfile = tfile;
171 tun->socket.file = file;
172 netif_carrier_on(tun->dev);
173 dev_hold(tun->dev);
174 sock_hold(tun->socket.sk);
175 atomic_inc(&tfile->count);
176
177 out:
178 netif_tx_unlock_bh(tun->dev);
179 return err;
180 }
181
182 static void __tun_detach(struct tun_struct *tun)
183 {
184 /* Detach from net device */
185 netif_tx_lock_bh(tun->dev);
186 netif_carrier_off(tun->dev);
187 tun->tfile = NULL;
188 netif_tx_unlock_bh(tun->dev);
189
190 /* Drop read queue */
191 skb_queue_purge(&tun->socket.sk->sk_receive_queue);
192
193 /* Drop the extra count on the net device */
194 dev_put(tun->dev);
195 }
196
197 static void tun_detach(struct tun_struct *tun)
198 {
199 rtnl_lock();
200 __tun_detach(tun);
201 rtnl_unlock();
202 }
203
204 static struct tun_struct *__tun_get(struct tun_file *tfile)
205 {
206 struct tun_struct *tun = NULL;
207
208 if (atomic_inc_not_zero(&tfile->count))
209 tun = tfile->tun;
210
211 return tun;
212 }
213
214 static struct tun_struct *tun_get(struct file *file)
215 {
216 return __tun_get(file->private_data);
217 }
218
219 static void tun_put(struct tun_struct *tun)
220 {
221 struct tun_file *tfile = tun->tfile;
222
223 if (atomic_dec_and_test(&tfile->count))
224 tun_detach(tfile->tun);
225 }
226
227 /* TAP filtering */
228 static void addr_hash_set(u32 *mask, const u8 *addr)
229 {
230 int n = ether_crc(ETH_ALEN, addr) >> 26;
231 mask[n >> 5] |= (1 << (n & 31));
232 }
233
234 static unsigned int addr_hash_test(const u32 *mask, const u8 *addr)
235 {
236 int n = ether_crc(ETH_ALEN, addr) >> 26;
237 return mask[n >> 5] & (1 << (n & 31));
238 }
239
240 static int update_filter(struct tap_filter *filter, void __user *arg)
241 {
242 struct { u8 u[ETH_ALEN]; } *addr;
243 struct tun_filter uf;
244 int err, alen, n, nexact;
245
246 if (copy_from_user(&uf, arg, sizeof(uf)))
247 return -EFAULT;
248
249 if (!uf.count) {
250 /* Disabled */
251 filter->count = 0;
252 return 0;
253 }
254
255 alen = ETH_ALEN * uf.count;
256 addr = kmalloc(alen, GFP_KERNEL);
257 if (!addr)
258 return -ENOMEM;
259
260 if (copy_from_user(addr, arg + sizeof(uf), alen)) {
261 err = -EFAULT;
262 goto done;
263 }
264
265 /* The filter is updated without holding any locks. Which is
266 * perfectly safe. We disable it first and in the worst
267 * case we'll accept a few undesired packets. */
268 filter->count = 0;
269 wmb();
270
271 /* Use first set of addresses as an exact filter */
272 for (n = 0; n < uf.count && n < FLT_EXACT_COUNT; n++)
273 memcpy(filter->addr[n], addr[n].u, ETH_ALEN);
274
275 nexact = n;
276
277 /* Remaining multicast addresses are hashed,
278 * unicast will leave the filter disabled. */
279 memset(filter->mask, 0, sizeof(filter->mask));
280 for (; n < uf.count; n++) {
281 if (!is_multicast_ether_addr(addr[n].u)) {
282 err = 0; /* no filter */
283 goto done;
284 }
285 addr_hash_set(filter->mask, addr[n].u);
286 }
287
288 /* For ALLMULTI just set the mask to all ones.
289 * This overrides the mask populated above. */
290 if ((uf.flags & TUN_FLT_ALLMULTI))
291 memset(filter->mask, ~0, sizeof(filter->mask));
292
293 /* Now enable the filter */
294 wmb();
295 filter->count = nexact;
296
297 /* Return the number of exact filters */
298 err = nexact;
299
300 done:
301 kfree(addr);
302 return err;
303 }
304
305 /* Returns: 0 - drop, !=0 - accept */
306 static int run_filter(struct tap_filter *filter, const struct sk_buff *skb)
307 {
308 /* Cannot use eth_hdr(skb) here because skb_mac_hdr() is incorrect
309 * at this point. */
310 struct ethhdr *eh = (struct ethhdr *) skb->data;
311 int i;
312
313 /* Exact match */
314 for (i = 0; i < filter->count; i++)
315 if (!compare_ether_addr(eh->h_dest, filter->addr[i]))
316 return 1;
317
318 /* Inexact match (multicast only) */
319 if (is_multicast_ether_addr(eh->h_dest))
320 return addr_hash_test(filter->mask, eh->h_dest);
321
322 return 0;
323 }
324
325 /*
326 * Checks whether the packet is accepted or not.
327 * Returns: 0 - drop, !=0 - accept
328 */
329 static int check_filter(struct tap_filter *filter, const struct sk_buff *skb)
330 {
331 if (!filter->count)
332 return 1;
333
334 return run_filter(filter, skb);
335 }
336
337 /* Network device part of the driver */
338
339 static const struct ethtool_ops tun_ethtool_ops;
340
341 /* Net device detach from fd. */
342 static void tun_net_uninit(struct net_device *dev)
343 {
344 struct tun_struct *tun = netdev_priv(dev);
345 struct tun_file *tfile = tun->tfile;
346
347 /* Inform the methods they need to stop using the dev.
348 */
349 if (tfile) {
350 wake_up_all(&tun->wq.wait);
351 if (atomic_dec_and_test(&tfile->count))
352 __tun_detach(tun);
353 }
354 }
355
356 static void tun_free_netdev(struct net_device *dev)
357 {
358 struct tun_struct *tun = netdev_priv(dev);
359
360 BUG_ON(!test_bit(SOCK_EXTERNALLY_ALLOCATED, &tun->socket.flags));
361
362 sk_release_kernel(tun->socket.sk);
363 }
364
365 /* Net device open. */
366 static int tun_net_open(struct net_device *dev)
367 {
368 netif_start_queue(dev);
369 return 0;
370 }
371
372 /* Net device close. */
373 static int tun_net_close(struct net_device *dev)
374 {
375 netif_stop_queue(dev);
376 return 0;
377 }
378
379 /* Net device start xmit */
380 static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev)
381 {
382 struct tun_struct *tun = netdev_priv(dev);
383
384 tun_debug(KERN_INFO, tun, "tun_net_xmit %d\n", skb->len);
385
386 /* Drop packet if interface is not attached */
387 if (!tun->tfile)
388 goto drop;
389
390 /* Drop if the filter does not like it.
391 * This is a noop if the filter is disabled.
392 * Filter can be enabled only for the TAP devices. */
393 if (!check_filter(&tun->txflt, skb))
394 goto drop;
395
396 if (tun->socket.sk->sk_filter &&
397 sk_filter(tun->socket.sk, skb))
398 goto drop;
399
400 if (skb_queue_len(&tun->socket.sk->sk_receive_queue) >= dev->tx_queue_len) {
401 if (!(tun->flags & TUN_ONE_QUEUE)) {
402 /* Normal queueing mode. */
403 /* Packet scheduler handles dropping of further packets. */
404 netif_stop_queue(dev);
405
406 /* We won't see all dropped packets individually, so overrun
407 * error is more appropriate. */
408 dev->stats.tx_fifo_errors++;
409 } else {
410 /* Single queue mode.
411 * Driver handles dropping of all packets itself. */
412 goto drop;
413 }
414 }
415
416 /* Orphan the skb - required as we might hang on to it
417 * for indefinite time. */
418 skb_orphan(skb);
419
420 nf_reset(skb);
421
422 /* Enqueue packet */
423 skb_queue_tail(&tun->socket.sk->sk_receive_queue, skb);
424
425 /* Notify and wake up reader process */
426 if (tun->flags & TUN_FASYNC)
427 kill_fasync(&tun->fasync, SIGIO, POLL_IN);
428 wake_up_interruptible_poll(&tun->wq.wait, POLLIN |
429 POLLRDNORM | POLLRDBAND);
430 return NETDEV_TX_OK;
431
432 drop:
433 dev->stats.tx_dropped++;
434 kfree_skb(skb);
435 return NETDEV_TX_OK;
436 }
437
438 static void tun_net_mclist(struct net_device *dev)
439 {
440 /*
441 * This callback is supposed to deal with mc filter in
442 * _rx_ path and has nothing to do with the _tx_ path.
443 * In rx path we always accept everything userspace gives us.
444 */
445 }
446
447 #define MIN_MTU 68
448 #define MAX_MTU 65535
449
450 static int
451 tun_net_change_mtu(struct net_device *dev, int new_mtu)
452 {
453 if (new_mtu < MIN_MTU || new_mtu + dev->hard_header_len > MAX_MTU)
454 return -EINVAL;
455 dev->mtu = new_mtu;
456 return 0;
457 }
458
459 static netdev_features_t tun_net_fix_features(struct net_device *dev,
460 netdev_features_t features)
461 {
462 struct tun_struct *tun = netdev_priv(dev);
463
464 return (features & tun->set_features) | (features & ~TUN_USER_FEATURES);
465 }
466 #ifdef CONFIG_NET_POLL_CONTROLLER
467 static void tun_poll_controller(struct net_device *dev)
468 {
469 /*
470 * Tun only receives frames when:
471 * 1) the char device endpoint gets data from user space
472 * 2) the tun socket gets a sendmsg call from user space
473 * Since both of those are syncronous operations, we are guaranteed
474 * never to have pending data when we poll for it
475 * so theres nothing to do here but return.
476 * We need this though so netpoll recognizes us as an interface that
477 * supports polling, which enables bridge devices in virt setups to
478 * still use netconsole
479 */
480 return;
481 }
482 #endif
483 static const struct net_device_ops tun_netdev_ops = {
484 .ndo_uninit = tun_net_uninit,
485 .ndo_open = tun_net_open,
486 .ndo_stop = tun_net_close,
487 .ndo_start_xmit = tun_net_xmit,
488 .ndo_change_mtu = tun_net_change_mtu,
489 .ndo_fix_features = tun_net_fix_features,
490 #ifdef CONFIG_NET_POLL_CONTROLLER
491 .ndo_poll_controller = tun_poll_controller,
492 #endif
493 };
494
495 static const struct net_device_ops tap_netdev_ops = {
496 .ndo_uninit = tun_net_uninit,
497 .ndo_open = tun_net_open,
498 .ndo_stop = tun_net_close,
499 .ndo_start_xmit = tun_net_xmit,
500 .ndo_change_mtu = tun_net_change_mtu,
501 .ndo_fix_features = tun_net_fix_features,
502 .ndo_set_rx_mode = tun_net_mclist,
503 .ndo_set_mac_address = eth_mac_addr,
504 .ndo_validate_addr = eth_validate_addr,
505 #ifdef CONFIG_NET_POLL_CONTROLLER
506 .ndo_poll_controller = tun_poll_controller,
507 #endif
508 };
509
510 /* Initialize net device. */
511 static void tun_net_init(struct net_device *dev)
512 {
513 struct tun_struct *tun = netdev_priv(dev);
514
515 switch (tun->flags & TUN_TYPE_MASK) {
516 case TUN_TUN_DEV:
517 dev->netdev_ops = &tun_netdev_ops;
518
519 /* Point-to-Point TUN Device */
520 dev->hard_header_len = 0;
521 dev->addr_len = 0;
522 dev->mtu = 1500;
523
524 /* Zero header length */
525 dev->type = ARPHRD_NONE;
526 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
527 dev->tx_queue_len = TUN_READQ_SIZE; /* We prefer our own queue length */
528 break;
529
530 case TUN_TAP_DEV:
531 dev->netdev_ops = &tap_netdev_ops;
532 /* Ethernet TAP Device */
533 ether_setup(dev);
534 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
535
536 eth_hw_addr_random(dev);
537
538 dev->tx_queue_len = TUN_READQ_SIZE; /* We prefer our own queue length */
539 break;
540 }
541 }
542
543 /* Character device part */
544
545 /* Poll */
546 static unsigned int tun_chr_poll(struct file *file, poll_table * wait)
547 {
548 struct tun_file *tfile = file->private_data;
549 struct tun_struct *tun = __tun_get(tfile);
550 struct sock *sk;
551 unsigned int mask = 0;
552
553 if (!tun)
554 return POLLERR;
555
556 sk = tun->socket.sk;
557
558 tun_debug(KERN_INFO, tun, "tun_chr_poll\n");
559
560 poll_wait(file, &tun->wq.wait, wait);
561
562 if (!skb_queue_empty(&sk->sk_receive_queue))
563 mask |= POLLIN | POLLRDNORM;
564
565 if (sock_writeable(sk) ||
566 (!test_and_set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags) &&
567 sock_writeable(sk)))
568 mask |= POLLOUT | POLLWRNORM;
569
570 if (tun->dev->reg_state != NETREG_REGISTERED)
571 mask = POLLERR;
572
573 tun_put(tun);
574 return mask;
575 }
576
577 /* prepad is the amount to reserve at front. len is length after that.
578 * linear is a hint as to how much to copy (usually headers). */
579 static struct sk_buff *tun_alloc_skb(struct tun_struct *tun,
580 size_t prepad, size_t len,
581 size_t linear, int noblock)
582 {
583 struct sock *sk = tun->socket.sk;
584 struct sk_buff *skb;
585 int err;
586
587 sock_update_classid(sk);
588
589 /* Under a page? Don't bother with paged skb. */
590 if (prepad + len < PAGE_SIZE || !linear)
591 linear = len;
592
593 skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock,
594 &err);
595 if (!skb)
596 return ERR_PTR(err);
597
598 skb_reserve(skb, prepad);
599 skb_put(skb, linear);
600 skb->data_len = len - linear;
601 skb->len += len - linear;
602
603 return skb;
604 }
605
606 /* Get packet from user space buffer */
607 static ssize_t tun_get_user(struct tun_struct *tun,
608 const struct iovec *iv, size_t count,
609 int noblock)
610 {
611 struct tun_pi pi = { 0, cpu_to_be16(ETH_P_IP) };
612 struct sk_buff *skb;
613 size_t len = count, align = NET_SKB_PAD;
614 struct virtio_net_hdr gso = { 0 };
615 int offset = 0;
616
617 if (!(tun->flags & TUN_NO_PI)) {
618 if (len < sizeof(pi))
619 return -EINVAL;
620 len -= sizeof(pi);
621
622 if (memcpy_fromiovecend((void *)&pi, iv, 0, sizeof(pi)))
623 return -EFAULT;
624 offset += sizeof(pi);
625 }
626
627 if (tun->flags & TUN_VNET_HDR) {
628 if (len < tun->vnet_hdr_sz)
629 return -EINVAL;
630 len -= tun->vnet_hdr_sz;
631
632 if (memcpy_fromiovecend((void *)&gso, iv, offset, sizeof(gso)))
633 return -EFAULT;
634
635 if ((gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
636 gso.csum_start + gso.csum_offset + 2 > gso.hdr_len)
637 gso.hdr_len = gso.csum_start + gso.csum_offset + 2;
638
639 if (gso.hdr_len > len)
640 return -EINVAL;
641 offset += tun->vnet_hdr_sz;
642 }
643
644 if ((tun->flags & TUN_TYPE_MASK) == TUN_TAP_DEV) {
645 align += NET_IP_ALIGN;
646 if (unlikely(len < ETH_HLEN ||
647 (gso.hdr_len && gso.hdr_len < ETH_HLEN)))
648 return -EINVAL;
649 }
650
651 skb = tun_alloc_skb(tun, align, len, gso.hdr_len, noblock);
652 if (IS_ERR(skb)) {
653 if (PTR_ERR(skb) != -EAGAIN)
654 tun->dev->stats.rx_dropped++;
655 return PTR_ERR(skb);
656 }
657
658 if (skb_copy_datagram_from_iovec(skb, 0, iv, offset, len)) {
659 tun->dev->stats.rx_dropped++;
660 kfree_skb(skb);
661 return -EFAULT;
662 }
663
664 if (gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
665 if (!skb_partial_csum_set(skb, gso.csum_start,
666 gso.csum_offset)) {
667 tun->dev->stats.rx_frame_errors++;
668 kfree_skb(skb);
669 return -EINVAL;
670 }
671 }
672
673 switch (tun->flags & TUN_TYPE_MASK) {
674 case TUN_TUN_DEV:
675 if (tun->flags & TUN_NO_PI) {
676 switch (skb->data[0] & 0xf0) {
677 case 0x40:
678 pi.proto = htons(ETH_P_IP);
679 break;
680 case 0x60:
681 pi.proto = htons(ETH_P_IPV6);
682 break;
683 default:
684 tun->dev->stats.rx_dropped++;
685 kfree_skb(skb);
686 return -EINVAL;
687 }
688 }
689
690 skb_reset_mac_header(skb);
691 skb->protocol = pi.proto;
692 skb->dev = tun->dev;
693 break;
694 case TUN_TAP_DEV:
695 skb->protocol = eth_type_trans(skb, tun->dev);
696 break;
697 }
698
699 if (gso.gso_type != VIRTIO_NET_HDR_GSO_NONE) {
700 pr_debug("GSO!\n");
701 switch (gso.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
702 case VIRTIO_NET_HDR_GSO_TCPV4:
703 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
704 break;
705 case VIRTIO_NET_HDR_GSO_TCPV6:
706 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
707 break;
708 case VIRTIO_NET_HDR_GSO_UDP:
709 skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
710 break;
711 default:
712 tun->dev->stats.rx_frame_errors++;
713 kfree_skb(skb);
714 return -EINVAL;
715 }
716
717 if (gso.gso_type & VIRTIO_NET_HDR_GSO_ECN)
718 skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
719
720 skb_shinfo(skb)->gso_size = gso.gso_size;
721 if (skb_shinfo(skb)->gso_size == 0) {
722 tun->dev->stats.rx_frame_errors++;
723 kfree_skb(skb);
724 return -EINVAL;
725 }
726
727 /* Header must be checked, and gso_segs computed. */
728 skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
729 skb_shinfo(skb)->gso_segs = 0;
730 }
731
732 netif_rx_ni(skb);
733
734 tun->dev->stats.rx_packets++;
735 tun->dev->stats.rx_bytes += len;
736
737 return count;
738 }
739
740 static ssize_t tun_chr_aio_write(struct kiocb *iocb, const struct iovec *iv,
741 unsigned long count, loff_t pos)
742 {
743 struct file *file = iocb->ki_filp;
744 struct tun_struct *tun = tun_get(file);
745 ssize_t result;
746
747 if (!tun)
748 return -EBADFD;
749
750 tun_debug(KERN_INFO, tun, "tun_chr_write %ld\n", count);
751
752 result = tun_get_user(tun, iv, iov_length(iv, count),
753 file->f_flags & O_NONBLOCK);
754
755 tun_put(tun);
756 return result;
757 }
758
759 /* Put packet to the user space buffer */
760 static ssize_t tun_put_user(struct tun_struct *tun,
761 struct sk_buff *skb,
762 const struct iovec *iv, int len)
763 {
764 struct tun_pi pi = { 0, skb->protocol };
765 ssize_t total = 0;
766
767 if (!(tun->flags & TUN_NO_PI)) {
768 if ((len -= sizeof(pi)) < 0)
769 return -EINVAL;
770
771 if (len < skb->len) {
772 /* Packet will be striped */
773 pi.flags |= TUN_PKT_STRIP;
774 }
775
776 if (memcpy_toiovecend(iv, (void *) &pi, 0, sizeof(pi)))
777 return -EFAULT;
778 total += sizeof(pi);
779 }
780
781 if (tun->flags & TUN_VNET_HDR) {
782 struct virtio_net_hdr gso = { 0 }; /* no info leak */
783 if ((len -= tun->vnet_hdr_sz) < 0)
784 return -EINVAL;
785
786 if (skb_is_gso(skb)) {
787 struct skb_shared_info *sinfo = skb_shinfo(skb);
788
789 /* This is a hint as to how much should be linear. */
790 gso.hdr_len = skb_headlen(skb);
791 gso.gso_size = sinfo->gso_size;
792 if (sinfo->gso_type & SKB_GSO_TCPV4)
793 gso.gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
794 else if (sinfo->gso_type & SKB_GSO_TCPV6)
795 gso.gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
796 else if (sinfo->gso_type & SKB_GSO_UDP)
797 gso.gso_type = VIRTIO_NET_HDR_GSO_UDP;
798 else {
799 pr_err("unexpected GSO type: "
800 "0x%x, gso_size %d, hdr_len %d\n",
801 sinfo->gso_type, gso.gso_size,
802 gso.hdr_len);
803 print_hex_dump(KERN_ERR, "tun: ",
804 DUMP_PREFIX_NONE,
805 16, 1, skb->head,
806 min((int)gso.hdr_len, 64), true);
807 WARN_ON_ONCE(1);
808 return -EINVAL;
809 }
810 if (sinfo->gso_type & SKB_GSO_TCP_ECN)
811 gso.gso_type |= VIRTIO_NET_HDR_GSO_ECN;
812 } else
813 gso.gso_type = VIRTIO_NET_HDR_GSO_NONE;
814
815 if (skb->ip_summed == CHECKSUM_PARTIAL) {
816 gso.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
817 gso.csum_start = skb_checksum_start_offset(skb);
818 gso.csum_offset = skb->csum_offset;
819 } else if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
820 gso.flags = VIRTIO_NET_HDR_F_DATA_VALID;
821 } /* else everything is zero */
822
823 if (unlikely(memcpy_toiovecend(iv, (void *)&gso, total,
824 sizeof(gso))))
825 return -EFAULT;
826 total += tun->vnet_hdr_sz;
827 }
828
829 len = min_t(int, skb->len, len);
830
831 skb_copy_datagram_const_iovec(skb, 0, iv, total, len);
832 total += skb->len;
833
834 tun->dev->stats.tx_packets++;
835 tun->dev->stats.tx_bytes += len;
836
837 return total;
838 }
839
840 static ssize_t tun_do_read(struct tun_struct *tun,
841 struct kiocb *iocb, const struct iovec *iv,
842 ssize_t len, int noblock)
843 {
844 DECLARE_WAITQUEUE(wait, current);
845 struct sk_buff *skb;
846 ssize_t ret = 0;
847
848 tun_debug(KERN_INFO, tun, "tun_chr_read\n");
849
850 if (unlikely(!noblock))
851 add_wait_queue(&tun->wq.wait, &wait);
852 while (len) {
853 current->state = TASK_INTERRUPTIBLE;
854
855 /* Read frames from the queue */
856 if (!(skb=skb_dequeue(&tun->socket.sk->sk_receive_queue))) {
857 if (noblock) {
858 ret = -EAGAIN;
859 break;
860 }
861 if (signal_pending(current)) {
862 ret = -ERESTARTSYS;
863 break;
864 }
865 if (tun->dev->reg_state != NETREG_REGISTERED) {
866 ret = -EIO;
867 break;
868 }
869
870 /* Nothing to read, let's sleep */
871 schedule();
872 continue;
873 }
874 netif_wake_queue(tun->dev);
875
876 ret = tun_put_user(tun, skb, iv, len);
877 kfree_skb(skb);
878 break;
879 }
880
881 current->state = TASK_RUNNING;
882 if (unlikely(!noblock))
883 remove_wait_queue(&tun->wq.wait, &wait);
884
885 return ret;
886 }
887
888 static ssize_t tun_chr_aio_read(struct kiocb *iocb, const struct iovec *iv,
889 unsigned long count, loff_t pos)
890 {
891 struct file *file = iocb->ki_filp;
892 struct tun_file *tfile = file->private_data;
893 struct tun_struct *tun = __tun_get(tfile);
894 ssize_t len, ret;
895
896 if (!tun)
897 return -EBADFD;
898 len = iov_length(iv, count);
899 if (len < 0) {
900 ret = -EINVAL;
901 goto out;
902 }
903
904 ret = tun_do_read(tun, iocb, iv, len, file->f_flags & O_NONBLOCK);
905 ret = min_t(ssize_t, ret, len);
906 if (ret > 0)
907 iocb->ki_pos = ret;
908 out:
909 tun_put(tun);
910 return ret;
911 }
912
913 static void tun_setup(struct net_device *dev)
914 {
915 struct tun_struct *tun = netdev_priv(dev);
916
917 tun->owner = -1;
918 tun->group = -1;
919
920 dev->ethtool_ops = &tun_ethtool_ops;
921 dev->destructor = tun_free_netdev;
922 }
923
924 /* Trivial set of netlink ops to allow deleting tun or tap
925 * device with netlink.
926 */
927 static int tun_validate(struct nlattr *tb[], struct nlattr *data[])
928 {
929 return -EINVAL;
930 }
931
932 static struct rtnl_link_ops tun_link_ops __read_mostly = {
933 .kind = DRV_NAME,
934 .priv_size = sizeof(struct tun_struct),
935 .setup = tun_setup,
936 .validate = tun_validate,
937 };
938
939 static void tun_sock_write_space(struct sock *sk)
940 {
941 struct tun_struct *tun;
942 wait_queue_head_t *wqueue;
943
944 if (!sock_writeable(sk))
945 return;
946
947 if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags))
948 return;
949
950 wqueue = sk_sleep(sk);
951 if (wqueue && waitqueue_active(wqueue))
952 wake_up_interruptible_sync_poll(wqueue, POLLOUT |
953 POLLWRNORM | POLLWRBAND);
954
955 tun = tun_sk(sk)->tun;
956 kill_fasync(&tun->fasync, SIGIO, POLL_OUT);
957 }
958
959 static void tun_sock_destruct(struct sock *sk)
960 {
961 free_netdev(tun_sk(sk)->tun->dev);
962 }
963
964 static int tun_sendmsg(struct kiocb *iocb, struct socket *sock,
965 struct msghdr *m, size_t total_len)
966 {
967 struct tun_struct *tun = container_of(sock, struct tun_struct, socket);
968 return tun_get_user(tun, m->msg_iov, total_len,
969 m->msg_flags & MSG_DONTWAIT);
970 }
971
972 static int tun_recvmsg(struct kiocb *iocb, struct socket *sock,
973 struct msghdr *m, size_t total_len,
974 int flags)
975 {
976 struct tun_struct *tun = container_of(sock, struct tun_struct, socket);
977 int ret;
978 if (flags & ~(MSG_DONTWAIT|MSG_TRUNC))
979 return -EINVAL;
980 ret = tun_do_read(tun, iocb, m->msg_iov, total_len,
981 flags & MSG_DONTWAIT);
982 if (ret > total_len) {
983 m->msg_flags |= MSG_TRUNC;
984 ret = flags & MSG_TRUNC ? ret : total_len;
985 }
986 return ret;
987 }
988
989 static int tun_release(struct socket *sock)
990 {
991 if (sock->sk)
992 sock_put(sock->sk);
993 return 0;
994 }
995
996 /* Ops structure to mimic raw sockets with tun */
997 static const struct proto_ops tun_socket_ops = {
998 .sendmsg = tun_sendmsg,
999 .recvmsg = tun_recvmsg,
1000 .release = tun_release,
1001 };
1002
1003 static struct proto tun_proto = {
1004 .name = "tun",
1005 .owner = THIS_MODULE,
1006 .obj_size = sizeof(struct tun_sock),
1007 };
1008
1009 static int tun_flags(struct tun_struct *tun)
1010 {
1011 int flags = 0;
1012
1013 if (tun->flags & TUN_TUN_DEV)
1014 flags |= IFF_TUN;
1015 else
1016 flags |= IFF_TAP;
1017
1018 if (tun->flags & TUN_NO_PI)
1019 flags |= IFF_NO_PI;
1020
1021 if (tun->flags & TUN_ONE_QUEUE)
1022 flags |= IFF_ONE_QUEUE;
1023
1024 if (tun->flags & TUN_VNET_HDR)
1025 flags |= IFF_VNET_HDR;
1026
1027 return flags;
1028 }
1029
1030 static ssize_t tun_show_flags(struct device *dev, struct device_attribute *attr,
1031 char *buf)
1032 {
1033 struct tun_struct *tun = netdev_priv(to_net_dev(dev));
1034 return sprintf(buf, "0x%x\n", tun_flags(tun));
1035 }
1036
1037 static ssize_t tun_show_owner(struct device *dev, struct device_attribute *attr,
1038 char *buf)
1039 {
1040 struct tun_struct *tun = netdev_priv(to_net_dev(dev));
1041 return sprintf(buf, "%d\n", tun->owner);
1042 }
1043
1044 static ssize_t tun_show_group(struct device *dev, struct device_attribute *attr,
1045 char *buf)
1046 {
1047 struct tun_struct *tun = netdev_priv(to_net_dev(dev));
1048 return sprintf(buf, "%d\n", tun->group);
1049 }
1050
1051 static DEVICE_ATTR(tun_flags, 0444, tun_show_flags, NULL);
1052 static DEVICE_ATTR(owner, 0444, tun_show_owner, NULL);
1053 static DEVICE_ATTR(group, 0444, tun_show_group, NULL);
1054
1055 static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
1056 {
1057 struct sock *sk;
1058 struct tun_struct *tun;
1059 struct net_device *dev;
1060 int err;
1061
1062 dev = __dev_get_by_name(net, ifr->ifr_name);
1063 if (dev) {
1064 const struct cred *cred = current_cred();
1065
1066 if (ifr->ifr_flags & IFF_TUN_EXCL)
1067 return -EBUSY;
1068 if ((ifr->ifr_flags & IFF_TUN) && dev->netdev_ops == &tun_netdev_ops)
1069 tun = netdev_priv(dev);
1070 else if ((ifr->ifr_flags & IFF_TAP) && dev->netdev_ops == &tap_netdev_ops)
1071 tun = netdev_priv(dev);
1072 else
1073 return -EINVAL;
1074
1075 if (((tun->owner != -1 && cred->euid != tun->owner) ||
1076 (tun->group != -1 && !in_egroup_p(tun->group))) &&
1077 !capable(CAP_NET_ADMIN))
1078 return -EPERM;
1079 err = security_tun_dev_attach(tun->socket.sk);
1080 if (err < 0)
1081 return err;
1082
1083 err = tun_attach(tun, file);
1084 if (err < 0)
1085 return err;
1086 }
1087 else {
1088 char *name;
1089 unsigned long flags = 0;
1090
1091 if (!capable(CAP_NET_ADMIN))
1092 return -EPERM;
1093 err = security_tun_dev_create();
1094 if (err < 0)
1095 return err;
1096
1097 /* Set dev type */
1098 if (ifr->ifr_flags & IFF_TUN) {
1099 /* TUN device */
1100 flags |= TUN_TUN_DEV;
1101 name = "tun%d";
1102 } else if (ifr->ifr_flags & IFF_TAP) {
1103 /* TAP device */
1104 flags |= TUN_TAP_DEV;
1105 name = "tap%d";
1106 } else
1107 return -EINVAL;
1108
1109 if (*ifr->ifr_name)
1110 name = ifr->ifr_name;
1111
1112 dev = alloc_netdev(sizeof(struct tun_struct), name,
1113 tun_setup);
1114 if (!dev)
1115 return -ENOMEM;
1116
1117 dev_net_set(dev, net);
1118 dev->rtnl_link_ops = &tun_link_ops;
1119
1120 tun = netdev_priv(dev);
1121 tun->dev = dev;
1122 tun->flags = flags;
1123 tun->txflt.count = 0;
1124 tun->vnet_hdr_sz = sizeof(struct virtio_net_hdr);
1125 set_bit(SOCK_EXTERNALLY_ALLOCATED, &tun->socket.flags);
1126
1127 err = -ENOMEM;
1128 sk = sk_alloc(&init_net, AF_UNSPEC, GFP_KERNEL, &tun_proto);
1129 if (!sk)
1130 goto err_free_dev;
1131
1132 sk_change_net(sk, net);
1133 tun->socket.wq = &tun->wq;
1134 init_waitqueue_head(&tun->wq.wait);
1135 tun->socket.ops = &tun_socket_ops;
1136 sock_init_data(&tun->socket, sk);
1137 sk->sk_write_space = tun_sock_write_space;
1138 sk->sk_sndbuf = INT_MAX;
1139
1140 tun_sk(sk)->tun = tun;
1141
1142 security_tun_dev_post_create(sk);
1143
1144 tun_net_init(dev);
1145
1146 dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST |
1147 TUN_USER_FEATURES;
1148 dev->features = dev->hw_features;
1149
1150 err = register_netdevice(tun->dev);
1151 if (err < 0)
1152 goto err_free_sk;
1153
1154 if (device_create_file(&tun->dev->dev, &dev_attr_tun_flags) ||
1155 device_create_file(&tun->dev->dev, &dev_attr_owner) ||
1156 device_create_file(&tun->dev->dev, &dev_attr_group))
1157 pr_err("Failed to create tun sysfs files\n");
1158
1159 sk->sk_destruct = tun_sock_destruct;
1160
1161 err = tun_attach(tun, file);
1162 if (err < 0)
1163 goto failed;
1164 }
1165
1166 tun_debug(KERN_INFO, tun, "tun_set_iff\n");
1167
1168 if (ifr->ifr_flags & IFF_NO_PI)
1169 tun->flags |= TUN_NO_PI;
1170 else
1171 tun->flags &= ~TUN_NO_PI;
1172
1173 if (ifr->ifr_flags & IFF_ONE_QUEUE)
1174 tun->flags |= TUN_ONE_QUEUE;
1175 else
1176 tun->flags &= ~TUN_ONE_QUEUE;
1177
1178 if (ifr->ifr_flags & IFF_VNET_HDR)
1179 tun->flags |= TUN_VNET_HDR;
1180 else
1181 tun->flags &= ~TUN_VNET_HDR;
1182
1183 /* Make sure persistent devices do not get stuck in
1184 * xoff state.
1185 */
1186 if (netif_running(tun->dev))
1187 netif_wake_queue(tun->dev);
1188
1189 strcpy(ifr->ifr_name, tun->dev->name);
1190 return 0;
1191
1192 err_free_sk:
1193 tun_free_netdev(dev);
1194 err_free_dev:
1195 free_netdev(dev);
1196 failed:
1197 return err;
1198 }
1199
1200 static int tun_get_iff(struct net *net, struct tun_struct *tun,
1201 struct ifreq *ifr)
1202 {
1203 tun_debug(KERN_INFO, tun, "tun_get_iff\n");
1204
1205 strcpy(ifr->ifr_name, tun->dev->name);
1206
1207 ifr->ifr_flags = tun_flags(tun);
1208
1209 return 0;
1210 }
1211
1212 /* This is like a cut-down ethtool ops, except done via tun fd so no
1213 * privs required. */
1214 static int set_offload(struct tun_struct *tun, unsigned long arg)
1215 {
1216 netdev_features_t features = 0;
1217
1218 if (arg & TUN_F_CSUM) {
1219 features |= NETIF_F_HW_CSUM;
1220 arg &= ~TUN_F_CSUM;
1221
1222 if (arg & (TUN_F_TSO4|TUN_F_TSO6)) {
1223 if (arg & TUN_F_TSO_ECN) {
1224 features |= NETIF_F_TSO_ECN;
1225 arg &= ~TUN_F_TSO_ECN;
1226 }
1227 if (arg & TUN_F_TSO4)
1228 features |= NETIF_F_TSO;
1229 if (arg & TUN_F_TSO6)
1230 features |= NETIF_F_TSO6;
1231 arg &= ~(TUN_F_TSO4|TUN_F_TSO6);
1232 }
1233
1234 if (arg & TUN_F_UFO) {
1235 features |= NETIF_F_UFO;
1236 arg &= ~TUN_F_UFO;
1237 }
1238 }
1239
1240 /* This gives the user a way to test for new features in future by
1241 * trying to set them. */
1242 if (arg)
1243 return -EINVAL;
1244
1245 tun->set_features = features;
1246 netdev_update_features(tun->dev);
1247
1248 return 0;
1249 }
1250
1251 static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
1252 unsigned long arg, int ifreq_len)
1253 {
1254 struct tun_file *tfile = file->private_data;
1255 struct tun_struct *tun;
1256 void __user* argp = (void __user*)arg;
1257 struct sock_fprog fprog;
1258 struct ifreq ifr;
1259 int sndbuf;
1260 int vnet_hdr_sz;
1261 int ret;
1262
1263 if (cmd == TUNSETIFF || _IOC_TYPE(cmd) == 0x89) {
1264 if (copy_from_user(&ifr, argp, ifreq_len))
1265 return -EFAULT;
1266 } else {
1267 memset(&ifr, 0, sizeof(ifr));
1268 }
1269 if (cmd == TUNGETFEATURES) {
1270 /* Currently this just means: "what IFF flags are valid?".
1271 * This is needed because we never checked for invalid flags on
1272 * TUNSETIFF. */
1273 return put_user(IFF_TUN | IFF_TAP | IFF_NO_PI | IFF_ONE_QUEUE |
1274 IFF_VNET_HDR,
1275 (unsigned int __user*)argp);
1276 }
1277
1278 rtnl_lock();
1279
1280 tun = __tun_get(tfile);
1281 if (cmd == TUNSETIFF && !tun) {
1282 ifr.ifr_name[IFNAMSIZ-1] = '\0';
1283
1284 ret = tun_set_iff(tfile->net, file, &ifr);
1285
1286 if (ret)
1287 goto unlock;
1288
1289 if (copy_to_user(argp, &ifr, ifreq_len))
1290 ret = -EFAULT;
1291 goto unlock;
1292 }
1293
1294 ret = -EBADFD;
1295 if (!tun)
1296 goto unlock;
1297
1298 tun_debug(KERN_INFO, tun, "tun_chr_ioctl cmd %d\n", cmd);
1299
1300 ret = 0;
1301 switch (cmd) {
1302 case TUNGETIFF:
1303 ret = tun_get_iff(current->nsproxy->net_ns, tun, &ifr);
1304 if (ret)
1305 break;
1306
1307 if (copy_to_user(argp, &ifr, ifreq_len))
1308 ret = -EFAULT;
1309 break;
1310
1311 case TUNSETNOCSUM:
1312 /* Disable/Enable checksum */
1313
1314 /* [unimplemented] */
1315 tun_debug(KERN_INFO, tun, "ignored: set checksum %s\n",
1316 arg ? "disabled" : "enabled");
1317 break;
1318
1319 case TUNSETPERSIST:
1320 /* Disable/Enable persist mode */
1321 if (arg)
1322 tun->flags |= TUN_PERSIST;
1323 else
1324 tun->flags &= ~TUN_PERSIST;
1325
1326 tun_debug(KERN_INFO, tun, "persist %s\n",
1327 arg ? "enabled" : "disabled");
1328 break;
1329
1330 case TUNSETOWNER:
1331 /* Set owner of the device */
1332 tun->owner = (uid_t) arg;
1333
1334 tun_debug(KERN_INFO, tun, "owner set to %d\n", tun->owner);
1335 break;
1336
1337 case TUNSETGROUP:
1338 /* Set group of the device */
1339 tun->group= (gid_t) arg;
1340
1341 tun_debug(KERN_INFO, tun, "group set to %d\n", tun->group);
1342 break;
1343
1344 case TUNSETLINK:
1345 /* Only allow setting the type when the interface is down */
1346 if (tun->dev->flags & IFF_UP) {
1347 tun_debug(KERN_INFO, tun,
1348 "Linktype set failed because interface is up\n");
1349 ret = -EBUSY;
1350 } else {
1351 tun->dev->type = (int) arg;
1352 tun_debug(KERN_INFO, tun, "linktype set to %d\n",
1353 tun->dev->type);
1354 ret = 0;
1355 }
1356 break;
1357
1358 #ifdef TUN_DEBUG
1359 case TUNSETDEBUG:
1360 tun->debug = arg;
1361 break;
1362 #endif
1363 case TUNSETOFFLOAD:
1364 ret = set_offload(tun, arg);
1365 break;
1366
1367 case TUNSETTXFILTER:
1368 /* Can be set only for TAPs */
1369 ret = -EINVAL;
1370 if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV)
1371 break;
1372 ret = update_filter(&tun->txflt, (void __user *)arg);
1373 break;
1374
1375 case SIOCGIFHWADDR:
1376 /* Get hw address */
1377 memcpy(ifr.ifr_hwaddr.sa_data, tun->dev->dev_addr, ETH_ALEN);
1378 ifr.ifr_hwaddr.sa_family = tun->dev->type;
1379 if (copy_to_user(argp, &ifr, ifreq_len))
1380 ret = -EFAULT;
1381 break;
1382
1383 case SIOCSIFHWADDR:
1384 /* Set hw address */
1385 tun_debug(KERN_DEBUG, tun, "set hw address: %pM\n",
1386 ifr.ifr_hwaddr.sa_data);
1387
1388 ret = dev_set_mac_address(tun->dev, &ifr.ifr_hwaddr);
1389 break;
1390
1391 case TUNGETSNDBUF:
1392 sndbuf = tun->socket.sk->sk_sndbuf;
1393 if (copy_to_user(argp, &sndbuf, sizeof(sndbuf)))
1394 ret = -EFAULT;
1395 break;
1396
1397 case TUNSETSNDBUF:
1398 if (copy_from_user(&sndbuf, argp, sizeof(sndbuf))) {
1399 ret = -EFAULT;
1400 break;
1401 }
1402
1403 tun->socket.sk->sk_sndbuf = sndbuf;
1404 break;
1405
1406 case TUNGETVNETHDRSZ:
1407 vnet_hdr_sz = tun->vnet_hdr_sz;
1408 if (copy_to_user(argp, &vnet_hdr_sz, sizeof(vnet_hdr_sz)))
1409 ret = -EFAULT;
1410 break;
1411
1412 case TUNSETVNETHDRSZ:
1413 if (copy_from_user(&vnet_hdr_sz, argp, sizeof(vnet_hdr_sz))) {
1414 ret = -EFAULT;
1415 break;
1416 }
1417 if (vnet_hdr_sz < (int)sizeof(struct virtio_net_hdr)) {
1418 ret = -EINVAL;
1419 break;
1420 }
1421
1422 tun->vnet_hdr_sz = vnet_hdr_sz;
1423 break;
1424
1425 case TUNATTACHFILTER:
1426 /* Can be set only for TAPs */
1427 ret = -EINVAL;
1428 if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV)
1429 break;
1430 ret = -EFAULT;
1431 if (copy_from_user(&fprog, argp, sizeof(fprog)))
1432 break;
1433
1434 ret = sk_attach_filter(&fprog, tun->socket.sk);
1435 break;
1436
1437 case TUNDETACHFILTER:
1438 /* Can be set only for TAPs */
1439 ret = -EINVAL;
1440 if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV)
1441 break;
1442 ret = sk_detach_filter(tun->socket.sk);
1443 break;
1444
1445 default:
1446 ret = -EINVAL;
1447 break;
1448 }
1449
1450 unlock:
1451 rtnl_unlock();
1452 if (tun)
1453 tun_put(tun);
1454 return ret;
1455 }
1456
1457 static long tun_chr_ioctl(struct file *file,
1458 unsigned int cmd, unsigned long arg)
1459 {
1460 return __tun_chr_ioctl(file, cmd, arg, sizeof (struct ifreq));
1461 }
1462
1463 #ifdef CONFIG_COMPAT
1464 static long tun_chr_compat_ioctl(struct file *file,
1465 unsigned int cmd, unsigned long arg)
1466 {
1467 switch (cmd) {
1468 case TUNSETIFF:
1469 case TUNGETIFF:
1470 case TUNSETTXFILTER:
1471 case TUNGETSNDBUF:
1472 case TUNSETSNDBUF:
1473 case SIOCGIFHWADDR:
1474 case SIOCSIFHWADDR:
1475 arg = (unsigned long)compat_ptr(arg);
1476 break;
1477 default:
1478 arg = (compat_ulong_t)arg;
1479 break;
1480 }
1481
1482 /*
1483 * compat_ifreq is shorter than ifreq, so we must not access beyond
1484 * the end of that structure. All fields that are used in this
1485 * driver are compatible though, we don't need to convert the
1486 * contents.
1487 */
1488 return __tun_chr_ioctl(file, cmd, arg, sizeof(struct compat_ifreq));
1489 }
1490 #endif /* CONFIG_COMPAT */
1491
1492 static int tun_chr_fasync(int fd, struct file *file, int on)
1493 {
1494 struct tun_struct *tun = tun_get(file);
1495 int ret;
1496
1497 if (!tun)
1498 return -EBADFD;
1499
1500 tun_debug(KERN_INFO, tun, "tun_chr_fasync %d\n", on);
1501
1502 if ((ret = fasync_helper(fd, file, on, &tun->fasync)) < 0)
1503 goto out;
1504
1505 if (on) {
1506 ret = __f_setown(file, task_pid(current), PIDTYPE_PID, 0);
1507 if (ret)
1508 goto out;
1509 tun->flags |= TUN_FASYNC;
1510 } else
1511 tun->flags &= ~TUN_FASYNC;
1512 ret = 0;
1513 out:
1514 tun_put(tun);
1515 return ret;
1516 }
1517
1518 static int tun_chr_open(struct inode *inode, struct file * file)
1519 {
1520 struct tun_file *tfile;
1521
1522 DBG1(KERN_INFO, "tunX: tun_chr_open\n");
1523
1524 tfile = kmalloc(sizeof(*tfile), GFP_KERNEL);
1525 if (!tfile)
1526 return -ENOMEM;
1527 atomic_set(&tfile->count, 0);
1528 tfile->tun = NULL;
1529 tfile->net = get_net(current->nsproxy->net_ns);
1530 file->private_data = tfile;
1531 return 0;
1532 }
1533
1534 static int tun_chr_close(struct inode *inode, struct file *file)
1535 {
1536 struct tun_file *tfile = file->private_data;
1537 struct tun_struct *tun;
1538
1539 tun = __tun_get(tfile);
1540 if (tun) {
1541 struct net_device *dev = tun->dev;
1542
1543 tun_debug(KERN_INFO, tun, "tun_chr_close\n");
1544
1545 __tun_detach(tun);
1546
1547 /* If desirable, unregister the netdevice. */
1548 if (!(tun->flags & TUN_PERSIST)) {
1549 rtnl_lock();
1550 if (dev->reg_state == NETREG_REGISTERED)
1551 unregister_netdevice(dev);
1552 rtnl_unlock();
1553 }
1554 }
1555
1556 tun = tfile->tun;
1557 if (tun)
1558 sock_put(tun->socket.sk);
1559
1560 put_net(tfile->net);
1561 kfree(tfile);
1562
1563 return 0;
1564 }
1565
1566 static const struct file_operations tun_fops = {
1567 .owner = THIS_MODULE,
1568 .llseek = no_llseek,
1569 .read = do_sync_read,
1570 .aio_read = tun_chr_aio_read,
1571 .write = do_sync_write,
1572 .aio_write = tun_chr_aio_write,
1573 .poll = tun_chr_poll,
1574 .unlocked_ioctl = tun_chr_ioctl,
1575 #ifdef CONFIG_COMPAT
1576 .compat_ioctl = tun_chr_compat_ioctl,
1577 #endif
1578 .open = tun_chr_open,
1579 .release = tun_chr_close,
1580 .fasync = tun_chr_fasync
1581 };
1582
1583 static struct miscdevice tun_miscdev = {
1584 .minor = TUN_MINOR,
1585 .name = "tun",
1586 .nodename = "net/tun",
1587 .fops = &tun_fops,
1588 };
1589
1590 /* ethtool interface */
1591
1592 static int tun_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1593 {
1594 cmd->supported = 0;
1595 cmd->advertising = 0;
1596 ethtool_cmd_speed_set(cmd, SPEED_10);
1597 cmd->duplex = DUPLEX_FULL;
1598 cmd->port = PORT_TP;
1599 cmd->phy_address = 0;
1600 cmd->transceiver = XCVR_INTERNAL;
1601 cmd->autoneg = AUTONEG_DISABLE;
1602 cmd->maxtxpkt = 0;
1603 cmd->maxrxpkt = 0;
1604 return 0;
1605 }
1606
1607 static void tun_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1608 {
1609 struct tun_struct *tun = netdev_priv(dev);
1610
1611 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1612 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1613
1614 switch (tun->flags & TUN_TYPE_MASK) {
1615 case TUN_TUN_DEV:
1616 strlcpy(info->bus_info, "tun", sizeof(info->bus_info));
1617 break;
1618 case TUN_TAP_DEV:
1619 strlcpy(info->bus_info, "tap", sizeof(info->bus_info));
1620 break;
1621 }
1622 }
1623
1624 static u32 tun_get_msglevel(struct net_device *dev)
1625 {
1626 #ifdef TUN_DEBUG
1627 struct tun_struct *tun = netdev_priv(dev);
1628 return tun->debug;
1629 #else
1630 return -EOPNOTSUPP;
1631 #endif
1632 }
1633
1634 static void tun_set_msglevel(struct net_device *dev, u32 value)
1635 {
1636 #ifdef TUN_DEBUG
1637 struct tun_struct *tun = netdev_priv(dev);
1638 tun->debug = value;
1639 #endif
1640 }
1641
1642 static const struct ethtool_ops tun_ethtool_ops = {
1643 .get_settings = tun_get_settings,
1644 .get_drvinfo = tun_get_drvinfo,
1645 .get_msglevel = tun_get_msglevel,
1646 .set_msglevel = tun_set_msglevel,
1647 .get_link = ethtool_op_get_link,
1648 };
1649
1650
1651 static int __init tun_init(void)
1652 {
1653 int ret = 0;
1654
1655 pr_info("%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
1656 pr_info("%s\n", DRV_COPYRIGHT);
1657
1658 ret = rtnl_link_register(&tun_link_ops);
1659 if (ret) {
1660 pr_err("Can't register link_ops\n");
1661 goto err_linkops;
1662 }
1663
1664 ret = misc_register(&tun_miscdev);
1665 if (ret) {
1666 pr_err("Can't register misc device %d\n", TUN_MINOR);
1667 goto err_misc;
1668 }
1669 return 0;
1670 err_misc:
1671 rtnl_link_unregister(&tun_link_ops);
1672 err_linkops:
1673 return ret;
1674 }
1675
1676 static void tun_cleanup(void)
1677 {
1678 misc_deregister(&tun_miscdev);
1679 rtnl_link_unregister(&tun_link_ops);
1680 }
1681
1682 /* Get an underlying socket object from tun file. Returns error unless file is
1683 * attached to a device. The returned object works like a packet socket, it
1684 * can be used for sock_sendmsg/sock_recvmsg. The caller is responsible for
1685 * holding a reference to the file for as long as the socket is in use. */
1686 struct socket *tun_get_socket(struct file *file)
1687 {
1688 struct tun_struct *tun;
1689 if (file->f_op != &tun_fops)
1690 return ERR_PTR(-EINVAL);
1691 tun = tun_get(file);
1692 if (!tun)
1693 return ERR_PTR(-EBADFD);
1694 tun_put(tun);
1695 return &tun->socket;
1696 }
1697 EXPORT_SYMBOL_GPL(tun_get_socket);
1698
1699 module_init(tun_init);
1700 module_exit(tun_cleanup);
1701 MODULE_DESCRIPTION(DRV_DESCRIPTION);
1702 MODULE_AUTHOR(DRV_COPYRIGHT);
1703 MODULE_LICENSE("GPL");
1704 MODULE_ALIAS_MISCDEV(TUN_MINOR);
1705 MODULE_ALIAS("devname:net/tun");
Linux with added FPC-III support