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 * Mark Smith <markzzzsmith@yahoo.com.au> 22 * Use random_ether_addr() for tap MAC address. 23 * 24 * Harald Roelle <harald.roelle@ifi.lmu.de> 2004/04/20 25 * Fixes in packet dropping, queue length setting and queue wakeup. 26 * Increased default tx queue length. 27 * Added ethtool API. 28 * Minor cleanups 29 * 30 * Daniel Podlejski <underley@underley.eu.org> 31 * Modifications for 2.3.99-pre5 kernel. 32 */ 33 34 #define DRV_NAME "tun" 35 #define DRV_VERSION "1.6" 36 #define DRV_DESCRIPTION "Universal TUN/TAP device driver" 37 #define DRV_COPYRIGHT "(C) 1999-2004 Max Krasnyansky <maxk@qualcomm.com>" 38 39 #include <linux/config.h> 40 #include <linux/module.h> 41 #include <linux/errno.h> 42 #include <linux/kernel.h> 43 #include <linux/major.h> 44 #include <linux/slab.h> 45 #include <linux/poll.h> 46 #include <linux/fcntl.h> 47 #include <linux/init.h> 48 #include <linux/skbuff.h> 49 #include <linux/netdevice.h> 50 #include <linux/etherdevice.h> 51 #include <linux/miscdevice.h> 52 #include <linux/ethtool.h> 53 #include <linux/rtnetlink.h> 54 #include <linux/if.h> 55 #include <linux/if_arp.h> 56 #include <linux/if_ether.h> 57 #include <linux/if_tun.h> 58 #include <linux/crc32.h> 59 60 #include <asm/system.h> 61 #include <asm/uaccess.h> 62 63 #ifdef TUN_DEBUG 64 static int debug; 65 #endif 66 67 /* Network device part of the driver */ 68 69 static LIST_HEAD(tun_dev_list); 70 static struct ethtool_ops tun_ethtool_ops; 71 72 /* Net device open. */ 73 static int tun_net_open(struct net_device *dev) 74 { 75 netif_start_queue(dev); 76 return 0; 77 } 78 79 /* Net device close. */ 80 static int tun_net_close(struct net_device *dev) 81 { 82 netif_stop_queue(dev); 83 return 0; 84 } 85 86 /* Net device start xmit */ 87 static int tun_net_xmit(struct sk_buff *skb, struct net_device *dev) 88 { 89 struct tun_struct *tun = netdev_priv(dev); 90 91 DBG(KERN_INFO "%s: tun_net_xmit %d\n", tun->dev->name, skb->len); 92 93 /* Drop packet if interface is not attached */ 94 if (!tun->attached) 95 goto drop; 96 97 /* Packet dropping */ 98 if (skb_queue_len(&tun->readq) >= dev->tx_queue_len) { 99 if (!(tun->flags & TUN_ONE_QUEUE)) { 100 /* Normal queueing mode. */ 101 /* Packet scheduler handles dropping of further packets. */ 102 netif_stop_queue(dev); 103 104 /* We won't see all dropped packets individually, so overrun 105 * error is more appropriate. */ 106 tun->stats.tx_fifo_errors++; 107 } else { 108 /* Single queue mode. 109 * Driver handles dropping of all packets itself. */ 110 goto drop; 111 } 112 } 113 114 /* Queue packet */ 115 skb_queue_tail(&tun->readq, skb); 116 dev->trans_start = jiffies; 117 118 /* Notify and wake up reader process */ 119 if (tun->flags & TUN_FASYNC) 120 kill_fasync(&tun->fasync, SIGIO, POLL_IN); 121 wake_up_interruptible(&tun->read_wait); 122 return 0; 123 124 drop: 125 tun->stats.tx_dropped++; 126 kfree_skb(skb); 127 return 0; 128 } 129 130 /** Add the specified Ethernet address to this multicast filter. */ 131 static void 132 add_multi(u32* filter, const u8* addr) 133 { 134 int bit_nr = ether_crc(ETH_ALEN, addr) >> 26; 135 filter[bit_nr >> 5] |= 1 << (bit_nr & 31); 136 } 137 138 /** Remove the specified Ethernet addres from this multicast filter. */ 139 static void 140 del_multi(u32* filter, const u8* addr) 141 { 142 int bit_nr = ether_crc(ETH_ALEN, addr) >> 26; 143 filter[bit_nr >> 5] &= ~(1 << (bit_nr & 31)); 144 } 145 146 /** Update the list of multicast groups to which the network device belongs. 147 * This list is used to filter packets being sent from the character device to 148 * the network device. */ 149 static void 150 tun_net_mclist(struct net_device *dev) 151 { 152 struct tun_struct *tun = netdev_priv(dev); 153 const struct dev_mc_list *mclist; 154 int i; 155 DBG(KERN_DEBUG "%s: tun_net_mclist: mc_count %d\n", 156 dev->name, dev->mc_count); 157 memset(tun->chr_filter, 0, sizeof tun->chr_filter); 158 for (i = 0, mclist = dev->mc_list; i < dev->mc_count && mclist != NULL; 159 i++, mclist = mclist->next) { 160 add_multi(tun->net_filter, mclist->dmi_addr); 161 DBG(KERN_DEBUG "%s: tun_net_mclist: %x:%x:%x:%x:%x:%x\n", 162 dev->name, 163 mclist->dmi_addr[0], mclist->dmi_addr[1], mclist->dmi_addr[2], 164 mclist->dmi_addr[3], mclist->dmi_addr[4], mclist->dmi_addr[5]); 165 } 166 } 167 168 static struct net_device_stats *tun_net_stats(struct net_device *dev) 169 { 170 struct tun_struct *tun = netdev_priv(dev); 171 return &tun->stats; 172 } 173 174 /* Initialize net device. */ 175 static void tun_net_init(struct net_device *dev) 176 { 177 struct tun_struct *tun = netdev_priv(dev); 178 179 switch (tun->flags & TUN_TYPE_MASK) { 180 case TUN_TUN_DEV: 181 /* Point-to-Point TUN Device */ 182 dev->hard_header_len = 0; 183 dev->addr_len = 0; 184 dev->mtu = 1500; 185 186 /* Zero header length */ 187 dev->type = ARPHRD_NONE; 188 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; 189 dev->tx_queue_len = TUN_READQ_SIZE; /* We prefer our own queue length */ 190 break; 191 192 case TUN_TAP_DEV: 193 /* Ethernet TAP Device */ 194 dev->set_multicast_list = tun_net_mclist; 195 196 ether_setup(dev); 197 random_ether_addr(dev->dev_addr); 198 dev->tx_queue_len = TUN_READQ_SIZE; /* We prefer our own queue length */ 199 break; 200 } 201 } 202 203 /* Character device part */ 204 205 /* Poll */ 206 static unsigned int tun_chr_poll(struct file *file, poll_table * wait) 207 { 208 struct tun_struct *tun = file->private_data; 209 unsigned int mask = POLLOUT | POLLWRNORM; 210 211 if (!tun) 212 return -EBADFD; 213 214 DBG(KERN_INFO "%s: tun_chr_poll\n", tun->dev->name); 215 216 poll_wait(file, &tun->read_wait, wait); 217 218 if (skb_queue_len(&tun->readq)) 219 mask |= POLLIN | POLLRDNORM; 220 221 return mask; 222 } 223 224 /* Get packet from user space buffer */ 225 static __inline__ ssize_t tun_get_user(struct tun_struct *tun, struct iovec *iv, size_t count) 226 { 227 struct tun_pi pi = { 0, __constant_htons(ETH_P_IP) }; 228 struct sk_buff *skb; 229 size_t len = count, align = 0; 230 231 if (!(tun->flags & TUN_NO_PI)) { 232 if ((len -= sizeof(pi)) > count) 233 return -EINVAL; 234 235 if(memcpy_fromiovec((void *)&pi, iv, sizeof(pi))) 236 return -EFAULT; 237 } 238 239 if ((tun->flags & TUN_TYPE_MASK) == TUN_TAP_DEV) 240 align = NET_IP_ALIGN; 241 242 if (!(skb = alloc_skb(len + align, GFP_KERNEL))) { 243 tun->stats.rx_dropped++; 244 return -ENOMEM; 245 } 246 247 if (align) 248 skb_reserve(skb, align); 249 if (memcpy_fromiovec(skb_put(skb, len), iv, len)) 250 return -EFAULT; 251 252 skb->dev = tun->dev; 253 switch (tun->flags & TUN_TYPE_MASK) { 254 case TUN_TUN_DEV: 255 skb->mac.raw = skb->data; 256 skb->protocol = pi.proto; 257 break; 258 case TUN_TAP_DEV: 259 skb->protocol = eth_type_trans(skb, tun->dev); 260 break; 261 }; 262 263 if (tun->flags & TUN_NOCHECKSUM) 264 skb->ip_summed = CHECKSUM_UNNECESSARY; 265 266 netif_rx_ni(skb); 267 tun->dev->last_rx = jiffies; 268 269 tun->stats.rx_packets++; 270 tun->stats.rx_bytes += len; 271 272 return count; 273 } 274 275 static inline size_t iov_total(const struct iovec *iv, unsigned long count) 276 { 277 unsigned long i; 278 size_t len; 279 280 for (i = 0, len = 0; i < count; i++) 281 len += iv[i].iov_len; 282 283 return len; 284 } 285 286 /* Writev */ 287 static ssize_t tun_chr_writev(struct file * file, const struct iovec *iv, 288 unsigned long count, loff_t *pos) 289 { 290 struct tun_struct *tun = file->private_data; 291 292 if (!tun) 293 return -EBADFD; 294 295 DBG(KERN_INFO "%s: tun_chr_write %ld\n", tun->dev->name, count); 296 297 return tun_get_user(tun, (struct iovec *) iv, iov_total(iv, count)); 298 } 299 300 /* Write */ 301 static ssize_t tun_chr_write(struct file * file, const char __user * buf, 302 size_t count, loff_t *pos) 303 { 304 struct iovec iv = { (void __user *) buf, count }; 305 return tun_chr_writev(file, &iv, 1, pos); 306 } 307 308 /* Put packet to the user space buffer */ 309 static __inline__ ssize_t tun_put_user(struct tun_struct *tun, 310 struct sk_buff *skb, 311 struct iovec *iv, int len) 312 { 313 struct tun_pi pi = { 0, skb->protocol }; 314 ssize_t total = 0; 315 316 if (!(tun->flags & TUN_NO_PI)) { 317 if ((len -= sizeof(pi)) < 0) 318 return -EINVAL; 319 320 if (len < skb->len) { 321 /* Packet will be striped */ 322 pi.flags |= TUN_PKT_STRIP; 323 } 324 325 if (memcpy_toiovec(iv, (void *) &pi, sizeof(pi))) 326 return -EFAULT; 327 total += sizeof(pi); 328 } 329 330 len = min_t(int, skb->len, len); 331 332 skb_copy_datagram_iovec(skb, 0, iv, len); 333 total += len; 334 335 tun->stats.tx_packets++; 336 tun->stats.tx_bytes += len; 337 338 return total; 339 } 340 341 /* Readv */ 342 static ssize_t tun_chr_readv(struct file *file, const struct iovec *iv, 343 unsigned long count, loff_t *pos) 344 { 345 struct tun_struct *tun = file->private_data; 346 DECLARE_WAITQUEUE(wait, current); 347 struct sk_buff *skb; 348 ssize_t len, ret = 0; 349 350 if (!tun) 351 return -EBADFD; 352 353 DBG(KERN_INFO "%s: tun_chr_read\n", tun->dev->name); 354 355 len = iov_total(iv, count); 356 if (len < 0) 357 return -EINVAL; 358 359 add_wait_queue(&tun->read_wait, &wait); 360 while (len) { 361 const u8 ones[ ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 362 u8 addr[ ETH_ALEN]; 363 int bit_nr; 364 365 current->state = TASK_INTERRUPTIBLE; 366 367 /* Read frames from the queue */ 368 if (!(skb=skb_dequeue(&tun->readq))) { 369 if (file->f_flags & O_NONBLOCK) { 370 ret = -EAGAIN; 371 break; 372 } 373 if (signal_pending(current)) { 374 ret = -ERESTARTSYS; 375 break; 376 } 377 378 /* Nothing to read, let's sleep */ 379 schedule(); 380 continue; 381 } 382 netif_wake_queue(tun->dev); 383 384 /** Decide whether to accept this packet. This code is designed to 385 * behave identically to an Ethernet interface. Accept the packet if 386 * - we are promiscuous. 387 * - the packet is addressed to us. 388 * - the packet is broadcast. 389 * - the packet is multicast and 390 * - we are multicast promiscous. 391 * - we belong to the multicast group. 392 */ 393 memcpy(addr, skb->data, 394 min_t(size_t, sizeof addr, skb->len)); 395 bit_nr = ether_crc(sizeof addr, addr) >> 26; 396 if ((tun->if_flags & IFF_PROMISC) || 397 memcmp(addr, tun->dev_addr, sizeof addr) == 0 || 398 memcmp(addr, ones, sizeof addr) == 0 || 399 (((addr[0] == 1 && addr[1] == 0 && addr[2] == 0x5e) || 400 (addr[0] == 0x33 && addr[1] == 0x33)) && 401 ((tun->if_flags & IFF_ALLMULTI) || 402 (tun->chr_filter[bit_nr >> 5] & (1 << (bit_nr & 31)))))) { 403 DBG(KERN_DEBUG "%s: tun_chr_readv: accepted: %x:%x:%x:%x:%x:%x\n", 404 tun->dev->name, addr[0], addr[1], addr[2], 405 addr[3], addr[4], addr[5]); 406 ret = tun_put_user(tun, skb, (struct iovec *) iv, len); 407 kfree_skb(skb); 408 break; 409 } else { 410 DBG(KERN_DEBUG "%s: tun_chr_readv: rejected: %x:%x:%x:%x:%x:%x\n", 411 tun->dev->name, addr[0], addr[1], addr[2], 412 addr[3], addr[4], addr[5]); 413 kfree_skb(skb); 414 continue; 415 } 416 } 417 418 current->state = TASK_RUNNING; 419 remove_wait_queue(&tun->read_wait, &wait); 420 421 return ret; 422 } 423 424 /* Read */ 425 static ssize_t tun_chr_read(struct file * file, char __user * buf, 426 size_t count, loff_t *pos) 427 { 428 struct iovec iv = { buf, count }; 429 return tun_chr_readv(file, &iv, 1, pos); 430 } 431 432 static void tun_setup(struct net_device *dev) 433 { 434 struct tun_struct *tun = netdev_priv(dev); 435 436 skb_queue_head_init(&tun->readq); 437 init_waitqueue_head(&tun->read_wait); 438 439 tun->owner = -1; 440 441 SET_MODULE_OWNER(dev); 442 dev->open = tun_net_open; 443 dev->hard_start_xmit = tun_net_xmit; 444 dev->stop = tun_net_close; 445 dev->get_stats = tun_net_stats; 446 dev->ethtool_ops = &tun_ethtool_ops; 447 dev->destructor = free_netdev; 448 } 449 450 static struct tun_struct *tun_get_by_name(const char *name) 451 { 452 struct tun_struct *tun; 453 454 ASSERT_RTNL(); 455 list_for_each_entry(tun, &tun_dev_list, list) { 456 if (!strncmp(tun->dev->name, name, IFNAMSIZ)) 457 return tun; 458 } 459 460 return NULL; 461 } 462 463 static int tun_set_iff(struct file *file, struct ifreq *ifr) 464 { 465 struct tun_struct *tun; 466 struct net_device *dev; 467 int err; 468 469 tun = tun_get_by_name(ifr->ifr_name); 470 if (tun) { 471 if (tun->attached) 472 return -EBUSY; 473 474 /* Check permissions */ 475 if (tun->owner != -1 && 476 current->euid != tun->owner && !capable(CAP_NET_ADMIN)) 477 return -EPERM; 478 } 479 else if (__dev_get_by_name(ifr->ifr_name)) 480 return -EINVAL; 481 else { 482 char *name; 483 unsigned long flags = 0; 484 485 err = -EINVAL; 486 487 /* Set dev type */ 488 if (ifr->ifr_flags & IFF_TUN) { 489 /* TUN device */ 490 flags |= TUN_TUN_DEV; 491 name = "tun%d"; 492 } else if (ifr->ifr_flags & IFF_TAP) { 493 /* TAP device */ 494 flags |= TUN_TAP_DEV; 495 name = "tap%d"; 496 } else 497 goto failed; 498 499 if (*ifr->ifr_name) 500 name = ifr->ifr_name; 501 502 dev = alloc_netdev(sizeof(struct tun_struct), name, 503 tun_setup); 504 if (!dev) 505 return -ENOMEM; 506 507 tun = netdev_priv(dev); 508 tun->dev = dev; 509 tun->flags = flags; 510 /* Be promiscuous by default to maintain previous behaviour. */ 511 tun->if_flags = IFF_PROMISC; 512 /* Generate random Ethernet address. */ 513 *(u16 *)tun->dev_addr = htons(0x00FF); 514 get_random_bytes(tun->dev_addr + sizeof(u16), 4); 515 memset(tun->chr_filter, 0, sizeof tun->chr_filter); 516 517 tun_net_init(dev); 518 519 if (strchr(dev->name, '%')) { 520 err = dev_alloc_name(dev, dev->name); 521 if (err < 0) 522 goto err_free_dev; 523 } 524 525 err = register_netdevice(tun->dev); 526 if (err < 0) 527 goto err_free_dev; 528 529 list_add(&tun->list, &tun_dev_list); 530 } 531 532 DBG(KERN_INFO "%s: tun_set_iff\n", tun->dev->name); 533 534 if (ifr->ifr_flags & IFF_NO_PI) 535 tun->flags |= TUN_NO_PI; 536 537 if (ifr->ifr_flags & IFF_ONE_QUEUE) 538 tun->flags |= TUN_ONE_QUEUE; 539 540 file->private_data = tun; 541 tun->attached = 1; 542 543 strcpy(ifr->ifr_name, tun->dev->name); 544 return 0; 545 546 err_free_dev: 547 free_netdev(dev); 548 failed: 549 return err; 550 } 551 552 static int tun_chr_ioctl(struct inode *inode, struct file *file, 553 unsigned int cmd, unsigned long arg) 554 { 555 struct tun_struct *tun = file->private_data; 556 void __user* argp = (void __user*)arg; 557 struct ifreq ifr; 558 559 if (cmd == TUNSETIFF || _IOC_TYPE(cmd) == 0x89) 560 if (copy_from_user(&ifr, argp, sizeof ifr)) 561 return -EFAULT; 562 563 if (cmd == TUNSETIFF && !tun) { 564 int err; 565 566 ifr.ifr_name[IFNAMSIZ-1] = '\0'; 567 568 rtnl_lock(); 569 err = tun_set_iff(file, &ifr); 570 rtnl_unlock(); 571 572 if (err) 573 return err; 574 575 if (copy_to_user(argp, &ifr, sizeof(ifr))) 576 return -EFAULT; 577 return 0; 578 } 579 580 if (!tun) 581 return -EBADFD; 582 583 DBG(KERN_INFO "%s: tun_chr_ioctl cmd %d\n", tun->dev->name, cmd); 584 585 switch (cmd) { 586 case TUNSETNOCSUM: 587 /* Disable/Enable checksum */ 588 if (arg) 589 tun->flags |= TUN_NOCHECKSUM; 590 else 591 tun->flags &= ~TUN_NOCHECKSUM; 592 593 DBG(KERN_INFO "%s: checksum %s\n", 594 tun->dev->name, arg ? "disabled" : "enabled"); 595 break; 596 597 case TUNSETPERSIST: 598 /* Disable/Enable persist mode */ 599 if (arg) 600 tun->flags |= TUN_PERSIST; 601 else 602 tun->flags &= ~TUN_PERSIST; 603 604 DBG(KERN_INFO "%s: persist %s\n", 605 tun->dev->name, arg ? "disabled" : "enabled"); 606 break; 607 608 case TUNSETOWNER: 609 /* Set owner of the device */ 610 tun->owner = (uid_t) arg; 611 612 DBG(KERN_INFO "%s: owner set to %d\n", tun->dev->name, tun->owner); 613 break; 614 615 #ifdef TUN_DEBUG 616 case TUNSETDEBUG: 617 tun->debug = arg; 618 break; 619 #endif 620 621 case SIOCGIFFLAGS: 622 ifr.ifr_flags = tun->if_flags; 623 if (copy_to_user( argp, &ifr, sizeof ifr)) 624 return -EFAULT; 625 return 0; 626 627 case SIOCSIFFLAGS: 628 /** Set the character device's interface flags. Currently only 629 * IFF_PROMISC and IFF_ALLMULTI are used. */ 630 tun->if_flags = ifr.ifr_flags; 631 DBG(KERN_INFO "%s: interface flags 0x%lx\n", 632 tun->dev->name, tun->if_flags); 633 return 0; 634 635 case SIOCGIFHWADDR: 636 memcpy(ifr.ifr_hwaddr.sa_data, tun->dev_addr, 637 min(sizeof ifr.ifr_hwaddr.sa_data, sizeof tun->dev_addr)); 638 if (copy_to_user( argp, &ifr, sizeof ifr)) 639 return -EFAULT; 640 return 0; 641 642 case SIOCSIFHWADDR: 643 /** Set the character device's hardware address. This is used when 644 * filtering packets being sent from the network device to the character 645 * device. */ 646 memcpy(tun->dev_addr, ifr.ifr_hwaddr.sa_data, 647 min(sizeof ifr.ifr_hwaddr.sa_data, sizeof tun->dev_addr)); 648 DBG(KERN_DEBUG "%s: set hardware address: %x:%x:%x:%x:%x:%x\n", 649 tun->dev->name, 650 tun->dev_addr[0], tun->dev_addr[1], tun->dev_addr[2], 651 tun->dev_addr[3], tun->dev_addr[4], tun->dev_addr[5]); 652 return 0; 653 654 case SIOCADDMULTI: 655 /** Add the specified group to the character device's multicast filter 656 * list. */ 657 add_multi(tun->chr_filter, ifr.ifr_hwaddr.sa_data); 658 DBG(KERN_DEBUG "%s: add multi: %x:%x:%x:%x:%x:%x\n", 659 tun->dev->name, 660 (u8)ifr.ifr_hwaddr.sa_data[0], (u8)ifr.ifr_hwaddr.sa_data[1], 661 (u8)ifr.ifr_hwaddr.sa_data[2], (u8)ifr.ifr_hwaddr.sa_data[3], 662 (u8)ifr.ifr_hwaddr.sa_data[4], (u8)ifr.ifr_hwaddr.sa_data[5]); 663 return 0; 664 665 case SIOCDELMULTI: 666 /** Remove the specified group from the character device's multicast 667 * filter list. */ 668 del_multi(tun->chr_filter, ifr.ifr_hwaddr.sa_data); 669 DBG(KERN_DEBUG "%s: del multi: %x:%x:%x:%x:%x:%x\n", 670 tun->dev->name, 671 (u8)ifr.ifr_hwaddr.sa_data[0], (u8)ifr.ifr_hwaddr.sa_data[1], 672 (u8)ifr.ifr_hwaddr.sa_data[2], (u8)ifr.ifr_hwaddr.sa_data[3], 673 (u8)ifr.ifr_hwaddr.sa_data[4], (u8)ifr.ifr_hwaddr.sa_data[5]); 674 return 0; 675 676 default: 677 return -EINVAL; 678 }; 679 680 return 0; 681 } 682 683 static int tun_chr_fasync(int fd, struct file *file, int on) 684 { 685 struct tun_struct *tun = file->private_data; 686 int ret; 687 688 if (!tun) 689 return -EBADFD; 690 691 DBG(KERN_INFO "%s: tun_chr_fasync %d\n", tun->dev->name, on); 692 693 if ((ret = fasync_helper(fd, file, on, &tun->fasync)) < 0) 694 return ret; 695 696 if (on) { 697 ret = f_setown(file, current->pid, 0); 698 if (ret) 699 return ret; 700 tun->flags |= TUN_FASYNC; 701 } else 702 tun->flags &= ~TUN_FASYNC; 703 704 return 0; 705 } 706 707 static int tun_chr_open(struct inode *inode, struct file * file) 708 { 709 DBG1(KERN_INFO "tunX: tun_chr_open\n"); 710 file->private_data = NULL; 711 return 0; 712 } 713 714 static int tun_chr_close(struct inode *inode, struct file *file) 715 { 716 struct tun_struct *tun = file->private_data; 717 718 if (!tun) 719 return 0; 720 721 DBG(KERN_INFO "%s: tun_chr_close\n", tun->dev->name); 722 723 tun_chr_fasync(-1, file, 0); 724 725 rtnl_lock(); 726 727 /* Detach from net device */ 728 file->private_data = NULL; 729 tun->attached = 0; 730 731 /* Drop read queue */ 732 skb_queue_purge(&tun->readq); 733 734 if (!(tun->flags & TUN_PERSIST)) { 735 list_del(&tun->list); 736 unregister_netdevice(tun->dev); 737 } 738 739 rtnl_unlock(); 740 741 return 0; 742 } 743 744 static struct file_operations tun_fops = { 745 .owner = THIS_MODULE, 746 .llseek = no_llseek, 747 .read = tun_chr_read, 748 .readv = tun_chr_readv, 749 .write = tun_chr_write, 750 .writev = tun_chr_writev, 751 .poll = tun_chr_poll, 752 .ioctl = tun_chr_ioctl, 753 .open = tun_chr_open, 754 .release = tun_chr_close, 755 .fasync = tun_chr_fasync 756 }; 757 758 static struct miscdevice tun_miscdev = { 759 .minor = TUN_MINOR, 760 .name = "tun", 761 .fops = &tun_fops, 762 .devfs_name = "net/tun", 763 }; 764 765 /* ethtool interface */ 766 767 static int tun_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 768 { 769 cmd->supported = 0; 770 cmd->advertising = 0; 771 cmd->speed = SPEED_10; 772 cmd->duplex = DUPLEX_FULL; 773 cmd->port = PORT_TP; 774 cmd->phy_address = 0; 775 cmd->transceiver = XCVR_INTERNAL; 776 cmd->autoneg = AUTONEG_DISABLE; 777 cmd->maxtxpkt = 0; 778 cmd->maxrxpkt = 0; 779 return 0; 780 } 781 782 static void tun_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 783 { 784 struct tun_struct *tun = netdev_priv(dev); 785 786 strcpy(info->driver, DRV_NAME); 787 strcpy(info->version, DRV_VERSION); 788 strcpy(info->fw_version, "N/A"); 789 790 switch (tun->flags & TUN_TYPE_MASK) { 791 case TUN_TUN_DEV: 792 strcpy(info->bus_info, "tun"); 793 break; 794 case TUN_TAP_DEV: 795 strcpy(info->bus_info, "tap"); 796 break; 797 } 798 } 799 800 static u32 tun_get_msglevel(struct net_device *dev) 801 { 802 #ifdef TUN_DEBUG 803 struct tun_struct *tun = netdev_priv(dev); 804 return tun->debug; 805 #else 806 return -EOPNOTSUPP; 807 #endif 808 } 809 810 static void tun_set_msglevel(struct net_device *dev, u32 value) 811 { 812 #ifdef TUN_DEBUG 813 struct tun_struct *tun = netdev_priv(dev); 814 tun->debug = value; 815 #endif 816 } 817 818 static u32 tun_get_link(struct net_device *dev) 819 { 820 struct tun_struct *tun = netdev_priv(dev); 821 return tun->attached; 822 } 823 824 static u32 tun_get_rx_csum(struct net_device *dev) 825 { 826 struct tun_struct *tun = netdev_priv(dev); 827 return (tun->flags & TUN_NOCHECKSUM) == 0; 828 } 829 830 static int tun_set_rx_csum(struct net_device *dev, u32 data) 831 { 832 struct tun_struct *tun = netdev_priv(dev); 833 if (data) 834 tun->flags &= ~TUN_NOCHECKSUM; 835 else 836 tun->flags |= TUN_NOCHECKSUM; 837 return 0; 838 } 839 840 static struct ethtool_ops tun_ethtool_ops = { 841 .get_settings = tun_get_settings, 842 .get_drvinfo = tun_get_drvinfo, 843 .get_msglevel = tun_get_msglevel, 844 .set_msglevel = tun_set_msglevel, 845 .get_link = tun_get_link, 846 .get_rx_csum = tun_get_rx_csum, 847 .set_rx_csum = tun_set_rx_csum 848 }; 849 850 static int __init tun_init(void) 851 { 852 int ret = 0; 853 854 printk(KERN_INFO "tun: %s, %s\n", DRV_DESCRIPTION, DRV_VERSION); 855 printk(KERN_INFO "tun: %s\n", DRV_COPYRIGHT); 856 857 ret = misc_register(&tun_miscdev); 858 if (ret) 859 printk(KERN_ERR "tun: Can't register misc device %d\n", TUN_MINOR); 860 return ret; 861 } 862 863 static void tun_cleanup(void) 864 { 865 struct tun_struct *tun, *nxt; 866 867 misc_deregister(&tun_miscdev); 868 869 rtnl_lock(); 870 list_for_each_entry_safe(tun, nxt, &tun_dev_list, list) { 871 DBG(KERN_INFO "%s cleaned up\n", tun->dev->name); 872 unregister_netdevice(tun->dev); 873 } 874 rtnl_unlock(); 875 876 } 877 878 module_init(tun_init); 879 module_exit(tun_cleanup); 880 MODULE_DESCRIPTION(DRV_DESCRIPTION); 881 MODULE_AUTHOR(DRV_COPYRIGHT); 882 MODULE_LICENSE("GPL"); 883 MODULE_ALIAS_MISCDEV(TUN_MINOR); 884