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