File: /usr/src/linux/drivers/net/slip.c
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
91 typedef struct slip_ctrl {
92 struct slip ctrl; /* SLIP things */
93 struct net_device dev; /* the device */
94 } slip_ctrl_t;
95 static slip_ctrl_t **slip_ctrls;
96
97 int slip_maxdev = SL_NRUNIT; /* Can be overridden with insmod! */
98 MODULE_PARM(slip_maxdev, "i");
99 MODULE_PARM_DESC(slip_maxdev, "Maximum number of slip devices");
100
101 static struct tty_ldisc sl_ldisc;
102
103 static int slip_esc(unsigned char *p, unsigned char *d, int len);
104 static void slip_unesc(struct slip *sl, unsigned char c);
105 #ifdef CONFIG_SLIP_MODE_SLIP6
106 static int slip_esc6(unsigned char *p, unsigned char *d, int len);
107 static void slip_unesc6(struct slip *sl, unsigned char c);
108 #endif
109 #ifdef CONFIG_SLIP_SMART
110 static void sl_keepalive(unsigned long sls);
111 static void sl_outfill(unsigned long sls);
112 static 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
130 static int
131 sl_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 */
196 err_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. */
211 static void
212 sl_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
233 static 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
306 done_on_bh:
307 spin_unlock_bh(&sl->lock);
308
309 done:
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. */
323 static inline void
324 sl_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. */
331 static inline void
332 sl_unlock(struct slip *sl)
333 {
334 netif_wake_queue(sl->dev);
335 }
336
337 /* Send one completely decapsulated IP datagram to the IP layer. */
338 static void
339 sl_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. */
396 static void
397 sl_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 */
447 static 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
470 static 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 (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
499 out:
500 spin_unlock(&sl->lock);
501 }
502
503
504 /* Encapsulate an IP datagram and kick it into a TTY queue. */
505 static int
506 sl_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
539 static int
540 sl_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
559 static 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
573 static 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
587 static struct net_device_stats *
588 sl_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
624 static 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
664 static 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
676 static 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
708 static 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. */
724 static struct slip *
725 sl_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 */
830 static int
831 slip_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
899 err_free_chan:
900 sl->tty = NULL;
901 tty->disc_data = NULL;
902 clear_bit(SLF_INUSE, &sl->flags);
903
904 err_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 */
935 static void
936 slip_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
963 int
964 slip_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
1001 static 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
1049 int
1050 slip_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
1087 void
1088 slip_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. */
1125 static int
1126 slip_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
1246 static 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
1322 int __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
1378 int
1379 init_module(void)
1380 {
1381 return slip_init_ctrl_dev();
1382 }
1383
1384 void
1385 cleanup_module(void)
1386 {
1387 int i;
1388
1389 if (slip_ctrls != NULL) {
1390 unsigned long start = jiffies;
1391 int busy = 0;
1392
1393 /* First of all: check for active disciplines and hangup them.
1394 */
1395 do {
1396 if (busy) {
1397 current->counter = 0;
1398 schedule();
1399 }
1400
1401 busy = 0;
1402 local_bh_disable();
1403 for (i = 0; i < slip_maxdev; i++) {
1404 struct slip_ctrl *slc = slip_ctrls[i];
1405 if (!slc)
1406 continue;
1407 spin_lock(&slc->ctrl.lock);
1408 if (slc->ctrl.tty) {
1409 busy++;
1410 tty_hangup(slc->ctrl.tty);
1411 }
1412 spin_unlock(&slc->ctrl.lock);
1413 }
1414 local_bh_enable();
1415 } while (busy && jiffies - start < 1*HZ);
1416
1417 busy = 0;
1418 for (i = 0; i < slip_maxdev; i++) {
1419 struct slip_ctrl *slc = slip_ctrls[i];
1420 if (slc) {
1421 unregister_netdev(&slc->dev);
1422 if (slc->ctrl.tty) {
1423 printk("%s: tty discipline is still running\n", slc->dev.name);
1424 /* Pin module forever */
1425 MOD_INC_USE_COUNT;
1426 busy++;
1427 continue;
1428 }
1429 sl_free_bufs(&slc->ctrl);
1430 kfree(slc);
1431 slip_ctrls[i] = NULL;
1432 }
1433 }
1434 if (!busy) {
1435 kfree(slip_ctrls);
1436 slip_ctrls = NULL;
1437 }
1438 }
1439 if ((i = tty_register_ldisc(N_SLIP, NULL)))
1440 {
1441 printk("SLIP: can't unregister line discipline (err = %d)\n", i);
1442 }
1443 }
1444 #endif /* MODULE */
1445
1446 #ifdef CONFIG_SLIP_SMART
1447 /*
1448 * This is start of the code for multislip style line checking
1449 * added by Stanislav Voronyi. All changes before marked VSV
1450 */
1451
1452 static void sl_outfill(unsigned long sls)
1453 {
1454 struct slip *sl=(struct slip *)sls;
1455
1456 spin_lock(&sl->lock);
1457
1458 if (sl->tty == NULL)
1459 goto out;
1460
1461 if(sl->outfill)
1462 {
1463 if( test_bit(SLF_OUTWAIT, &sl->flags) )
1464 {
1465 /* no packets were transmitted, do outfill */
1466 #ifdef CONFIG_SLIP_MODE_SLIP6
1467 unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
1468 #else
1469 unsigned char s = END;
1470 #endif
1471 /* put END into tty queue. Is it right ??? */
1472 if (!netif_queue_stopped(sl->dev))
1473 {
1474 /* if device busy no outfill */
1475 sl->tty->driver.write(sl->tty, 0, &s, 1);
1476 }
1477 }
1478 else
1479 set_bit(SLF_OUTWAIT, &sl->flags);
1480
1481 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1482 }
1483 out:
1484 spin_unlock(&sl->lock);
1485 }
1486
1487 static void sl_keepalive(unsigned long sls)
1488 {
1489 struct slip *sl=(struct slip *)sls;
1490
1491 spin_lock(&sl->lock);
1492
1493 if (sl->tty == NULL)
1494 goto out;
1495
1496 if( sl->keepalive)
1497 {
1498 if(test_bit(SLF_KEEPTEST, &sl->flags))
1499 {
1500 /* keepalive still high :(, we must hangup */
1501 if( sl->outfill ) /* outfill timer must be deleted too */
1502 (void)del_timer(&sl->outfill_timer);
1503 printk("%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
1504 tty_hangup(sl->tty); /* this must hangup tty & close slip */
1505 /* I think we need not something else */
1506 goto out;
1507 }
1508 else
1509 set_bit(SLF_KEEPTEST, &sl->flags);
1510
1511 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1512 }
1513
1514 out:
1515 spin_unlock(&sl->lock);
1516 }
1517
1518 #endif
1519