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.1.1.1 2008/10/15 03:26:40 james26_jang Exp $ 16 */ 17 18/* 19 * Daniel Podlejski <underley@underley.eu.org> 20 * Modifications for 2.3.99-pre5 kernel. 21 */ 22 23#define TUN_VER "1.5" 24 25#include <linux/config.h> 26#include <linux/module.h> 27 28#include <linux/errno.h> 29#include <linux/kernel.h> 30#include <linux/major.h> 31#include <linux/sched.h> 32#include <linux/slab.h> 33#include <linux/poll.h> 34#include <linux/fcntl.h> 35#include <linux/init.h> 36#include <linux/random.h> 37 38#include <linux/skbuff.h> 39#include <linux/netdevice.h> 40#include <linux/etherdevice.h> 41#include <linux/miscdevice.h> 42#include <linux/rtnetlink.h> 43#include <linux/if.h> 44#include <linux/if_arp.h> 45#include <linux/if_ether.h> 46#include <linux/if_tun.h> 47 48#include <asm/system.h> 49#include <asm/uaccess.h> 50 51#ifdef TUN_DEBUG 52static int debug; 53#endif 54 55/* Network device part of the driver */ 56 57/* Net device open. */ 58static int tun_net_open(struct net_device *dev) 59{ 60 netif_start_queue(dev); 61 return 0; 62} 63 64/* Net device close. */ 65static int tun_net_close(struct net_device *dev) 66{ 67 netif_stop_queue(dev); 68 return 0; 69} 70 71/* Net device start xmit */ 72static int tun_net_xmit(struct sk_buff *skb, struct net_device *dev) 73{ 74 struct tun_struct *tun = (struct tun_struct *)dev->priv; 75 76 DBG(KERN_INFO "%s: tun_net_xmit %d\n", tun->name, skb->len); 77 78 /* Drop packet if interface is not attached */ 79 if (!tun->attached) 80 goto drop; 81 82 /* Queue packet */ 83 if (!(tun->flags & TUN_ONE_QUEUE)) { 84 /* Normal queueing mode. 85 * Packet scheduler handles dropping. */ 86 if (skb_queue_len(&tun->readq) >= TUN_READQ_SIZE) 87 netif_stop_queue(dev); 88 } else { 89 /* Single queue mode. 90 * Driver handles dropping itself. */ 91 if (skb_queue_len(&tun->readq) >= dev->tx_queue_len) 92 goto drop; 93 } 94 skb_queue_tail(&tun->readq, skb); 95 96 /* Notify and wake up reader process */ 97 if (tun->flags & TUN_FASYNC) 98 kill_fasync(&tun->fasync, SIGIO, POLL_IN); 99 wake_up_interruptible(&tun->read_wait); 100 return 0; 101 102drop: 103 tun->stats.tx_dropped++; 104 kfree_skb(skb); 105 return 0; 106} 107 108static void tun_net_mclist(struct net_device *dev) 109{ 110 /* Nothing to do for multicast filters. 111 * We always accept all frames. */ 112 return; 113} 114 115static struct net_device_stats *tun_net_stats(struct net_device *dev) 116{ 117 struct tun_struct *tun = (struct tun_struct *)dev->priv; 118 return &tun->stats; 119} 120 121/* Initialize net device. */ 122int tun_net_init(struct net_device *dev) 123{ 124 struct tun_struct *tun = (struct tun_struct *)dev->priv; 125 126 DBG(KERN_INFO "%s: tun_net_init\n", tun->name); 127 128 SET_MODULE_OWNER(dev); 129 dev->open = tun_net_open; 130 dev->hard_start_xmit = tun_net_xmit; 131 dev->stop = tun_net_close; 132 dev->get_stats = tun_net_stats; 133 134 switch (tun->flags & TUN_TYPE_MASK) { 135 case TUN_TUN_DEV: 136 /* Point-to-Point TUN Device */ 137 dev->hard_header_len = 0; 138 dev->addr_len = 0; 139 dev->mtu = 1500; 140 141 /* Type PPP seems most suitable */ 142 dev->type = ARPHRD_PPP; 143 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; 144 dev->tx_queue_len = 10; 145 break; 146 147 case TUN_TAP_DEV: 148 /* Ethernet TAP Device */ 149 dev->set_multicast_list = tun_net_mclist; 150 151 /* Generate random Ethernet address. */ 152 *(u16 *)dev->dev_addr = htons(0x00FF); 153 get_random_bytes(dev->dev_addr + sizeof(u16), 4); 154 155 ether_setup(dev); 156 break; 157 }; 158 159 return 0; 160} 161 162/* Character device part */ 163 164/* Poll */ 165static unsigned int tun_chr_poll(struct file *file, poll_table * wait) 166{ 167 struct tun_struct *tun = (struct tun_struct *)file->private_data; 168 unsigned int mask = POLLOUT | POLLWRNORM; 169 170 if (!tun) 171 return -EBADFD; 172 173 DBG(KERN_INFO "%s: tun_chr_poll\n", tun->name); 174 175 poll_wait(file, &tun->read_wait, wait); 176 177 if (skb_queue_len(&tun->readq)) 178 mask |= POLLIN | POLLRDNORM; 179 180 return mask; 181} 182 183/* Get packet from user space buffer(already verified) */ 184static __inline__ ssize_t tun_get_user(struct tun_struct *tun, struct iovec *iv, size_t count) 185{ 186 struct tun_pi pi = { 0, __constant_htons(ETH_P_IP) }; 187 struct sk_buff *skb; 188 size_t len = count; 189 190 if (!(tun->flags & TUN_NO_PI)) { 191 if ((len -= sizeof(pi)) < 0) 192 return -EINVAL; 193 194 memcpy_fromiovec((void *)&pi, iv, sizeof(pi)); 195 } 196 197 if (!(skb = alloc_skb(len + 2, GFP_KERNEL))) { 198 tun->stats.rx_dropped++; 199 return -ENOMEM; 200 } 201 202 skb_reserve(skb, 2); 203 memcpy_fromiovec(skb_put(skb, len), iv, len); 204 205 skb->dev = &tun->dev; 206 switch (tun->flags & TUN_TYPE_MASK) { 207 case TUN_TUN_DEV: 208 skb->mac.raw = skb->data; 209 skb->protocol = pi.proto; 210 break; 211 case TUN_TAP_DEV: 212 skb->protocol = eth_type_trans(skb, &tun->dev); 213 break; 214 }; 215 216 if (tun->flags & TUN_NOCHECKSUM) 217 skb->ip_summed = CHECKSUM_UNNECESSARY; 218 219 netif_rx_ni(skb); 220 221 tun->stats.rx_packets++; 222 tun->stats.rx_bytes += len; 223 224 return count; 225} 226 227/* Writev */ 228static ssize_t tun_chr_writev(struct file * file, const struct iovec *iv, 229 unsigned long count, loff_t *pos) 230{ 231 struct tun_struct *tun = (struct tun_struct *)file->private_data; 232 unsigned long i; 233 size_t len; 234 235 if (!tun) 236 return -EBADFD; 237 238 DBG(KERN_INFO "%s: tun_chr_write %d\n", tun->name, count); 239 240 for (i = 0, len = 0; i < count; i++) { 241 if (verify_area(VERIFY_READ, iv[i].iov_base, iv[i].iov_len)) 242 return -EFAULT; 243 len += iv[i].iov_len; 244 } 245 246 return tun_get_user(tun, (struct iovec *) iv, len); 247} 248 249/* Write */ 250static ssize_t tun_chr_write(struct file * file, const char * buf, 251 size_t count, loff_t *pos) 252{ 253 struct iovec iv = { (void *) buf, count }; 254 return tun_chr_writev(file, &iv, 1, pos); 255} 256 257/* Put packet to the user space buffer (already verified) */ 258static __inline__ ssize_t tun_put_user(struct tun_struct *tun, 259 struct sk_buff *skb, 260 struct iovec *iv, int len) 261{ 262 struct tun_pi pi = { 0, skb->protocol }; 263 ssize_t total = 0; 264 265 if (!(tun->flags & TUN_NO_PI)) { 266 if ((len -= sizeof(pi)) < 0) 267 return -EINVAL; 268 269 if (len < skb->len) { 270 /* Packet will be striped */ 271 pi.flags |= TUN_PKT_STRIP; 272 } 273 274 memcpy_toiovec(iv, (void *) &pi, sizeof(pi)); 275 total += sizeof(pi); 276 } 277 278 len = MIN(skb->len, len); 279 280 skb_copy_datagram_iovec(skb, 0, iv, len); 281 total += len; 282 283 tun->stats.tx_packets++; 284 tun->stats.tx_bytes += len; 285 286 return total; 287} 288 289/* Readv */ 290static ssize_t tun_chr_readv(struct file *file, const struct iovec *iv, 291 unsigned long count, loff_t *pos) 292{ 293 struct tun_struct *tun = (struct tun_struct *)file->private_data; 294 DECLARE_WAITQUEUE(wait, current); 295 struct sk_buff *skb; 296 ssize_t len, ret = 0; 297 unsigned long i; 298 299 if (!tun) 300 return -EBADFD; 301 302 DBG(KERN_INFO "%s: tun_chr_read\n", tun->name); 303 304 for (i = 0, len = 0; i < count; i++) { 305 if (verify_area(VERIFY_WRITE, iv[i].iov_base, iv[i].iov_len)) 306 return -EFAULT; 307 len += iv[i].iov_len; 308 } 309 310 add_wait_queue(&tun->read_wait, &wait); 311 while (len) { 312 current->state = TASK_INTERRUPTIBLE; 313 314 /* Read frames from the queue */ 315 if (!(skb=skb_dequeue(&tun->readq))) { 316 if (file->f_flags & O_NONBLOCK) { 317 ret = -EAGAIN; 318 break; 319 } 320 if (signal_pending(current)) { 321 ret = -ERESTARTSYS; 322 break; 323 } 324 325 /* Nothing to read, let's sleep */ 326 schedule(); 327 continue; 328 } 329 netif_start_queue(&tun->dev); 330 331 ret = tun_put_user(tun, skb, (struct iovec *) iv, len); 332 333 kfree_skb(skb); 334 break; 335 } 336 337 current->state = TASK_RUNNING; 338 remove_wait_queue(&tun->read_wait, &wait); 339 340 return ret; 341} 342 343/* Read */ 344static ssize_t tun_chr_read(struct file * file, char * buf, 345 size_t count, loff_t *pos) 346{ 347 struct iovec iv = { buf, count }; 348 return tun_chr_readv(file, &iv, 1, pos); 349} 350 351static int tun_set_iff(struct file *file, struct ifreq *ifr) 352{ 353 struct tun_struct *tun; 354 struct net_device *dev; 355 int err; 356 357 dev = __dev_get_by_name(ifr->ifr_name); 358 if (dev) { 359 /* Device exist */ 360 tun = dev->priv; 361 362 if (dev->init != tun_net_init || tun->attached) 363 return -EBUSY; 364 365 /* Check permissions */ 366 if (tun->owner != -1) 367 if (current->euid != tun->owner && !capable(CAP_NET_ADMIN)) 368 return -EPERM; 369 } else { 370 char *name; 371 372 /* Allocate new device */ 373 if (!(tun = kmalloc(sizeof(struct tun_struct), GFP_KERNEL)) ) 374 return -ENOMEM; 375 memset(tun, 0, sizeof(struct tun_struct)); 376 377 skb_queue_head_init(&tun->readq); 378 init_waitqueue_head(&tun->read_wait); 379 380 tun->owner = -1; 381 tun->dev.init = tun_net_init; 382 tun->dev.priv = tun; 383 384 err = -EINVAL; 385 386 /* Set dev type */ 387 if (ifr->ifr_flags & IFF_TUN) { 388 /* TUN device */ 389 tun->flags |= TUN_TUN_DEV; 390 name = "tun%d"; 391 } else if (ifr->ifr_flags & IFF_TAP) { 392 /* TAP device */ 393 tun->flags |= TUN_TAP_DEV; 394 name = "tap%d"; 395 } else 396 goto failed; 397 398 if (*ifr->ifr_name) 399 name = ifr->ifr_name; 400 401 if ((err = dev_alloc_name(&tun->dev, name)) < 0) 402 goto failed; 403 if ((err = register_netdevice(&tun->dev))) 404 goto failed; 405 406 MOD_INC_USE_COUNT; 407 408 tun->name = tun->dev.name; 409 } 410 411 DBG(KERN_INFO "%s: tun_set_iff\n", tun->name); 412 413 if (ifr->ifr_flags & IFF_NO_PI) 414 tun->flags |= TUN_NO_PI; 415 416 if (ifr->ifr_flags & IFF_ONE_QUEUE) 417 tun->flags |= TUN_ONE_QUEUE; 418 419 file->private_data = tun; 420 tun->attached = 1; 421 422 strcpy(ifr->ifr_name, tun->name); 423 return 0; 424 425failed: 426 kfree(tun); 427 return err; 428} 429 430static int tun_chr_ioctl(struct inode *inode, struct file *file, 431 unsigned int cmd, unsigned long arg) 432{ 433 struct tun_struct *tun = (struct tun_struct *)file->private_data; 434 435 if (cmd == TUNSETIFF && !tun) { 436 struct ifreq ifr; 437 int err; 438 439 if (copy_from_user(&ifr, (void *)arg, sizeof(ifr))) 440 return -EFAULT; 441 ifr.ifr_name[IFNAMSIZ-1] = '\0'; 442 443 rtnl_lock(); 444 err = tun_set_iff(file, &ifr); 445 rtnl_unlock(); 446 447 if (err) 448 return err; 449 450 copy_to_user((void *)arg, &ifr, sizeof(ifr)); 451 return 0; 452 } 453 454 if (!tun) 455 return -EBADFD; 456 457 DBG(KERN_INFO "%s: tun_chr_ioctl cmd %d\n", tun->name, cmd); 458 459 switch (cmd) { 460 case TUNSETNOCSUM: 461 /* Disable/Enable checksum */ 462 if (arg) 463 tun->flags |= TUN_NOCHECKSUM; 464 else 465 tun->flags &= ~TUN_NOCHECKSUM; 466 467 DBG(KERN_INFO "%s: checksum %s\n", 468 tun->name, arg ? "disabled" : "enabled"); 469 break; 470 471 case TUNSETPERSIST: 472 /* Disable/Enable persist mode */ 473 if (arg) 474 tun->flags |= TUN_PERSIST; 475 else 476 tun->flags &= ~TUN_PERSIST; 477 478 DBG(KERN_INFO "%s: persist %s\n", 479 tun->name, arg ? "disabled" : "enabled"); 480 break; 481 482 case TUNSETOWNER: 483 /* Set owner of the device */ 484 tun->owner = (uid_t) arg; 485 486 DBG(KERN_INFO "%s: owner set to %d\n", tun->owner); 487 break; 488 489#ifdef TUN_DEBUG 490 case TUNSETDEBUG: 491 tun->debug = arg; 492 break; 493#endif 494 495 default: 496 return -EINVAL; 497 }; 498 499 return 0; 500} 501 502static int tun_chr_fasync(int fd, struct file *file, int on) 503{ 504 struct tun_struct *tun = (struct tun_struct *)file->private_data; 505 int ret; 506 507 if (!tun) 508 return -EBADFD; 509 510 DBG(KERN_INFO "%s: tun_chr_fasync %d\n", tun->name, on); 511 512 if ((ret = fasync_helper(fd, file, on, &tun->fasync)) < 0) 513 return ret; 514 515 if (on) { 516 tun->flags |= TUN_FASYNC; 517 if (!file->f_owner.pid) { 518 file->f_owner.pid = current->pid; 519 file->f_owner.uid = current->uid; 520 file->f_owner.euid = current->euid; 521 } 522 } else 523 tun->flags &= ~TUN_FASYNC; 524 525 return 0; 526} 527 528static int tun_chr_open(struct inode *inode, struct file * file) 529{ 530 DBG1(KERN_INFO "tunX: tun_chr_open\n"); 531 file->private_data = NULL; 532 return 0; 533} 534 535static int tun_chr_close(struct inode *inode, struct file *file) 536{ 537 struct tun_struct *tun = (struct tun_struct *)file->private_data; 538 539 if (!tun) 540 return 0; 541 542 DBG(KERN_INFO "%s: tun_chr_close\n", tun->name); 543 544 tun_chr_fasync(-1, file, 0); 545 546 rtnl_lock(); 547 548 /* Detach from net device */ 549 file->private_data = NULL; 550 tun->attached = 0; 551 552 /* Drop read queue */ 553 skb_queue_purge(&tun->readq); 554 555 if (!(tun->flags & TUN_PERSIST)) { 556 dev_close(&tun->dev); 557 unregister_netdevice(&tun->dev); 558 kfree(tun); 559 MOD_DEC_USE_COUNT; 560 } 561 562 rtnl_unlock(); 563 return 0; 564} 565 566static struct file_operations tun_fops = { 567 owner: THIS_MODULE, 568 llseek: no_llseek, 569 read: tun_chr_read, 570 readv: tun_chr_readv, 571 write: tun_chr_write, 572 writev: tun_chr_writev, 573 poll: tun_chr_poll, 574 ioctl: tun_chr_ioctl, 575 open: tun_chr_open, 576 release:tun_chr_close, 577 fasync: tun_chr_fasync 578}; 579 580static struct miscdevice tun_miscdev= 581{ 582 TUN_MINOR, 583 "net/tun", 584 &tun_fops 585}; 586 587int __init tun_init(void) 588{ 589 printk(KERN_INFO "Universal TUN/TAP device driver %s " 590 "(C)1999-2002 Maxim Krasnyansky\n", TUN_VER); 591 592 if (misc_register(&tun_miscdev)) { 593 printk(KERN_ERR "tun: Can't register misc device %d\n", TUN_MINOR); 594 return -EIO; 595 } 596 597 return 0; 598} 599 600void tun_cleanup(void) 601{ 602 misc_deregister(&tun_miscdev); 603} 604 605module_init(tun_init); 606module_exit(tun_cleanup); 607MODULE_LICENSE("GPL"); 608