1/* 2 * slip.c This module implements the SLIP protocol for kernel-based 3 * devices like TTY. It interfaces between a raw TTY, and the 4 * kernel's INET protocol layers. 5 * 6 * Version: @(#)slip.c 0.8.3 12/24/94 7 * 8 * Authors: Laurence Culhane, <loz@holmes.demon.co.uk> 9 * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org> 10 * 11 * Fixes: 12 * Alan Cox : Sanity checks and avoid tx overruns. 13 * Has a new sl->mtu field. 14 * Alan Cox : Found cause of overrun. ifconfig sl0 mtu upwards. 15 * Driver now spots this and grows/shrinks its buffers(hack!). 16 * Memory leak if you run out of memory setting up a slip driver fixed. 17 * Matt Dillon : Printable slip (borrowed from NET2E) 18 * Pauline Middelink : Slip driver fixes. 19 * Alan Cox : Honours the old SL_COMPRESSED flag 20 * Alan Cox : KISS AX.25 and AXUI IP support 21 * Michael Riepe : Automatic CSLIP recognition added 22 * Charles Hedrick : CSLIP header length problem fix. 23 * Alan Cox : Corrected non-IP cases of the above. 24 * Alan Cox : Now uses hardware type as per FvK. 25 * Alan Cox : Default to 192.168.0.0 (RFC 1597) 26 * A.N.Kuznetsov : dev_tint() recursion fix. 27 * Dmitry Gorodchanin : SLIP memory leaks 28 * Dmitry Gorodchanin : Code cleanup. Reduce tty driver 29 * buffering from 4096 to 256 bytes. 30 * Improving SLIP response time. 31 * CONFIG_SLIP_MODE_SLIP6. 32 * ifconfig sl? up & down now works correctly. 33 * Modularization. 34 * Alan Cox : Oops - fix AX.25 buffer lengths 35 * Dmitry Gorodchanin : Even more cleanups. Preserve CSLIP 36 * statistics. Include CSLIP code only 37 * if it really needed. 38 * Alan Cox : Free slhc buffers in the right place. 39 * Alan Cox : Allow for digipeated IP over AX.25 40 * Matti Aarnio : Dynamic SLIP devices, with ideas taken 41 * from Jim Freeman's <jfree@caldera.com> 42 * dynamic PPP devices. We do NOT kfree() 43 * device entries, just reg./unreg. them 44 * as they are needed. We kfree() them 45 * at module cleanup. 46 * With MODULE-loading ``insmod'', user can 47 * issue parameter: slip_maxdev=1024 48 * (Or how much he/she wants.. Default is 256) 49 * * Stanislav Voronyi : Slip line checking, with ideas taken 50 * from multislip BSDI driver which was written 51 * by Igor Chechik, RELCOM Corp. Only algorithms 52 * have been ported to Linux SLIP driver. 53 * Vitaly E. Lavrov : Sane behaviour on tty hangup. 54 * Alexey Kuznetsov : Cleanup interfaces to tty&netdevice modules. 55 */ 56 57#define SL_CHECK_TRANSMIT 58#include <linux/module.h> 59#include <linux/moduleparam.h> 60 61#include <asm/system.h> 62#include <asm/uaccess.h> 63#include <linux/bitops.h> 64#include <linux/string.h> 65#include <linux/mm.h> 66#include <linux/interrupt.h> 67#include <linux/in.h> 68#include <linux/tty.h> 69#include <linux/errno.h> 70#include <linux/netdevice.h> 71#include <linux/etherdevice.h> 72#include <linux/skbuff.h> 73#include <linux/rtnetlink.h> 74#include <linux/if_arp.h> 75#include <linux/if_slip.h> 76#include <linux/delay.h> 77#include <linux/init.h> 78#include "slip.h" 79#ifdef CONFIG_INET 80#include <linux/ip.h> 81#include <linux/tcp.h> 82#include <net/slhc_vj.h> 83#endif 84 85#define SLIP_VERSION "0.8.4-NET3.019-NEWTTY" 86 87static struct net_device **slip_devs; 88 89static int slip_maxdev = SL_NRUNIT; 90module_param(slip_maxdev, int, 0); 91MODULE_PARM_DESC(slip_maxdev, "Maximum number of slip devices"); 92 93static int slip_esc(unsigned char *p, unsigned char *d, int len); 94static void slip_unesc(struct slip *sl, unsigned char c); 95#ifdef CONFIG_SLIP_MODE_SLIP6 96static int slip_esc6(unsigned char *p, unsigned char *d, int len); 97static void slip_unesc6(struct slip *sl, unsigned char c); 98#endif 99#ifdef CONFIG_SLIP_SMART 100static void sl_keepalive(unsigned long sls); 101static void sl_outfill(unsigned long sls); 102static int sl_ioctl(struct net_device *dev,struct ifreq *rq,int cmd); 103#endif 104 105/******************************** 106* Buffer administration routines: 107* sl_alloc_bufs() 108* sl_free_bufs() 109* sl_realloc_bufs() 110* 111* NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because 112* sl_realloc_bufs provides strong atomicity and reallocation 113* on actively running device. 114*********************************/ 115 116/* 117 Allocate channel buffers. 118 */ 119 120static int 121sl_alloc_bufs(struct slip *sl, int mtu) 122{ 123 int err = -ENOBUFS; 124 unsigned long len; 125 char * rbuff = NULL; 126 char * xbuff = NULL; 127#ifdef SL_INCLUDE_CSLIP 128 char * cbuff = NULL; 129 struct slcompress *slcomp = NULL; 130#endif 131 132 /* 133 * Allocate the SLIP frame buffers: 134 * 135 * rbuff Receive buffer. 136 * xbuff Transmit buffer. 137 * cbuff Temporary compression buffer. 138 */ 139 len = mtu * 2; 140 141 /* 142 * allow for arrival of larger UDP packets, even if we say not to 143 * also fixes a bug in which SunOS sends 512-byte packets even with 144 * an MSS of 128 145 */ 146 if (len < 576 * 2) 147 len = 576 * 2; 148 rbuff = kmalloc(len + 4, GFP_KERNEL); 149 if (rbuff == NULL) 150 goto err_exit; 151 xbuff = kmalloc(len + 4, GFP_KERNEL); 152 if (xbuff == NULL) 153 goto err_exit; 154#ifdef SL_INCLUDE_CSLIP 155 cbuff = kmalloc(len + 4, GFP_KERNEL); 156 if (cbuff == NULL) 157 goto err_exit; 158 slcomp = slhc_init(16, 16); 159 if (slcomp == NULL) 160 goto err_exit; 161#endif 162 spin_lock_bh(&sl->lock); 163 if (sl->tty == NULL) { 164 spin_unlock_bh(&sl->lock); 165 err = -ENODEV; 166 goto err_exit; 167 } 168 sl->mtu = mtu; 169 sl->buffsize = len; 170 sl->rcount = 0; 171 sl->xleft = 0; 172 rbuff = xchg(&sl->rbuff, rbuff); 173 xbuff = xchg(&sl->xbuff, xbuff); 174#ifdef SL_INCLUDE_CSLIP 175 cbuff = xchg(&sl->cbuff, cbuff); 176 slcomp = xchg(&sl->slcomp, slcomp); 177#ifdef CONFIG_SLIP_MODE_SLIP6 178 sl->xdata = 0; 179 sl->xbits = 0; 180#endif 181#endif 182 spin_unlock_bh(&sl->lock); 183 err = 0; 184 185 /* Cleanup */ 186err_exit: 187#ifdef SL_INCLUDE_CSLIP 188 kfree(cbuff); 189 if (slcomp) 190 slhc_free(slcomp); 191#endif 192 kfree(xbuff); 193 kfree(rbuff); 194 return err; 195} 196 197/* Free a SLIP channel buffers. */ 198static void 199sl_free_bufs(struct slip *sl) 200{ 201 /* Free all SLIP frame buffers. */ 202 kfree(xchg(&sl->rbuff, NULL)); 203 kfree(xchg(&sl->xbuff, NULL)); 204#ifdef SL_INCLUDE_CSLIP 205 kfree(xchg(&sl->cbuff, NULL)); 206 slhc_free(xchg(&sl->slcomp, NULL)); 207#endif 208} 209 210/* 211 Reallocate slip channel buffers. 212 */ 213 214static int sl_realloc_bufs(struct slip *sl, int mtu) 215{ 216 int err = 0; 217 struct net_device *dev = sl->dev; 218 unsigned char *xbuff, *rbuff; 219#ifdef SL_INCLUDE_CSLIP 220 unsigned char *cbuff; 221#endif 222 int len = mtu * 2; 223 224/* 225 * allow for arrival of larger UDP packets, even if we say not to 226 * also fixes a bug in which SunOS sends 512-byte packets even with 227 * an MSS of 128 228 */ 229 if (len < 576 * 2) 230 len = 576 * 2; 231 232 xbuff = kmalloc(len + 4, GFP_ATOMIC); 233 rbuff = kmalloc(len + 4, GFP_ATOMIC); 234#ifdef SL_INCLUDE_CSLIP 235 cbuff = kmalloc(len + 4, GFP_ATOMIC); 236#endif 237 238 239#ifdef SL_INCLUDE_CSLIP 240 if (xbuff == NULL || rbuff == NULL || cbuff == NULL) { 241#else 242 if (xbuff == NULL || rbuff == NULL) { 243#endif 244 if (mtu >= sl->mtu) { 245 printk(KERN_WARNING "%s: unable to grow slip buffers, MTU change cancelled.\n", 246 dev->name); 247 err = -ENOBUFS; 248 } 249 goto done; 250 } 251 252 spin_lock_bh(&sl->lock); 253 254 err = -ENODEV; 255 if (sl->tty == NULL) 256 goto done_on_bh; 257 258 xbuff = xchg(&sl->xbuff, xbuff); 259 rbuff = xchg(&sl->rbuff, rbuff); 260#ifdef SL_INCLUDE_CSLIP 261 cbuff = xchg(&sl->cbuff, cbuff); 262#endif 263 if (sl->xleft) { 264 if (sl->xleft <= len) { 265 memcpy(sl->xbuff, sl->xhead, sl->xleft); 266 } else { 267 sl->xleft = 0; 268 sl->tx_dropped++; 269 } 270 } 271 sl->xhead = sl->xbuff; 272 273 if (sl->rcount) { 274 if (sl->rcount <= len) { 275 memcpy(sl->rbuff, rbuff, sl->rcount); 276 } else { 277 sl->rcount = 0; 278 sl->rx_over_errors++; 279 set_bit(SLF_ERROR, &sl->flags); 280 } 281 } 282 sl->mtu = mtu; 283 dev->mtu = mtu; 284 sl->buffsize = len; 285 err = 0; 286 287done_on_bh: 288 spin_unlock_bh(&sl->lock); 289 290done: 291 kfree(xbuff); 292 kfree(rbuff); 293#ifdef SL_INCLUDE_CSLIP 294 kfree(cbuff); 295#endif 296 return err; 297} 298 299 300/* Set the "sending" flag. This must be atomic hence the set_bit. */ 301static inline void 302sl_lock(struct slip *sl) 303{ 304 netif_stop_queue(sl->dev); 305} 306 307 308/* Clear the "sending" flag. This must be atomic, hence the ASM. */ 309static inline void 310sl_unlock(struct slip *sl) 311{ 312 netif_wake_queue(sl->dev); 313} 314 315/* Send one completely decapsulated IP datagram to the IP layer. */ 316static void 317sl_bump(struct slip *sl) 318{ 319 struct sk_buff *skb; 320 int count; 321 322 count = sl->rcount; 323#ifdef SL_INCLUDE_CSLIP 324 if (sl->mode & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) { 325 unsigned char c; 326 if ((c = sl->rbuff[0]) & SL_TYPE_COMPRESSED_TCP) { 327 /* ignore compressed packets when CSLIP is off */ 328 if (!(sl->mode & SL_MODE_CSLIP)) { 329 printk(KERN_WARNING "%s: compressed packet ignored\n", sl->dev->name); 330 return; 331 } 332 /* make sure we've reserved enough space for uncompress to use */ 333 if (count + 80 > sl->buffsize) { 334 sl->rx_over_errors++; 335 return; 336 } 337 count = slhc_uncompress(sl->slcomp, sl->rbuff, count); 338 if (count <= 0) { 339 return; 340 } 341 } else if (c >= SL_TYPE_UNCOMPRESSED_TCP) { 342 if (!(sl->mode & SL_MODE_CSLIP)) { 343 /* turn on header compression */ 344 sl->mode |= SL_MODE_CSLIP; 345 sl->mode &= ~SL_MODE_ADAPTIVE; 346 printk(KERN_INFO "%s: header compression turned on\n", sl->dev->name); 347 } 348 sl->rbuff[0] &= 0x4f; 349 if (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0) { 350 return; 351 } 352 } 353 } 354#endif /* SL_INCLUDE_CSLIP */ 355 356 sl->rx_bytes+=count; 357 358 skb = dev_alloc_skb(count); 359 if (skb == NULL) { 360 printk(KERN_WARNING "%s: memory squeeze, dropping packet.\n", sl->dev->name); 361 sl->rx_dropped++; 362 return; 363 } 364 skb->dev = sl->dev; 365 memcpy(skb_put(skb,count), sl->rbuff, count); 366 skb_reset_mac_header(skb); 367 skb->protocol=htons(ETH_P_IP); 368 netif_rx(skb); 369 sl->dev->last_rx = jiffies; 370 sl->rx_packets++; 371} 372 373/* Encapsulate one IP datagram and stuff into a TTY queue. */ 374static void 375sl_encaps(struct slip *sl, unsigned char *icp, int len) 376{ 377 unsigned char *p; 378 int actual, count; 379 380 if (len > sl->mtu) { /* Sigh, shouldn't occur BUT ... */ 381 printk(KERN_WARNING "%s: truncating oversized transmit packet!\n", sl->dev->name); 382 sl->tx_dropped++; 383 sl_unlock(sl); 384 return; 385 } 386 387 p = icp; 388#ifdef SL_INCLUDE_CSLIP 389 if (sl->mode & SL_MODE_CSLIP) { 390 len = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1); 391 } 392#endif 393#ifdef CONFIG_SLIP_MODE_SLIP6 394 if(sl->mode & SL_MODE_SLIP6) 395 count = slip_esc6(p, (unsigned char *) sl->xbuff, len); 396 else 397#endif 398 count = slip_esc(p, (unsigned char *) sl->xbuff, len); 399 400 /* Order of next two lines is *very* important. 401 * When we are sending a little amount of data, 402 * the transfer may be completed inside driver.write() 403 * routine, because it's running with interrupts enabled. 404 * In this case we *never* got WRITE_WAKEUP event, 405 * if we did not request it before write operation. 406 * 14 Oct 1994 Dmitry Gorodchanin. 407 */ 408 sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP); 409 actual = sl->tty->driver->write(sl->tty, sl->xbuff, count); 410#ifdef SL_CHECK_TRANSMIT 411 sl->dev->trans_start = jiffies; 412#endif 413 sl->xleft = count - actual; 414 sl->xhead = sl->xbuff + actual; 415#ifdef CONFIG_SLIP_SMART 416 /* VSV */ 417 clear_bit(SLF_OUTWAIT, &sl->flags); /* reset outfill flag */ 418#endif 419} 420 421/* 422 * Called by the driver when there's room for more data. If we have 423 * more packets to send, we send them here. 424 */ 425static void slip_write_wakeup(struct tty_struct *tty) 426{ 427 int actual; 428 struct slip *sl = (struct slip *) tty->disc_data; 429 430 /* First make sure we're connected. */ 431 if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev)) { 432 return; 433 } 434 if (sl->xleft <= 0) { 435 /* Now serial buffer is almost free & we can start 436 * transmission of another packet */ 437 sl->tx_packets++; 438 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP); 439 sl_unlock(sl); 440 return; 441 } 442 443 actual = tty->driver->write(tty, sl->xhead, sl->xleft); 444 sl->xleft -= actual; 445 sl->xhead += actual; 446} 447 448static void sl_tx_timeout(struct net_device *dev) 449{ 450 struct slip *sl = netdev_priv(dev); 451 452 spin_lock(&sl->lock); 453 454 if (netif_queue_stopped(dev)) { 455 if (!netif_running(dev)) 456 goto out; 457 458 /* May be we must check transmitter timeout here ? 459 * 14 Oct 1994 Dmitry Gorodchanin. 460 */ 461#ifdef SL_CHECK_TRANSMIT 462 if (time_before(jiffies, dev->trans_start + 20 * HZ)) { 463 /* 20 sec timeout not reached */ 464 goto out; 465 } 466 printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name, 467 (sl->tty->driver->chars_in_buffer(sl->tty) || sl->xleft) ? 468 "bad line quality" : "driver error"); 469 sl->xleft = 0; 470 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP); 471 sl_unlock(sl); 472#endif 473 } 474 475out: 476 spin_unlock(&sl->lock); 477} 478 479 480/* Encapsulate an IP datagram and kick it into a TTY queue. */ 481static int 482sl_xmit(struct sk_buff *skb, struct net_device *dev) 483{ 484 struct slip *sl = netdev_priv(dev); 485 486 spin_lock(&sl->lock); 487 if (!netif_running(dev)) { 488 spin_unlock(&sl->lock); 489 printk(KERN_WARNING "%s: xmit call when iface is down\n", dev->name); 490 dev_kfree_skb(skb); 491 return 0; 492 } 493 if (sl->tty == NULL) { 494 spin_unlock(&sl->lock); 495 dev_kfree_skb(skb); 496 return 0; 497 } 498 499 sl_lock(sl); 500 sl->tx_bytes+=skb->len; 501 sl_encaps(sl, skb->data, skb->len); 502 spin_unlock(&sl->lock); 503 504 dev_kfree_skb(skb); 505 return 0; 506} 507 508 509/****************************************** 510 * Routines looking at netdevice side. 511 ******************************************/ 512 513/* Netdevice UP -> DOWN routine */ 514 515static int 516sl_close(struct net_device *dev) 517{ 518 struct slip *sl = netdev_priv(dev); 519 520 spin_lock_bh(&sl->lock); 521 if (sl->tty) { 522 /* TTY discipline is running. */ 523 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP); 524 } 525 netif_stop_queue(dev); 526 sl->rcount = 0; 527 sl->xleft = 0; 528 spin_unlock_bh(&sl->lock); 529 530 return 0; 531} 532 533/* Netdevice DOWN -> UP routine */ 534 535static int sl_open(struct net_device *dev) 536{ 537 struct slip *sl = netdev_priv(dev); 538 539 if (sl->tty==NULL) 540 return -ENODEV; 541 542 sl->flags &= (1 << SLF_INUSE); 543 netif_start_queue(dev); 544 return 0; 545} 546 547/* Netdevice change MTU request */ 548 549static int sl_change_mtu(struct net_device *dev, int new_mtu) 550{ 551 struct slip *sl = netdev_priv(dev); 552 553 if (new_mtu < 68 || new_mtu > 65534) 554 return -EINVAL; 555 556 if (new_mtu != dev->mtu) 557 return sl_realloc_bufs(sl, new_mtu); 558 return 0; 559} 560 561/* Netdevice get statistics request */ 562 563static struct net_device_stats * 564sl_get_stats(struct net_device *dev) 565{ 566 static struct net_device_stats stats; 567 struct slip *sl = netdev_priv(dev); 568#ifdef SL_INCLUDE_CSLIP 569 struct slcompress *comp; 570#endif 571 572 memset(&stats, 0, sizeof(struct net_device_stats)); 573 574 stats.rx_packets = sl->rx_packets; 575 stats.tx_packets = sl->tx_packets; 576 stats.rx_bytes = sl->rx_bytes; 577 stats.tx_bytes = sl->tx_bytes; 578 stats.rx_dropped = sl->rx_dropped; 579 stats.tx_dropped = sl->tx_dropped; 580 stats.tx_errors = sl->tx_errors; 581 stats.rx_errors = sl->rx_errors; 582 stats.rx_over_errors = sl->rx_over_errors; 583#ifdef SL_INCLUDE_CSLIP 584 stats.rx_fifo_errors = sl->rx_compressed; 585 stats.tx_fifo_errors = sl->tx_compressed; 586 stats.collisions = sl->tx_misses; 587 comp = sl->slcomp; 588 if (comp) { 589 stats.rx_fifo_errors += comp->sls_i_compressed; 590 stats.rx_dropped += comp->sls_i_tossed; 591 stats.tx_fifo_errors += comp->sls_o_compressed; 592 stats.collisions += comp->sls_o_misses; 593 } 594#endif /* CONFIG_INET */ 595 return (&stats); 596} 597 598/* Netdevice register callback */ 599 600static int sl_init(struct net_device *dev) 601{ 602 struct slip *sl = netdev_priv(dev); 603 604 /* 605 * Finish setting up the DEVICE info. 606 */ 607 608 dev->mtu = sl->mtu; 609 dev->type = ARPHRD_SLIP + sl->mode; 610#ifdef SL_CHECK_TRANSMIT 611 dev->tx_timeout = sl_tx_timeout; 612 dev->watchdog_timeo = 20*HZ; 613#endif 614 return 0; 615} 616 617 618static void sl_uninit(struct net_device *dev) 619{ 620 struct slip *sl = netdev_priv(dev); 621 622 sl_free_bufs(sl); 623} 624 625static void sl_setup(struct net_device *dev) 626{ 627 dev->init = sl_init; 628 dev->uninit = sl_uninit; 629 dev->open = sl_open; 630 dev->destructor = free_netdev; 631 dev->stop = sl_close; 632 dev->get_stats = sl_get_stats; 633 dev->change_mtu = sl_change_mtu; 634 dev->hard_start_xmit = sl_xmit; 635#ifdef CONFIG_SLIP_SMART 636 dev->do_ioctl = sl_ioctl; 637#endif 638 dev->hard_header_len = 0; 639 dev->addr_len = 0; 640 dev->tx_queue_len = 10; 641 642 SET_MODULE_OWNER(dev); 643 644 /* New-style flags. */ 645 dev->flags = IFF_NOARP|IFF_POINTOPOINT|IFF_MULTICAST; 646} 647 648/****************************************** 649 Routines looking at TTY side. 650 ******************************************/ 651 652 653/* 654 * Handle the 'receiver data ready' interrupt. 655 * This function is called by the 'tty_io' module in the kernel when 656 * a block of SLIP data has been received, which can now be decapsulated 657 * and sent on to some IP layer for further processing. This will not 658 * be re-entered while running but other ldisc functions may be called 659 * in parallel 660 */ 661 662static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count) 663{ 664 struct slip *sl = (struct slip *) tty->disc_data; 665 666 if (!sl || sl->magic != SLIP_MAGIC || 667 !netif_running(sl->dev)) 668 return; 669 670 /* Read the characters out of the buffer */ 671 while (count--) { 672 if (fp && *fp++) { 673 if (!test_and_set_bit(SLF_ERROR, &sl->flags)) { 674 sl->rx_errors++; 675 } 676 cp++; 677 continue; 678 } 679#ifdef CONFIG_SLIP_MODE_SLIP6 680 if (sl->mode & SL_MODE_SLIP6) 681 slip_unesc6(sl, *cp++); 682 else 683#endif 684 slip_unesc(sl, *cp++); 685 } 686} 687 688/************************************ 689 * slip_open helper routines. 690 ************************************/ 691 692/* Collect hanged up channels */ 693 694static void sl_sync(void) 695{ 696 int i; 697 struct net_device *dev; 698 struct slip *sl; 699 700 for (i = 0; i < slip_maxdev; i++) { 701 if ((dev = slip_devs[i]) == NULL) 702 break; 703 704 sl = netdev_priv(dev); 705 if (sl->tty || sl->leased) 706 continue; 707 if (dev->flags&IFF_UP) 708 dev_close(dev); 709 } 710} 711 712 713/* Find a free SLIP channel, and link in this `tty' line. */ 714static struct slip * 715sl_alloc(dev_t line) 716{ 717 int i; 718 int sel = -1; 719 int score = -1; 720 struct net_device *dev = NULL; 721 struct slip *sl; 722 723 if (slip_devs == NULL) 724 return NULL; /* Master array missing ! */ 725 726 for (i = 0; i < slip_maxdev; i++) { 727 dev = slip_devs[i]; 728 if (dev == NULL) 729 break; 730 731 sl = netdev_priv(dev); 732 if (sl->leased) { 733 if (sl->line != line) 734 continue; 735 if (sl->tty) 736 return NULL; 737 738 /* Clear ESCAPE & ERROR flags */ 739 sl->flags &= (1 << SLF_INUSE); 740 return sl; 741 } 742 743 if (sl->tty) 744 continue; 745 746 if (current->pid == sl->pid) { 747 if (sl->line == line && score < 3) { 748 sel = i; 749 score = 3; 750 continue; 751 } 752 if (score < 2) { 753 sel = i; 754 score = 2; 755 } 756 continue; 757 } 758 if (sl->line == line && score < 1) { 759 sel = i; 760 score = 1; 761 continue; 762 } 763 if (score < 0) { 764 sel = i; 765 score = 0; 766 } 767 } 768 769 if (sel >= 0) { 770 i = sel; 771 dev = slip_devs[i]; 772 if (score > 1) { 773 sl = netdev_priv(dev); 774 sl->flags &= (1 << SLF_INUSE); 775 return sl; 776 } 777 } 778 779 /* Sorry, too many, all slots in use */ 780 if (i >= slip_maxdev) 781 return NULL; 782 783 if (dev) { 784 sl = netdev_priv(dev); 785 if (test_bit(SLF_INUSE, &sl->flags)) { 786 unregister_netdevice(dev); 787 dev = NULL; 788 slip_devs[i] = NULL; 789 } 790 } 791 792 if (!dev) { 793 char name[IFNAMSIZ]; 794 sprintf(name, "sl%d", i); 795 796 dev = alloc_netdev(sizeof(*sl), name, sl_setup); 797 if (!dev) 798 return NULL; 799 dev->base_addr = i; 800 } 801 802 sl = netdev_priv(dev); 803 804 /* Initialize channel control data */ 805 sl->magic = SLIP_MAGIC; 806 sl->dev = dev; 807 spin_lock_init(&sl->lock); 808 sl->mode = SL_MODE_DEFAULT; 809#ifdef CONFIG_SLIP_SMART 810 init_timer(&sl->keepalive_timer); /* initialize timer_list struct */ 811 sl->keepalive_timer.data=(unsigned long)sl; 812 sl->keepalive_timer.function=sl_keepalive; 813 init_timer(&sl->outfill_timer); 814 sl->outfill_timer.data=(unsigned long)sl; 815 sl->outfill_timer.function=sl_outfill; 816#endif 817 slip_devs[i] = dev; 818 819 return sl; 820} 821 822/* 823 * Open the high-level part of the SLIP channel. 824 * This function is called by the TTY module when the 825 * SLIP line discipline is called for. Because we are 826 * sure the tty line exists, we only have to link it to 827 * a free SLIP channel... 828 * 829 * Called in process context serialized from other ldisc calls. 830 */ 831 832static int slip_open(struct tty_struct *tty) 833{ 834 struct slip *sl; 835 int err; 836 837 if(!capable(CAP_NET_ADMIN)) 838 return -EPERM; 839 840 /* RTnetlink lock is misused here to serialize concurrent 841 opens of slip channels. There are better ways, but it is 842 the simplest one. 843 */ 844 rtnl_lock(); 845 846 /* Collect hanged up channels. */ 847 sl_sync(); 848 849 sl = (struct slip *) tty->disc_data; 850 851 err = -EEXIST; 852 /* First make sure we're not already connected. */ 853 if (sl && sl->magic == SLIP_MAGIC) 854 goto err_exit; 855 856 /* OK. Find a free SLIP channel to use. */ 857 err = -ENFILE; 858 if ((sl = sl_alloc(tty_devnum(tty))) == NULL) 859 goto err_exit; 860 861 sl->tty = tty; 862 tty->disc_data = sl; 863 sl->line = tty_devnum(tty); 864 sl->pid = current->pid; 865 866 if (!test_bit(SLF_INUSE, &sl->flags)) { 867 /* Perform the low-level SLIP initialization. */ 868 if ((err = sl_alloc_bufs(sl, SL_MTU)) != 0) 869 goto err_free_chan; 870 871 set_bit(SLF_INUSE, &sl->flags); 872 873 if ((err = register_netdevice(sl->dev))) 874 goto err_free_bufs; 875 } 876 877#ifdef CONFIG_SLIP_SMART 878 if (sl->keepalive) { 879 sl->keepalive_timer.expires=jiffies+sl->keepalive*HZ; 880 add_timer (&sl->keepalive_timer); 881 } 882 if (sl->outfill) { 883 sl->outfill_timer.expires=jiffies+sl->outfill*HZ; 884 add_timer (&sl->outfill_timer); 885 } 886#endif 887 888 /* Done. We have linked the TTY line to a channel. */ 889 rtnl_unlock(); 890 tty->receive_room = 65536; /* We don't flow control */ 891 return sl->dev->base_addr; 892 893err_free_bufs: 894 sl_free_bufs(sl); 895 896err_free_chan: 897 sl->tty = NULL; 898 tty->disc_data = NULL; 899 clear_bit(SLF_INUSE, &sl->flags); 900 901err_exit: 902 rtnl_unlock(); 903 904 /* Count references from TTY module */ 905 return err; 906} 907 908 909/* 910 * Close down a SLIP channel. 911 * This means flushing out any pending queues, and then returning. This 912 * call is serialized against other ldisc functions. 913 */ 914static void 915slip_close(struct tty_struct *tty) 916{ 917 struct slip *sl = (struct slip *) tty->disc_data; 918 919 /* First make sure we're connected. */ 920 if (!sl || sl->magic != SLIP_MAGIC || sl->tty != tty) 921 return; 922 923 tty->disc_data = NULL; 924 sl->tty = NULL; 925 if (!sl->leased) 926 sl->line = 0; 927 928 /* VSV = very important to remove timers */ 929#ifdef CONFIG_SLIP_SMART 930 del_timer_sync(&sl->keepalive_timer); 931 del_timer_sync(&sl->outfill_timer); 932#endif 933 934 /* Count references from TTY module */ 935} 936 937 /************************************************************************ 938 * STANDARD SLIP ENCAPSULATION * 939 ************************************************************************/ 940 941int 942slip_esc(unsigned char *s, unsigned char *d, int len) 943{ 944 unsigned char *ptr = d; 945 unsigned char c; 946 947 /* 948 * Send an initial END character to flush out any 949 * data that may have accumulated in the receiver 950 * due to line noise. 951 */ 952 953 *ptr++ = END; 954 955 /* 956 * For each byte in the packet, send the appropriate 957 * character sequence, according to the SLIP protocol. 958 */ 959 960 while (len-- > 0) { 961 switch(c = *s++) { 962 case END: 963 *ptr++ = ESC; 964 *ptr++ = ESC_END; 965 break; 966 case ESC: 967 *ptr++ = ESC; 968 *ptr++ = ESC_ESC; 969 break; 970 default: 971 *ptr++ = c; 972 break; 973 } 974 } 975 *ptr++ = END; 976 return (ptr - d); 977} 978 979static void slip_unesc(struct slip *sl, unsigned char s) 980{ 981 982 switch(s) { 983 case END: 984#ifdef CONFIG_SLIP_SMART 985 /* drop keeptest bit = VSV */ 986 if (test_bit(SLF_KEEPTEST, &sl->flags)) 987 clear_bit(SLF_KEEPTEST, &sl->flags); 988#endif 989 990 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2)) { 991 sl_bump(sl); 992 } 993 clear_bit(SLF_ESCAPE, &sl->flags); 994 sl->rcount = 0; 995 return; 996 997 case ESC: 998 set_bit(SLF_ESCAPE, &sl->flags); 999 return; 1000 case ESC_ESC: 1001 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags)) { 1002 s = ESC; 1003 } 1004 break; 1005 case ESC_END: 1006 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags)) { 1007 s = END; 1008 } 1009 break; 1010 } 1011 if (!test_bit(SLF_ERROR, &sl->flags)) { 1012 if (sl->rcount < sl->buffsize) { 1013 sl->rbuff[sl->rcount++] = s; 1014 return; 1015 } 1016 sl->rx_over_errors++; 1017 set_bit(SLF_ERROR, &sl->flags); 1018 } 1019} 1020 1021 1022#ifdef CONFIG_SLIP_MODE_SLIP6 1023/************************************************************************ 1024 * 6 BIT SLIP ENCAPSULATION * 1025 ************************************************************************/ 1026 1027int 1028slip_esc6(unsigned char *s, unsigned char *d, int len) 1029{ 1030 unsigned char *ptr = d; 1031 unsigned char c; 1032 int i; 1033 unsigned short v = 0; 1034 short bits = 0; 1035 1036 /* 1037 * Send an initial END character to flush out any 1038 * data that may have accumulated in the receiver 1039 * due to line noise. 1040 */ 1041 1042 *ptr++ = 0x70; 1043 1044 /* 1045 * Encode the packet into printable ascii characters 1046 */ 1047 1048 for (i = 0; i < len; ++i) { 1049 v = (v << 8) | s[i]; 1050 bits += 8; 1051 while (bits >= 6) { 1052 bits -= 6; 1053 c = 0x30 + ((v >> bits) & 0x3F); 1054 *ptr++ = c; 1055 } 1056 } 1057 if (bits) { 1058 c = 0x30 + ((v << (6 - bits)) & 0x3F); 1059 *ptr++ = c; 1060 } 1061 *ptr++ = 0x70; 1062 return ptr - d; 1063} 1064 1065void 1066slip_unesc6(struct slip *sl, unsigned char s) 1067{ 1068 unsigned char c; 1069 1070 if (s == 0x70) { 1071#ifdef CONFIG_SLIP_SMART 1072 /* drop keeptest bit = VSV */ 1073 if (test_bit(SLF_KEEPTEST, &sl->flags)) 1074 clear_bit(SLF_KEEPTEST, &sl->flags); 1075#endif 1076 1077 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2)) { 1078 sl_bump(sl); 1079 } 1080 sl->rcount = 0; 1081 sl->xbits = 0; 1082 sl->xdata = 0; 1083 } else if (s >= 0x30 && s < 0x70) { 1084 sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F); 1085 sl->xbits += 6; 1086 if (sl->xbits >= 8) { 1087 sl->xbits -= 8; 1088 c = (unsigned char)(sl->xdata >> sl->xbits); 1089 if (!test_bit(SLF_ERROR, &sl->flags)) { 1090 if (sl->rcount < sl->buffsize) { 1091 sl->rbuff[sl->rcount++] = c; 1092 return; 1093 } 1094 sl->rx_over_errors++; 1095 set_bit(SLF_ERROR, &sl->flags); 1096 } 1097 } 1098 } 1099} 1100#endif /* CONFIG_SLIP_MODE_SLIP6 */ 1101 1102/* Perform I/O control on an active SLIP channel. */ 1103static int slip_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg) 1104{ 1105 struct slip *sl = (struct slip *) tty->disc_data; 1106 unsigned int tmp; 1107 int __user *p = (int __user *)arg; 1108 1109 /* First make sure we're connected. */ 1110 if (!sl || sl->magic != SLIP_MAGIC) { 1111 return -EINVAL; 1112 } 1113 1114 switch(cmd) { 1115 case SIOCGIFNAME: 1116 tmp = strlen(sl->dev->name) + 1; 1117 if (copy_to_user((void __user *)arg, sl->dev->name, tmp)) 1118 return -EFAULT; 1119 return 0; 1120 1121 case SIOCGIFENCAP: 1122 if (put_user(sl->mode, p)) 1123 return -EFAULT; 1124 return 0; 1125 1126 case SIOCSIFENCAP: 1127 if (get_user(tmp, p)) 1128 return -EFAULT; 1129#ifndef SL_INCLUDE_CSLIP 1130 if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE)) { 1131 return -EINVAL; 1132 } 1133#else 1134 if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) == 1135 (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) { 1136 /* return -EINVAL; */ 1137 tmp &= ~SL_MODE_ADAPTIVE; 1138 } 1139#endif 1140#ifndef CONFIG_SLIP_MODE_SLIP6 1141 if (tmp & SL_MODE_SLIP6) { 1142 return -EINVAL; 1143 } 1144#endif 1145 sl->mode = tmp; 1146 sl->dev->type = ARPHRD_SLIP+sl->mode; 1147 return 0; 1148 1149 case SIOCSIFHWADDR: 1150 return -EINVAL; 1151 1152#ifdef CONFIG_SLIP_SMART 1153 /* VSV changes start here */ 1154 case SIOCSKEEPALIVE: 1155 if (get_user(tmp, p)) 1156 return -EFAULT; 1157 if (tmp > 255) /* max for unchar */ 1158 return -EINVAL; 1159 1160 spin_lock_bh(&sl->lock); 1161 if (!sl->tty) { 1162 spin_unlock_bh(&sl->lock); 1163 return -ENODEV; 1164 } 1165 if ((sl->keepalive = (unchar) tmp) != 0) { 1166 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ); 1167 set_bit(SLF_KEEPTEST, &sl->flags); 1168 } else { 1169 del_timer (&sl->keepalive_timer); 1170 } 1171 spin_unlock_bh(&sl->lock); 1172 return 0; 1173 1174 case SIOCGKEEPALIVE: 1175 if (put_user(sl->keepalive, p)) 1176 return -EFAULT; 1177 return 0; 1178 1179 case SIOCSOUTFILL: 1180 if (get_user(tmp, p)) 1181 return -EFAULT; 1182 if (tmp > 255) /* max for unchar */ 1183 return -EINVAL; 1184 spin_lock_bh(&sl->lock); 1185 if (!sl->tty) { 1186 spin_unlock_bh(&sl->lock); 1187 return -ENODEV; 1188 } 1189 if ((sl->outfill = (unchar) tmp) != 0){ 1190 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ); 1191 set_bit(SLF_OUTWAIT, &sl->flags); 1192 } else { 1193 del_timer (&sl->outfill_timer); 1194 } 1195 spin_unlock_bh(&sl->lock); 1196 return 0; 1197 1198 case SIOCGOUTFILL: 1199 if (put_user(sl->outfill, p)) 1200 return -EFAULT; 1201 return 0; 1202 /* VSV changes end */ 1203#endif 1204 1205 /* Allow stty to read, but not set, the serial port */ 1206 case TCGETS: 1207 case TCGETA: 1208 return n_tty_ioctl(tty, file, cmd, arg); 1209 1210 default: 1211 return -ENOIOCTLCMD; 1212 } 1213} 1214 1215/* VSV changes start here */ 1216#ifdef CONFIG_SLIP_SMART 1217/* function do_ioctl called from net/core/dev.c 1218 to allow get/set outfill/keepalive parameter 1219 by ifconfig */ 1220 1221static int sl_ioctl(struct net_device *dev,struct ifreq *rq,int cmd) 1222{ 1223 struct slip *sl = netdev_priv(dev); 1224 unsigned long *p = (unsigned long *)&rq->ifr_ifru; 1225 1226 if (sl == NULL) /* Allocation failed ?? */ 1227 return -ENODEV; 1228 1229 spin_lock_bh(&sl->lock); 1230 1231 if (!sl->tty) { 1232 spin_unlock_bh(&sl->lock); 1233 return -ENODEV; 1234 } 1235 1236 switch(cmd){ 1237 case SIOCSKEEPALIVE: 1238 /* max for unchar */ 1239 if ((unsigned)*p > 255) { 1240 spin_unlock_bh(&sl->lock); 1241 return -EINVAL; 1242 } 1243 sl->keepalive = (unchar) *p; 1244 if (sl->keepalive != 0) { 1245 sl->keepalive_timer.expires=jiffies+sl->keepalive*HZ; 1246 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ); 1247 set_bit(SLF_KEEPTEST, &sl->flags); 1248 } else { 1249 del_timer(&sl->keepalive_timer); 1250 } 1251 break; 1252 1253 case SIOCGKEEPALIVE: 1254 *p = sl->keepalive; 1255 break; 1256 1257 case SIOCSOUTFILL: 1258 if ((unsigned)*p > 255) { /* max for unchar */ 1259 spin_unlock_bh(&sl->lock); 1260 return -EINVAL; 1261 } 1262 if ((sl->outfill = (unchar)*p) != 0){ 1263 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ); 1264 set_bit(SLF_OUTWAIT, &sl->flags); 1265 } else { 1266 del_timer (&sl->outfill_timer); 1267 } 1268 break; 1269 1270 case SIOCGOUTFILL: 1271 *p = sl->outfill; 1272 break; 1273 1274 case SIOCSLEASE: 1275 /* Resolve race condition, when ioctl'ing hanged up 1276 and opened by another process device. 1277 */ 1278 if (sl->tty != current->signal->tty && sl->pid != current->pid) { 1279 spin_unlock_bh(&sl->lock); 1280 return -EPERM; 1281 } 1282 sl->leased = 0; 1283 if (*p) 1284 sl->leased = 1; 1285 break; 1286 1287 case SIOCGLEASE: 1288 *p = sl->leased; 1289 }; 1290 spin_unlock_bh(&sl->lock); 1291 return 0; 1292} 1293#endif 1294/* VSV changes end */ 1295 1296static struct tty_ldisc sl_ldisc = { 1297 .owner = THIS_MODULE, 1298 .magic = TTY_LDISC_MAGIC, 1299 .name = "slip", 1300 .open = slip_open, 1301 .close = slip_close, 1302 .ioctl = slip_ioctl, 1303 .receive_buf = slip_receive_buf, 1304 .write_wakeup = slip_write_wakeup, 1305}; 1306 1307static int __init slip_init(void) 1308{ 1309 int status; 1310 1311 if (slip_maxdev < 4) 1312 slip_maxdev = 4; /* Sanity */ 1313 1314 printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)" 1315#ifdef CONFIG_SLIP_MODE_SLIP6 1316 " (6 bit encapsulation enabled)" 1317#endif 1318 ".\n", 1319 SLIP_VERSION, slip_maxdev ); 1320#if defined(SL_INCLUDE_CSLIP) 1321 printk(KERN_INFO "CSLIP: code copyright 1989 Regents of the University of California.\n"); 1322#endif 1323#ifdef CONFIG_SLIP_SMART 1324 printk(KERN_INFO "SLIP linefill/keepalive option.\n"); 1325#endif 1326 1327 slip_devs = kzalloc(sizeof(struct net_device *)*slip_maxdev, GFP_KERNEL); 1328 if (!slip_devs) { 1329 printk(KERN_ERR "SLIP: Can't allocate slip devices array! Uaargh! (-> No SLIP available)\n"); 1330 return -ENOMEM; 1331 } 1332 1333 /* Fill in our line protocol discipline, and register it */ 1334 if ((status = tty_register_ldisc(N_SLIP, &sl_ldisc)) != 0) { 1335 printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status); 1336 kfree(slip_devs); 1337 } 1338 return status; 1339} 1340 1341static void __exit slip_exit(void) 1342{ 1343 int i; 1344 struct net_device *dev; 1345 struct slip *sl; 1346 unsigned long timeout = jiffies + HZ; 1347 int busy = 0; 1348 1349 if (slip_devs == NULL) 1350 return; 1351 1352 /* First of all: check for active disciplines and hangup them. 1353 */ 1354 do { 1355 if (busy) 1356 msleep_interruptible(100); 1357 1358 busy = 0; 1359 for (i = 0; i < slip_maxdev; i++) { 1360 dev = slip_devs[i]; 1361 if (!dev) 1362 continue; 1363 sl = netdev_priv(dev); 1364 spin_lock_bh(&sl->lock); 1365 if (sl->tty) { 1366 busy++; 1367 tty_hangup(sl->tty); 1368 } 1369 spin_unlock_bh(&sl->lock); 1370 } 1371 } while (busy && time_before(jiffies, timeout)); 1372 1373 1374 for (i = 0; i < slip_maxdev; i++) { 1375 dev = slip_devs[i]; 1376 if (!dev) 1377 continue; 1378 slip_devs[i] = NULL; 1379 1380 sl = netdev_priv(dev); 1381 if (sl->tty) { 1382 printk(KERN_ERR "%s: tty discipline still running\n", 1383 dev->name); 1384 /* Intentionally leak the control block. */ 1385 dev->destructor = NULL; 1386 } 1387 1388 unregister_netdev(dev); 1389 } 1390 1391 kfree(slip_devs); 1392 slip_devs = NULL; 1393 1394 if ((i = tty_unregister_ldisc(N_SLIP))) 1395 { 1396 printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i); 1397 } 1398} 1399 1400module_init(slip_init); 1401module_exit(slip_exit); 1402 1403#ifdef CONFIG_SLIP_SMART 1404/* 1405 * This is start of the code for multislip style line checking 1406 * added by Stanislav Voronyi. All changes before marked VSV 1407 */ 1408 1409static void sl_outfill(unsigned long sls) 1410{ 1411 struct slip *sl=(struct slip *)sls; 1412 1413 spin_lock(&sl->lock); 1414 1415 if (sl->tty == NULL) 1416 goto out; 1417 1418 if(sl->outfill) 1419 { 1420 if( test_bit(SLF_OUTWAIT, &sl->flags) ) 1421 { 1422 /* no packets were transmitted, do outfill */ 1423#ifdef CONFIG_SLIP_MODE_SLIP6 1424 unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END; 1425#else 1426 unsigned char s = END; 1427#endif 1428 /* put END into tty queue. Is it right ??? */ 1429 if (!netif_queue_stopped(sl->dev)) 1430 { 1431 /* if device busy no outfill */ 1432 sl->tty->driver->write(sl->tty, &s, 1); 1433 } 1434 } 1435 else 1436 set_bit(SLF_OUTWAIT, &sl->flags); 1437 1438 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ); 1439 } 1440out: 1441 spin_unlock(&sl->lock); 1442} 1443 1444static void sl_keepalive(unsigned long sls) 1445{ 1446 struct slip *sl=(struct slip *)sls; 1447 1448 spin_lock(&sl->lock); 1449 1450 if (sl->tty == NULL) 1451 goto out; 1452 1453 if( sl->keepalive) 1454 { 1455 if(test_bit(SLF_KEEPTEST, &sl->flags)) 1456 { 1457 /* keepalive still high :(, we must hangup */ 1458 if( sl->outfill ) /* outfill timer must be deleted too */ 1459 (void)del_timer(&sl->outfill_timer); 1460 printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name); 1461 tty_hangup(sl->tty); /* this must hangup tty & close slip */ 1462 /* I think we need not something else */ 1463 goto out; 1464 } 1465 else 1466 set_bit(SLF_KEEPTEST, &sl->flags); 1467 1468 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ); 1469 } 1470 1471out: 1472 spin_unlock(&sl->lock); 1473} 1474 1475#endif 1476MODULE_LICENSE("GPL"); 1477MODULE_ALIAS_LDISC(N_SLIP); 1478