projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] skge: remove unused declarations
[deliverable/linux.git] / drivers / net / slip.c
CommitLineData
1da177e4
LT		 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#include <linux/moduleparam.h>
61
62#include <asm/system.h>
63#include <asm/uaccess.h>
64#include <linux/bitops.h>
65#include <linux/string.h>
66#include <linux/mm.h>
67#include <linux/interrupt.h>
68#include <linux/in.h>
69#include <linux/tty.h>
70#include <linux/errno.h>
71#include <linux/netdevice.h>
72#include <linux/etherdevice.h>
73#include <linux/skbuff.h>
74#include <linux/rtnetlink.h>
75#include <linux/if_arp.h>
76#include <linux/if_slip.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
158a0e45 188 kfree(cbuff);
1da177e4
LT		 189 if (slcomp)
190 slhc_free(slcomp);
191#endif
158a0e45
JJ		 192 kfree(xbuff);
193 kfree(rbuff);
1da177e4
LT		 194 return err;
195}
196
197/* Free a SLIP channel buffers. */
198static void
199sl_free_bufs(struct slip *sl)
200{
1da177e4 201 /* Free all SLIP frame buffers. */
9b200b02
JJ		 202 kfree(xchg(&sl->rbuff, NULL));
203 kfree(xchg(&sl->xbuff, NULL));
1da177e4 204#ifdef SL_INCLUDE_CSLIP
9b200b02
JJ		 205 kfree(xchg(&sl->cbuff, NULL));
206 slhc_free(xchg(&sl->slcomp, NULL));
1da177e4
LT		 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 = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
233 rbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
234#ifdef SL_INCLUDE_CSLIP
235 cbuff = (unsigned char *) 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:
158a0e45
JJ		 291 kfree(xbuff);
292 kfree(rbuff);
1da177e4 293#ifdef SL_INCLUDE_CSLIP
158a0e45 294 kfree(cbuff);
1da177e4
LT		 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->mac.raw=skb->data;
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
653static int slip_receive_room(struct tty_struct *tty)
654{
655 return 65536; /* We can handle an infinite amount of data. :-) */
656}
657
658/*
659 * Handle the 'receiver data ready' interrupt.
660 * This function is called by the 'tty_io' module in the kernel when
661 * a block of SLIP data has been received, which can now be decapsulated
662 * and sent on to some IP layer for further processing. This will not
663 * be re-entered while running but other ldisc functions may be called
664 * in parallel
665 */
666
667static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
668{
669 struct slip *sl = (struct slip *) tty->disc_data;
670
671 if (!sl || sl->magic != SLIP_MAGIC ||
672 !netif_running(sl->dev))
673 return;
674
675 /* Read the characters out of the buffer */
676 while (count--) {
677 if (fp && *fp++) {
678 if (!test_and_set_bit(SLF_ERROR, &sl->flags)) {
679 sl->rx_errors++;
680 }
681 cp++;
682 continue;
683 }
684#ifdef CONFIG_SLIP_MODE_SLIP6
685 if (sl->mode & SL_MODE_SLIP6)
686 slip_unesc6(sl, *cp++);
687 else
688#endif
689 slip_unesc(sl, *cp++);
690 }
691}
692
693/************************************
694 * slip_open helper routines.
695 ************************************/
696
697/* Collect hanged up channels */
698
699static void sl_sync(void)
700{
701 int i;
702 struct net_device *dev;
703 struct slip *sl;
704
705 for (i = 0; i < slip_maxdev; i++) {
706 if ((dev = slip_devs[i]) == NULL)
707 break;
708
709 sl = netdev_priv(dev);
710 if (sl->tty || sl->leased)
711 continue;
712 if (dev->flags&IFF_UP)
713 dev_close(dev);
714 }
715}
716
717
718/* Find a free SLIP channel, and link in this `tty' line. */
719static struct slip *
720sl_alloc(dev_t line)
721{
722 int i;
723 int sel = -1;
724 int score = -1;
725 struct net_device *dev = NULL;
726 struct slip *sl;
727
728 if (slip_devs == NULL)
729 return NULL; /* Master array missing ! */
730
731 for (i = 0; i < slip_maxdev; i++) {
732 dev = slip_devs[i];
733 if (dev == NULL)
734 break;
735
736 sl = netdev_priv(dev);
737 if (sl->leased) {
738 if (sl->line != line)
739 continue;
740 if (sl->tty)
741 return NULL;
742
743 /* Clear ESCAPE & ERROR flags */
744 sl->flags &= (1 << SLF_INUSE);
745 return sl;
746 }
747
748 if (sl->tty)
749 continue;
750
751 if (current->pid == sl->pid) {
752 if (sl->line == line && score < 3) {
753 sel = i;
754 score = 3;
755 continue;
756 }
757 if (score < 2) {
758 sel = i;
759 score = 2;
760 }
761 continue;
762 }
763 if (sl->line == line && score < 1) {
764 sel = i;
765 score = 1;
766 continue;
767 }
768 if (score < 0) {
769 sel = i;
770 score = 0;
771 }
772 }
773
774 if (sel >= 0) {
775 i = sel;
776 dev = slip_devs[i];
777 if (score > 1) {
778 sl = netdev_priv(dev);
779 sl->flags &= (1 << SLF_INUSE);
780 return sl;
781 }
782 }
783
784 /* Sorry, too many, all slots in use */
785 if (i >= slip_maxdev)
786 return NULL;
787
788 if (dev) {
789 sl = netdev_priv(dev);
790 if (test_bit(SLF_INUSE, &sl->flags)) {
791 unregister_netdevice(dev);
792 dev = NULL;
793 slip_devs[i] = NULL;
794 }
795 }
796
797 if (!dev) {
798 char name[IFNAMSIZ];
799 sprintf(name, "sl%d", i);
800
801 dev = alloc_netdev(sizeof(*sl), name, sl_setup);
802 if (!dev)
803 return NULL;
804 dev->base_addr = i;
805 }
806
807 sl = netdev_priv(dev);
808
809 /* Initialize channel control data */
810 sl->magic = SLIP_MAGIC;
811 sl->dev = dev;
812 spin_lock_init(&sl->lock);
813 sl->mode = SL_MODE_DEFAULT;
814#ifdef CONFIG_SLIP_SMART
815 init_timer(&sl->keepalive_timer); /* initialize timer_list struct */
816 sl->keepalive_timer.data=(unsigned long)sl;
817 sl->keepalive_timer.function=sl_keepalive;
818 init_timer(&sl->outfill_timer);
819 sl->outfill_timer.data=(unsigned long)sl;
820 sl->outfill_timer.function=sl_outfill;
821#endif
822 slip_devs[i] = dev;
823
824 return sl;
825}
826
827/*
828 * Open the high-level part of the SLIP channel.
829 * This function is called by the TTY module when the
830 * SLIP line discipline is called for. Because we are
831 * sure the tty line exists, we only have to link it to
832 * a free SLIP channel...
833 *
834 * Called in process context serialized from other ldisc calls.
835 */
836
837static int slip_open(struct tty_struct *tty)
838{
839 struct slip *sl;
840 int err;
841
842 if(!capable(CAP_NET_ADMIN))
843 return -EPERM;
844
845 /* RTnetlink lock is misused here to serialize concurrent
846 opens of slip channels. There are better ways, but it is
847 the simplest one.
848 */
849 rtnl_lock();
850
851 /* Collect hanged up channels. */
852 sl_sync();
853
854 sl = (struct slip *) tty->disc_data;
855
856 err = -EEXIST;
857 /* First make sure we're not already connected. */
858 if (sl && sl->magic == SLIP_MAGIC)
859 goto err_exit;
860
861 /* OK. Find a free SLIP channel to use. */
862 err = -ENFILE;
863 if ((sl = sl_alloc(tty_devnum(tty))) == NULL)
864 goto err_exit;
865
866 sl->tty = tty;
867 tty->disc_data = sl;
868 sl->line = tty_devnum(tty);
869 sl->pid = current->pid;
870
871 /* FIXME: already done before we were called - seems this can go */
872 if (tty->driver->flush_buffer)
873 tty->driver->flush_buffer(tty);
874
875 if (!test_bit(SLF_INUSE, &sl->flags)) {
876 /* Perform the low-level SLIP initialization. */
877 if ((err = sl_alloc_bufs(sl, SL_MTU)) != 0)
878 goto err_free_chan;
879
880 set_bit(SLF_INUSE, &sl->flags);
881
882 if ((err = register_netdevice(sl->dev)))
883 goto err_free_bufs;
884 }
885
886#ifdef CONFIG_SLIP_SMART
887 if (sl->keepalive) {
888 sl->keepalive_timer.expires=jiffies+sl->keepalive*HZ;
889 add_timer (&sl->keepalive_timer);
890 }
891 if (sl->outfill) {
892 sl->outfill_timer.expires=jiffies+sl->outfill*HZ;
893 add_timer (&sl->outfill_timer);
894 }
895#endif
896
897 /* Done. We have linked the TTY line to a channel. */
898 rtnl_unlock();
899 return sl->dev->base_addr;
900
901err_free_bufs:
902 sl_free_bufs(sl);
903
904err_free_chan:
905 sl->tty = NULL;
906 tty->disc_data = NULL;
907 clear_bit(SLF_INUSE, &sl->flags);
908
909err_exit:
910 rtnl_unlock();
911
912 /* Count references from TTY module */
913 return err;
914}
915
916/*
917
918 FIXME: 1,2 are fixed 3 was never true anyway.
919
920 Let me to blame a bit.
921 1. TTY module calls this funstion on soft interrupt.
922 2. TTY module calls this function WITH MASKED INTERRUPTS!
923 3. TTY module does not notify us about line discipline
924 shutdown,
925
926 Seems, now it is clean. The solution is to consider netdevice and
927 line discipline sides as two independent threads.
928
929 By-product (not desired): sl? does not feel hangups and remains open.
930 It is supposed, that user level program (dip, diald, slattach...)
931 will catch SIGHUP and make the rest of work.
932
933 I see no way to make more with current tty code. --ANK
934 */
935
936/*
937 * Close down a SLIP channel.
938 * This means flushing out any pending queues, and then returning. This
939 * call is serialized against other ldisc functions.
940 */
941static void
942slip_close(struct tty_struct *tty)
943{
944 struct slip *sl = (struct slip *) tty->disc_data;
945
946 /* First make sure we're connected. */
947 if (!sl || sl->magic != SLIP_MAGIC || sl->tty != tty)
948 return;
949
950 tty->disc_data = NULL;
951 sl->tty = NULL;
952 if (!sl->leased)
953 sl->line = 0;
954
955 /* VSV = very important to remove timers */
956#ifdef CONFIG_SLIP_SMART
957 del_timer_sync(&sl->keepalive_timer);
958 del_timer_sync(&sl->outfill_timer);
959#endif
960
961 /* Count references from TTY module */
962}
963
964 /************************************************************************
965 * STANDARD SLIP ENCAPSULATION *
966 ************************************************************************/
967
968int
969slip_esc(unsigned char *s, unsigned char *d, int len)
970{
971 unsigned char *ptr = d;
972 unsigned char c;
973
974 /*
975 * Send an initial END character to flush out any
976 * data that may have accumulated in the receiver
977 * due to line noise.
978 */
979
980 *ptr++ = END;
981
982 /*
983 * For each byte in the packet, send the appropriate
984 * character sequence, according to the SLIP protocol.
985 */
986
987 while (len-- > 0) {
988 switch(c = *s++) {
989 case END:
990 *ptr++ = ESC;
991 *ptr++ = ESC_END;
992 break;
993 case ESC:
994 *ptr++ = ESC;
995 *ptr++ = ESC_ESC;
996 break;
997 default:
998 *ptr++ = c;
999 break;
1000 }
1001 }
1002 *ptr++ = END;
1003 return (ptr - d);
1004}
1005
1006static void slip_unesc(struct slip *sl, unsigned char s)
1007{
1008
1009 switch(s) {
1010 case END:
1011#ifdef CONFIG_SLIP_SMART
1012 /* drop keeptest bit = VSV */
1013 if (test_bit(SLF_KEEPTEST, &sl->flags))
1014 clear_bit(SLF_KEEPTEST, &sl->flags);
1015#endif
1016
1017 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2)) {
1018 sl_bump(sl);
1019 }
1020 clear_bit(SLF_ESCAPE, &sl->flags);
1021 sl->rcount = 0;
1022 return;
1023
1024 case ESC:
1025 set_bit(SLF_ESCAPE, &sl->flags);
1026 return;
1027 case ESC_ESC:
1028 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags)) {
1029 s = ESC;
1030 }
1031 break;
1032 case ESC_END:
1033 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags)) {
1034 s = END;
1035 }
1036 break;
1037 }
1038 if (!test_bit(SLF_ERROR, &sl->flags)) {
1039 if (sl->rcount < sl->buffsize) {
1040 sl->rbuff[sl->rcount++] = s;
1041 return;
1042 }
1043 sl->rx_over_errors++;
1044 set_bit(SLF_ERROR, &sl->flags);
1045 }
1046}
1047
1048
1049#ifdef CONFIG_SLIP_MODE_SLIP6
1050/************************************************************************
1051 * 6 BIT SLIP ENCAPSULATION *
1052 ************************************************************************/
1053
1054int
1055slip_esc6(unsigned char *s, unsigned char *d, int len)
1056{
1057 unsigned char *ptr = d;
1058 unsigned char c;
1059 int i;
1060 unsigned short v = 0;
1061 short bits = 0;
1062
1063 /*
1064 * Send an initial END character to flush out any
1065 * data that may have accumulated in the receiver
1066 * due to line noise.
1067 */
1068
1069 *ptr++ = 0x70;
1070
1071 /*
1072 * Encode the packet into printable ascii characters
1073 */
1074
1075 for (i = 0; i < len; ++i) {
1076 v = (v << 8) | s[i];
1077 bits += 8;
1078 while (bits >= 6) {
1079 bits -= 6;
1080 c = 0x30 + ((v >> bits) & 0x3F);
1081 *ptr++ = c;
1082 }
1083 }
1084 if (bits) {
1085 c = 0x30 + ((v << (6 - bits)) & 0x3F);
1086 *ptr++ = c;
1087 }
1088 *ptr++ = 0x70;
1089 return ptr - d;
1090}
1091
1092void
1093slip_unesc6(struct slip *sl, unsigned char s)
1094{
1095 unsigned char c;
1096
1097 if (s == 0x70) {
1098#ifdef CONFIG_SLIP_SMART
1099 /* drop keeptest bit = VSV */
1100 if (test_bit(SLF_KEEPTEST, &sl->flags))
1101 clear_bit(SLF_KEEPTEST, &sl->flags);
1102#endif
1103
1104 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2)) {
1105 sl_bump(sl);
1106 }
1107 sl->rcount = 0;
1108 sl->xbits = 0;
1109 sl->xdata = 0;
1110 } else if (s >= 0x30 && s < 0x70) {
1111 sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
1112 sl->xbits += 6;
1113 if (sl->xbits >= 8) {
1114 sl->xbits -= 8;
1115 c = (unsigned char)(sl->xdata >> sl->xbits);
1116 if (!test_bit(SLF_ERROR, &sl->flags)) {
1117 if (sl->rcount < sl->buffsize) {
1118 sl->rbuff[sl->rcount++] = c;
1119 return;
1120 }
1121 sl->rx_over_errors++;
1122 set_bit(SLF_ERROR, &sl->flags);
1123 }
1124 }
1125 }
1126}
1127#endif /* CONFIG_SLIP_MODE_SLIP6 */
1128
1129/* Perform I/O control on an active SLIP channel. */
1130static int slip_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1131{
1132 struct slip *sl = (struct slip *) tty->disc_data;
1133 unsigned int tmp;
1134 int __user *p = (int __user *)arg;
1135
1136 /* First make sure we're connected. */
1137 if (!sl || sl->magic != SLIP_MAGIC) {
1138 return -EINVAL;
1139 }
1140
1141 switch(cmd) {
1142 case SIOCGIFNAME:
1143 tmp = strlen(sl->dev->name) + 1;
1144 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1145 return -EFAULT;
1146 return 0;
1147
1148 case SIOCGIFENCAP:
1149 if (put_user(sl->mode, p))
1150 return -EFAULT;
1151 return 0;
1152
1153 case SIOCSIFENCAP:
1154 if (get_user(tmp, p))
1155 return -EFAULT;
1156#ifndef SL_INCLUDE_CSLIP
1157 if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE)) {
1158 return -EINVAL;
1159 }
1160#else
1161 if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
1162 (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) {
1163 /* return -EINVAL; */
1164 tmp &= ~SL_MODE_ADAPTIVE;
1165 }
1166#endif
1167#ifndef CONFIG_SLIP_MODE_SLIP6
1168 if (tmp & SL_MODE_SLIP6) {
1169 return -EINVAL;
1170 }
1171#endif
1172 sl->mode = tmp;
1173 sl->dev->type = ARPHRD_SLIP+sl->mode;
1174 return 0;
1175
1176 case SIOCSIFHWADDR:
1177 return -EINVAL;
1178
1179#ifdef CONFIG_SLIP_SMART
1180 /* VSV changes start here */
1181 case SIOCSKEEPALIVE:
1182 if (get_user(tmp, p))
1183 return -EFAULT;
1184 if (tmp > 255) /* max for unchar */
1185 return -EINVAL;
1186
1187 spin_lock_bh(&sl->lock);
1188 if (!sl->tty) {
1189 spin_unlock_bh(&sl->lock);
1190 return -ENODEV;
1191 }
1192 if ((sl->keepalive = (unchar) tmp) != 0) {
1193 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1194 set_bit(SLF_KEEPTEST, &sl->flags);
1195 } else {
1196 del_timer (&sl->keepalive_timer);
1197 }
1198 spin_unlock_bh(&sl->lock);
1199 return 0;
1200
1201 case SIOCGKEEPALIVE:
1202 if (put_user(sl->keepalive, p))
1203 return -EFAULT;
1204 return 0;
1205
1206 case SIOCSOUTFILL:
1207 if (get_user(tmp, p))
1208 return -EFAULT;
1209 if (tmp > 255) /* max for unchar */
1210 return -EINVAL;
1211 spin_lock_bh(&sl->lock);
1212 if (!sl->tty) {
1213 spin_unlock_bh(&sl->lock);
1214 return -ENODEV;
1215 }
1216 if ((sl->outfill = (unchar) tmp) != 0){
1217 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1218 set_bit(SLF_OUTWAIT, &sl->flags);
1219 } else {
1220 del_timer (&sl->outfill_timer);
1221 }
1222 spin_unlock_bh(&sl->lock);
1223 return 0;
1224
1225 case SIOCGOUTFILL:
1226 if (put_user(sl->outfill, p))
1227 return -EFAULT;
1228 return 0;
1229 /* VSV changes end */
1230#endif
1231
1232 /* Allow stty to read, but not set, the serial port */
1233 case TCGETS:
1234 case TCGETA:
1235 return n_tty_ioctl(tty, file, cmd, arg);
1236
1237 default:
1238 return -ENOIOCTLCMD;
1239 }
1240}
1241
1242/* VSV changes start here */
1243#ifdef CONFIG_SLIP_SMART
1244/* function do_ioctl called from net/core/dev.c
1245 to allow get/set outfill/keepalive parameter
1246 by ifconfig */
1247
1248static int sl_ioctl(struct net_device *dev,struct ifreq *rq,int cmd)
1249{
1250 struct slip *sl = netdev_priv(dev);
1251 unsigned long *p = (unsigned long *)&rq->ifr_ifru;
1252
1253 if (sl == NULL) /* Allocation failed ?? */
1254 return -ENODEV;
1255
1256 spin_lock_bh(&sl->lock);
1257
1258 if (!sl->tty) {
1259 spin_unlock_bh(&sl->lock);
1260 return -ENODEV;
1261 }
1262
1263 switch(cmd){
1264 case SIOCSKEEPALIVE:
1265 /* max for unchar */
1266 if ((unsigned)*p > 255) {
1267 spin_unlock_bh(&sl->lock);
1268 return -EINVAL;
1269 }
1270 sl->keepalive = (unchar) *p;
1271 if (sl->keepalive != 0) {
1272 sl->keepalive_timer.expires=jiffies+sl->keepalive*HZ;
1273 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1274 set_bit(SLF_KEEPTEST, &sl->flags);
1275 } else {
1276 del_timer(&sl->keepalive_timer);
1277 }
1278 break;
1279
1280 case SIOCGKEEPALIVE:
1281 *p = sl->keepalive;
1282 break;
1283
1284 case SIOCSOUTFILL:
1285 if ((unsigned)*p > 255) { /* max for unchar */
1286 spin_unlock_bh(&sl->lock);
1287 return -EINVAL;
1288 }
1289 if ((sl->outfill = (unchar)*p) != 0){
1290 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1291 set_bit(SLF_OUTWAIT, &sl->flags);
1292 } else {
1293 del_timer (&sl->outfill_timer);
1294 }
1295 break;
1296
1297 case SIOCGOUTFILL:
1298 *p = sl->outfill;
1299 break;
1300
1301 case SIOCSLEASE:
1302 /* Resolve race condition, when ioctl'ing hanged up
1303 and opened by another process device.
1304 */
1305 if (sl->tty != current->signal->tty && sl->pid != current->pid) {
1306 spin_unlock_bh(&sl->lock);
1307 return -EPERM;
1308 }
1309 sl->leased = 0;
1310 if (*p)
1311 sl->leased = 1;
1312 break;
1313
1314 case SIOCGLEASE:
1315 *p = sl->leased;
1316 };
1317 spin_unlock_bh(&sl->lock);
1318 return 0;
1319}
1320#endif
1321/* VSV changes end */
1322
1323static struct tty_ldisc sl_ldisc = {
1324 .owner = THIS_MODULE,
1325 .magic = TTY_LDISC_MAGIC,
1326 .name = "slip",
1327 .open = slip_open,
1328 .close = slip_close,
1329 .ioctl = slip_ioctl,
1330 .receive_buf = slip_receive_buf,
1331 .receive_room = slip_receive_room,
1332 .write_wakeup = slip_write_wakeup,
1333};
1334
1335static int __init slip_init(void)
1336{
1337 int status;
1338
1339 if (slip_maxdev < 4)
1340 slip_maxdev = 4; /* Sanity */
1341
1342 printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)"
1343#ifdef CONFIG_SLIP_MODE_SLIP6
1344 " (6 bit encapsulation enabled)"
1345#endif
1346 ".\n",
1347 SLIP_VERSION, slip_maxdev );
1348#if defined(SL_INCLUDE_CSLIP)
1349 printk(KERN_INFO "CSLIP: code copyright 1989 Regents of the University of California.\n");
1350#endif
1351#ifdef CONFIG_SLIP_SMART
1352 printk(KERN_INFO "SLIP linefill/keepalive option.\n");
1353#endif
1354
1355 slip_devs = kmalloc(sizeof(struct net_device *)*slip_maxdev, GFP_KERNEL);
1356 if (!slip_devs) {
1357 printk(KERN_ERR "SLIP: Can't allocate slip devices array! Uaargh! (-> No SLIP available)\n");
1358 return -ENOMEM;
1359 }
1360
1361 /* Clear the pointer array, we allocate devices when we need them */
1362 memset(slip_devs, 0, sizeof(struct net_device *)*slip_maxdev);
1363
1364 /* Fill in our line protocol discipline, and register it */
1365 if ((status = tty_register_ldisc(N_SLIP, &sl_ldisc)) != 0) {
1366 printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status);
1367 kfree(slip_devs);
1368 }
1369 return status;
1370}
1371
1372static void __exit slip_exit(void)
1373{
1374 int i;
1375 struct net_device *dev;
1376 struct slip *sl;
1377 unsigned long timeout = jiffies + HZ;
1378 int busy = 0;
1379
1380 if (slip_devs == NULL)
1381 return;
1382
1383 /* First of all: check for active disciplines and hangup them.
1384 */
1385 do {
a9fc2510
NA		 1386 if (busy)
1387 msleep_interruptible(100);
1da177e4
LT		 1388
1389 busy = 0;
1390 for (i = 0; i < slip_maxdev; i++) {
1391 dev = slip_devs[i];
1392 if (!dev)
1393 continue;
1394 sl = netdev_priv(dev);
1395 spin_lock_bh(&sl->lock);
1396 if (sl->tty) {
1397 busy++;
1398 tty_hangup(sl->tty);
1399 }
1400 spin_unlock_bh(&sl->lock);
1401 }
1402 } while (busy && time_before(jiffies, timeout));
1403
1404
1405 for (i = 0; i < slip_maxdev; i++) {
1406 dev = slip_devs[i];
1407 if (!dev)
1408 continue;
1409 slip_devs[i] = NULL;
1410
1411 sl = netdev_priv(dev);
1412 if (sl->tty) {
1413 printk(KERN_ERR "%s: tty discipline still running\n",
1414 dev->name);
1415 /* Intentionally leak the control block. */
1416 dev->destructor = NULL;
1417 }
1418
1419 unregister_netdev(dev);
1420 }
1421
1422 kfree(slip_devs);
1423 slip_devs = NULL;
1424
64ccd715 1425 if ((i = tty_unregister_ldisc(N_SLIP)))
1da177e4
LT		 1426 {
1427 printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i);
1428 }
1429}
1430
1431module_init(slip_init);
1432module_exit(slip_exit);
1433
1434#ifdef CONFIG_SLIP_SMART
1435/*
1436 * This is start of the code for multislip style line checking
1437 * added by Stanislav Voronyi. All changes before marked VSV
1438 */
1439
1440static void sl_outfill(unsigned long sls)
1441{
1442 struct slip *sl=(struct slip *)sls;
1443
1444 spin_lock(&sl->lock);
1445
1446 if (sl->tty == NULL)
1447 goto out;
1448
1449 if(sl->outfill)
1450 {
1451 if( test_bit(SLF_OUTWAIT, &sl->flags) )
1452 {
1453 /* no packets were transmitted, do outfill */
1454#ifdef CONFIG_SLIP_MODE_SLIP6
1455 unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
1456#else
1457 unsigned char s = END;
1458#endif
1459 /* put END into tty queue. Is it right ??? */
1460 if (!netif_queue_stopped(sl->dev))
1461 {
1462 /* if device busy no outfill */
1463 sl->tty->driver->write(sl->tty, &s, 1);
1464 }
1465 }
1466 else
1467 set_bit(SLF_OUTWAIT, &sl->flags);
1468
1469 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1470 }
1471out:
1472 spin_unlock(&sl->lock);
1473}
1474
1475static void sl_keepalive(unsigned long sls)
1476{
1477 struct slip *sl=(struct slip *)sls;
1478
1479 spin_lock(&sl->lock);
1480
1481 if (sl->tty == NULL)
1482 goto out;
1483
1484 if( sl->keepalive)
1485 {
1486 if(test_bit(SLF_KEEPTEST, &sl->flags))
1487 {
1488 /* keepalive still high :(, we must hangup */
1489 if( sl->outfill ) /* outfill timer must be deleted too */
1490 (void)del_timer(&sl->outfill_timer);
1491 printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
1492 tty_hangup(sl->tty); /* this must hangup tty & close slip */
1493 /* I think we need not something else */
1494 goto out;
1495 }
1496 else
1497 set_bit(SLF_KEEPTEST, &sl->flags);
1498
1499 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1500 }
1501
1502out:
1503 spin_unlock(&sl->lock);
1504}
1505
1506#endif
1507MODULE_LICENSE("GPL");
1508MODULE_ALIAS_LDISC(N_SLIP);
Linux kernel - Deliverables
This page took 0.099738 seconds and 5 git commands to generate.