1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63#define SL_CHECK_TRANSMIT
64#include <linux/module.h>
65#include <linux/moduleparam.h>
66
67#include <asm/system.h>
68#include <asm/uaccess.h>
69#include <linux/bitops.h>
70#include <linux/sched.h>
71#include <linux/string.h>
72#include <linux/mm.h>
73#include <linux/interrupt.h>
74#include <linux/in.h>
75#include <linux/tty.h>
76#include <linux/errno.h>
77#include <linux/netdevice.h>
78#include <linux/etherdevice.h>
79#include <linux/skbuff.h>
80#include <linux/rtnetlink.h>
81#include <linux/if_arp.h>
82#include <linux/if_slip.h>
83#include <linux/delay.h>
84#include <linux/init.h>
85#include "slip.h"
86#ifdef CONFIG_INET
87#include <linux/ip.h>
88#include <linux/tcp.h>
89#include <net/slhc_vj.h>
90#endif
91
92#define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"
93
94static struct net_device **slip_devs;
95
96static int slip_maxdev = SL_NRUNIT;
97module_param(slip_maxdev, int, 0);
98MODULE_PARM_DESC(slip_maxdev, "Maximum number of slip devices");
99
100static int slip_esc(unsigned char *p, unsigned char *d, int len);
101static void slip_unesc(struct slip *sl, unsigned char c);
102#ifdef CONFIG_SLIP_MODE_SLIP6
103static int slip_esc6(unsigned char *p, unsigned char *d, int len);
104static void slip_unesc6(struct slip *sl, unsigned char c);
105#endif
106#ifdef CONFIG_SLIP_SMART
107static void sl_keepalive(unsigned long sls);
108static void sl_outfill(unsigned long sls);
109static int sl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
110#endif
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127static int sl_alloc_bufs(struct slip *sl, int mtu)
128{
129 int err = -ENOBUFS;
130 unsigned long len;
131 char *rbuff = NULL;
132 char *xbuff = NULL;
133#ifdef SL_INCLUDE_CSLIP
134 char *cbuff = NULL;
135 struct slcompress *slcomp = NULL;
136#endif
137
138
139
140
141
142
143
144
145 len = mtu * 2;
146
147
148
149
150
151
152 if (len < 576 * 2)
153 len = 576 * 2;
154 rbuff = kmalloc(len + 4, GFP_KERNEL);
155 if (rbuff == NULL)
156 goto err_exit;
157 xbuff = kmalloc(len + 4, GFP_KERNEL);
158 if (xbuff == NULL)
159 goto err_exit;
160#ifdef SL_INCLUDE_CSLIP
161 cbuff = kmalloc(len + 4, GFP_KERNEL);
162 if (cbuff == NULL)
163 goto err_exit;
164 slcomp = slhc_init(16, 16);
165 if (slcomp == NULL)
166 goto err_exit;
167#endif
168 spin_lock_bh(&sl->lock);
169 if (sl->tty == NULL) {
170 spin_unlock_bh(&sl->lock);
171 err = -ENODEV;
172 goto err_exit;
173 }
174 sl->mtu = mtu;
175 sl->buffsize = len;
176 sl->rcount = 0;
177 sl->xleft = 0;
178 rbuff = xchg(&sl->rbuff, rbuff);
179 xbuff = xchg(&sl->xbuff, xbuff);
180#ifdef SL_INCLUDE_CSLIP
181 cbuff = xchg(&sl->cbuff, cbuff);
182 slcomp = xchg(&sl->slcomp, slcomp);
183#ifdef CONFIG_SLIP_MODE_SLIP6
184 sl->xdata = 0;
185 sl->xbits = 0;
186#endif
187#endif
188 spin_unlock_bh(&sl->lock);
189 err = 0;
190
191
192err_exit:
193#ifdef SL_INCLUDE_CSLIP
194 kfree(cbuff);
195 if (slcomp)
196 slhc_free(slcomp);
197#endif
198 kfree(xbuff);
199 kfree(rbuff);
200 return err;
201}
202
203
204static void sl_free_bufs(struct slip *sl)
205{
206
207 kfree(xchg(&sl->rbuff, NULL));
208 kfree(xchg(&sl->xbuff, NULL));
209#ifdef SL_INCLUDE_CSLIP
210 kfree(xchg(&sl->cbuff, NULL));
211 slhc_free(xchg(&sl->slcomp, NULL));
212#endif
213}
214
215
216
217
218
219static int sl_realloc_bufs(struct slip *sl, int mtu)
220{
221 int err = 0;
222 struct net_device *dev = sl->dev;
223 unsigned char *xbuff, *rbuff;
224#ifdef SL_INCLUDE_CSLIP
225 unsigned char *cbuff;
226#endif
227 int len = mtu * 2;
228
229
230
231
232
233
234 if (len < 576 * 2)
235 len = 576 * 2;
236
237 xbuff = kmalloc(len + 4, GFP_ATOMIC);
238 rbuff = kmalloc(len + 4, GFP_ATOMIC);
239#ifdef SL_INCLUDE_CSLIP
240 cbuff = kmalloc(len + 4, GFP_ATOMIC);
241#endif
242
243
244#ifdef SL_INCLUDE_CSLIP
245 if (xbuff == NULL || rbuff == NULL || cbuff == NULL) {
246#else
247 if (xbuff == NULL || rbuff == NULL) {
248#endif
249 if (mtu >= sl->mtu) {
250 printk(KERN_WARNING "%s: unable to grow slip buffers, MTU change cancelled.\n",
251 dev->name);
252 err = -ENOBUFS;
253 }
254 goto done;
255 }
256 spin_lock_bh(&sl->lock);
257
258 err = -ENODEV;
259 if (sl->tty == NULL)
260 goto done_on_bh;
261
262 xbuff = xchg(&sl->xbuff, xbuff);
263 rbuff = xchg(&sl->rbuff, rbuff);
264#ifdef SL_INCLUDE_CSLIP
265 cbuff = xchg(&sl->cbuff, cbuff);
266#endif
267 if (sl->xleft) {
268 if (sl->xleft <= len) {
269 memcpy(sl->xbuff, sl->xhead, sl->xleft);
270 } else {
271 sl->xleft = 0;
272 sl->tx_dropped++;
273 }
274 }
275 sl->xhead = sl->xbuff;
276
277 if (sl->rcount) {
278 if (sl->rcount <= len) {
279 memcpy(sl->rbuff, rbuff, sl->rcount);
280 } else {
281 sl->rcount = 0;
282 sl->rx_over_errors++;
283 set_bit(SLF_ERROR, &sl->flags);
284 }
285 }
286 sl->mtu = mtu;
287 dev->mtu = mtu;
288 sl->buffsize = len;
289 err = 0;
290
291done_on_bh:
292 spin_unlock_bh(&sl->lock);
293
294done:
295 kfree(xbuff);
296 kfree(rbuff);
297#ifdef SL_INCLUDE_CSLIP
298 kfree(cbuff);
299#endif
300 return err;
301}
302
303
304
305static inline void sl_lock(struct slip *sl)
306{
307 netif_stop_queue(sl->dev);
308}
309
310
311
312static inline void sl_unlock(struct slip *sl)
313{
314 netif_wake_queue(sl->dev);
315}
316
317
318static void sl_bump(struct slip *sl)
319{
320 struct sk_buff *skb;
321 int count;
322
323 count = sl->rcount;
324#ifdef SL_INCLUDE_CSLIP
325 if (sl->mode & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) {
326 unsigned char c = sl->rbuff[0];
327 if (c & SL_TYPE_COMPRESSED_TCP) {
328
329 if (!(sl->mode & SL_MODE_CSLIP)) {
330 printk(KERN_WARNING "%s: compressed packet ignored\n", sl->dev->name);
331 return;
332 }
333
334
335 if (count + 80 > sl->buffsize) {
336 sl->rx_over_errors++;
337 return;
338 }
339 count = slhc_uncompress(sl->slcomp, sl->rbuff, count);
340 if (count <= 0)
341 return;
342 } else if (c >= SL_TYPE_UNCOMPRESSED_TCP) {
343 if (!(sl->mode & SL_MODE_CSLIP)) {
344
345 sl->mode |= SL_MODE_CSLIP;
346 sl->mode &= ~SL_MODE_ADAPTIVE;
347 printk(KERN_INFO "%s: header compression turned on\n", sl->dev->name);
348 }
349 sl->rbuff[0] &= 0x4f;
350 if (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0)
351 return;
352 }
353 }
354#endif
355
356 sl->rx_bytes += count;
357
358 skb = dev_alloc_skb(count);
359 if (skb == NULL) {
360 printk(KERN_WARNING "%s: memory squeeze, dropping packet.\n", sl->dev->name);
361 sl->rx_dropped++;
362 return;
363 }
364 skb->dev = sl->dev;
365 memcpy(skb_put(skb, count), sl->rbuff, count);
366 skb_reset_mac_header(skb);
367 skb->protocol = htons(ETH_P_IP);
368 netif_rx(skb);
369 sl->rx_packets++;
370}
371
372
373static void sl_encaps(struct slip *sl, unsigned char *icp, int len)
374{
375 unsigned char *p;
376 int actual, count;
377
378 if (len > sl->mtu) {
379 printk(KERN_WARNING "%s: truncating oversized transmit packet!\n", sl->dev->name);
380 sl->tx_dropped++;
381 sl_unlock(sl);
382 return;
383 }
384
385 p = icp;
386#ifdef SL_INCLUDE_CSLIP
387 if (sl->mode & SL_MODE_CSLIP)
388 len = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
389#endif
390#ifdef CONFIG_SLIP_MODE_SLIP6
391 if (sl->mode & SL_MODE_SLIP6)
392 count = slip_esc6(p, (unsigned char *) sl->xbuff, len);
393 else
394#endif
395 count = slip_esc(p, (unsigned char *) sl->xbuff, len);
396
397
398
399
400
401
402
403
404
405 set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
406 actual = sl->tty->ops->write(sl->tty, sl->xbuff, count);
407#ifdef SL_CHECK_TRANSMIT
408 sl->dev->trans_start = jiffies;
409#endif
410 sl->xleft = count - actual;
411 sl->xhead = sl->xbuff + actual;
412#ifdef CONFIG_SLIP_SMART
413
414 clear_bit(SLF_OUTWAIT, &sl->flags);
415#endif
416}
417
418
419
420
421
422static void slip_write_wakeup(struct tty_struct *tty)
423{
424 int actual;
425 struct slip *sl = tty->disc_data;
426
427
428 if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
429 return;
430
431 if (sl->xleft <= 0) {
432
433
434 sl->tx_packets++;
435 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
436 sl_unlock(sl);
437 return;
438 }
439
440 actual = tty->ops->write(tty, sl->xhead, sl->xleft);
441 sl->xleft -= actual;
442 sl->xhead += actual;
443}
444
445static void sl_tx_timeout(struct net_device *dev)
446{
447 struct slip *sl = netdev_priv(dev);
448
449 spin_lock(&sl->lock);
450
451 if (netif_queue_stopped(dev)) {
452 if (!netif_running(dev))
453 goto out;
454
455
456
457
458#ifdef SL_CHECK_TRANSMIT
459 if (time_before(jiffies, dev->trans_start + 20 * HZ)) {
460
461 goto out;
462 }
463 printk(KERN_WARNING "%s: transmit timed out, %s?\n",
464 dev->name,
465 (tty_chars_in_buffer(sl->tty) || sl->xleft) ?
466 "bad line quality" : "driver error");
467 sl->xleft = 0;
468 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
469 sl_unlock(sl);
470#endif
471 }
472out:
473 spin_unlock(&sl->lock);
474}
475
476
477
478static netdev_tx_t
479sl_xmit(struct sk_buff *skb, struct net_device *dev)
480{
481 struct slip *sl = netdev_priv(dev);
482
483 spin_lock(&sl->lock);
484 if (!netif_running(dev)) {
485 spin_unlock(&sl->lock);
486 printk(KERN_WARNING "%s: xmit call when iface is down\n", dev->name);
487 dev_kfree_skb(skb);
488 return NETDEV_TX_OK;
489 }
490 if (sl->tty == NULL) {
491 spin_unlock(&sl->lock);
492 dev_kfree_skb(skb);
493 return NETDEV_TX_OK;
494 }
495
496 sl_lock(sl);
497 sl->tx_bytes += skb->len;
498 sl_encaps(sl, skb->data, skb->len);
499 spin_unlock(&sl->lock);
500
501 dev_kfree_skb(skb);
502 return NETDEV_TX_OK;
503}
504
505
506
507
508
509
510
511
512static int
513sl_close(struct net_device *dev)
514{
515 struct slip *sl = netdev_priv(dev);
516
517 spin_lock_bh(&sl->lock);
518 if (sl->tty)
519
520 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
521 netif_stop_queue(dev);
522 sl->rcount = 0;
523 sl->xleft = 0;
524 spin_unlock_bh(&sl->lock);
525
526 return 0;
527}
528
529
530
531static int sl_open(struct net_device *dev)
532{
533 struct slip *sl = netdev_priv(dev);
534
535 if (sl->tty == NULL)
536 return -ENODEV;
537
538 sl->flags &= (1 << SLF_INUSE);
539 netif_start_queue(dev);
540 return 0;
541}
542
543
544
545static int sl_change_mtu(struct net_device *dev, int new_mtu)
546{
547 struct slip *sl = netdev_priv(dev);
548
549 if (new_mtu < 68 || new_mtu > 65534)
550 return -EINVAL;
551
552 if (new_mtu != dev->mtu)
553 return sl_realloc_bufs(sl, new_mtu);
554 return 0;
555}
556
557
558
559static struct net_device_stats *
560sl_get_stats(struct net_device *dev)
561{
562 static struct net_device_stats stats;
563 struct slip *sl = netdev_priv(dev);
564#ifdef SL_INCLUDE_CSLIP
565 struct slcompress *comp;
566#endif
567
568 memset(&stats, 0, sizeof(struct net_device_stats));
569
570 stats.rx_packets = sl->rx_packets;
571 stats.tx_packets = sl->tx_packets;
572 stats.rx_bytes = sl->rx_bytes;
573 stats.tx_bytes = sl->tx_bytes;
574 stats.rx_dropped = sl->rx_dropped;
575 stats.tx_dropped = sl->tx_dropped;
576 stats.tx_errors = sl->tx_errors;
577 stats.rx_errors = sl->rx_errors;
578 stats.rx_over_errors = sl->rx_over_errors;
579#ifdef SL_INCLUDE_CSLIP
580 stats.rx_fifo_errors = sl->rx_compressed;
581 stats.tx_fifo_errors = sl->tx_compressed;
582 stats.collisions = sl->tx_misses;
583 comp = sl->slcomp;
584 if (comp) {
585 stats.rx_fifo_errors += comp->sls_i_compressed;
586 stats.rx_dropped += comp->sls_i_tossed;
587 stats.tx_fifo_errors += comp->sls_o_compressed;
588 stats.collisions += comp->sls_o_misses;
589 }
590#endif
591 return (&stats);
592}
593
594
595
596static int sl_init(struct net_device *dev)
597{
598 struct slip *sl = netdev_priv(dev);
599
600
601
602
603
604 dev->mtu = sl->mtu;
605 dev->type = ARPHRD_SLIP + sl->mode;
606#ifdef SL_CHECK_TRANSMIT
607 dev->watchdog_timeo = 20*HZ;
608#endif
609 return 0;
610}
611
612
613static void sl_uninit(struct net_device *dev)
614{
615 struct slip *sl = netdev_priv(dev);
616
617 sl_free_bufs(sl);
618}
619
620
621static void sl_free_netdev(struct net_device *dev)
622{
623 int i = dev->base_addr;
624 free_netdev(dev);
625 slip_devs[i] = NULL;
626}
627
628static const struct net_device_ops sl_netdev_ops = {
629 .ndo_init = sl_init,
630 .ndo_uninit = sl_uninit,
631 .ndo_open = sl_open,
632 .ndo_stop = sl_close,
633 .ndo_start_xmit = sl_xmit,
634 .ndo_get_stats = sl_get_stats,
635 .ndo_change_mtu = sl_change_mtu,
636 .ndo_tx_timeout = sl_tx_timeout,
637#ifdef CONFIG_SLIP_SMART
638 .ndo_do_ioctl = sl_ioctl,
639#endif
640};
641
642
643static void sl_setup(struct net_device *dev)
644{
645 dev->netdev_ops = &sl_netdev_ops;
646 dev->destructor = sl_free_netdev;
647
648 dev->hard_header_len = 0;
649 dev->addr_len = 0;
650 dev->tx_queue_len = 10;
651
652
653 dev->flags = IFF_NOARP|IFF_POINTOPOINT|IFF_MULTICAST;
654}
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
671 char *fp, int count)
672{
673 struct slip *sl = tty->disc_data;
674
675 if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
676 return;
677
678
679 while (count--) {
680 if (fp && *fp++) {
681 if (!test_and_set_bit(SLF_ERROR, &sl->flags))
682 sl->rx_errors++;
683 cp++;
684 continue;
685 }
686#ifdef CONFIG_SLIP_MODE_SLIP6
687 if (sl->mode & SL_MODE_SLIP6)
688 slip_unesc6(sl, *cp++);
689 else
690#endif
691 slip_unesc(sl, *cp++);
692 }
693}
694
695
696
697
698
699
700static void sl_sync(void)
701{
702 int i;
703 struct net_device *dev;
704 struct slip *sl;
705
706 for (i = 0; i < slip_maxdev; i++) {
707 dev = slip_devs[i];
708 if (dev == NULL)
709 break;
710
711 sl = netdev_priv(dev);
712 if (sl->tty || sl->leased)
713 continue;
714 if (dev->flags & IFF_UP)
715 dev_close(dev);
716 }
717}
718
719
720
721static struct slip *sl_alloc(dev_t line)
722{
723 int i;
724 struct net_device *dev = NULL;
725 struct slip *sl;
726
727 if (slip_devs == NULL)
728 return NULL;
729
730 for (i = 0; i < slip_maxdev; i++) {
731 dev = slip_devs[i];
732 if (dev == NULL)
733 break;
734 }
735
736 if (i >= slip_maxdev)
737 return NULL;
738
739 if (dev) {
740 sl = netdev_priv(dev);
741 if (test_bit(SLF_INUSE, &sl->flags)) {
742 unregister_netdevice(dev);
743 dev = NULL;
744 slip_devs[i] = NULL;
745 }
746 }
747
748 if (!dev) {
749 char name[IFNAMSIZ];
750 sprintf(name, "sl%d", i);
751
752 dev = alloc_netdev(sizeof(*sl), name, sl_setup);
753 if (!dev)
754 return NULL;
755 dev->base_addr = i;
756 }
757
758 sl = netdev_priv(dev);
759
760
761 sl->magic = SLIP_MAGIC;
762 sl->dev = dev;
763 spin_lock_init(&sl->lock);
764 sl->mode = SL_MODE_DEFAULT;
765#ifdef CONFIG_SLIP_SMART
766
767 init_timer(&sl->keepalive_timer);
768 sl->keepalive_timer.data = (unsigned long)sl;
769 sl->keepalive_timer.function = sl_keepalive;
770 init_timer(&sl->outfill_timer);
771 sl->outfill_timer.data = (unsigned long)sl;
772 sl->outfill_timer.function = sl_outfill;
773#endif
774 slip_devs[i] = dev;
775 return sl;
776}
777
778
779
780
781
782
783
784
785
786
787
788static int slip_open(struct tty_struct *tty)
789{
790 struct slip *sl;
791 int err;
792
793 if (!capable(CAP_NET_ADMIN))
794 return -EPERM;
795
796 if (tty->ops->write == NULL)
797 return -EOPNOTSUPP;
798
799
800
801
802
803 rtnl_lock();
804
805
806 sl_sync();
807
808 sl = tty->disc_data;
809
810 err = -EEXIST;
811
812 if (sl && sl->magic == SLIP_MAGIC)
813 goto err_exit;
814
815
816 err = -ENFILE;
817 sl = sl_alloc(tty_devnum(tty));
818 if (sl == NULL)
819 goto err_exit;
820
821 sl->tty = tty;
822 tty->disc_data = sl;
823 sl->line = tty_devnum(tty);
824 sl->pid = current->pid;
825
826 if (!test_bit(SLF_INUSE, &sl->flags)) {
827
828 err = sl_alloc_bufs(sl, SL_MTU);
829 if (err)
830 goto err_free_chan;
831
832 set_bit(SLF_INUSE, &sl->flags);
833
834 err = register_netdevice(sl->dev);
835 if (err)
836 goto err_free_bufs;
837 }
838
839#ifdef CONFIG_SLIP_SMART
840 if (sl->keepalive) {
841 sl->keepalive_timer.expires = jiffies + sl->keepalive * HZ;
842 add_timer(&sl->keepalive_timer);
843 }
844 if (sl->outfill) {
845 sl->outfill_timer.expires = jiffies + sl->outfill * HZ;
846 add_timer(&sl->outfill_timer);
847 }
848#endif
849
850
851 rtnl_unlock();
852 tty->receive_room = 65536;
853 return sl->dev->base_addr;
854
855err_free_bufs:
856 sl_free_bufs(sl);
857
858err_free_chan:
859 sl->tty = NULL;
860 tty->disc_data = NULL;
861 clear_bit(SLF_INUSE, &sl->flags);
862
863err_exit:
864 rtnl_unlock();
865
866
867 return err;
868}
869
870
871
872
873
874
875
876
877
878static void slip_close(struct tty_struct *tty)
879{
880 struct slip *sl = tty->disc_data;
881
882
883 if (!sl || sl->magic != SLIP_MAGIC || sl->tty != tty)
884 return;
885
886 tty->disc_data = NULL;
887 sl->tty = NULL;
888 if (!sl->leased)
889 sl->line = 0;
890
891
892#ifdef CONFIG_SLIP_SMART
893 del_timer_sync(&sl->keepalive_timer);
894 del_timer_sync(&sl->outfill_timer);
895#endif
896
897 unregister_netdev(sl->dev);
898
899}
900
901static int slip_hangup(struct tty_struct *tty)
902{
903 slip_close(tty);
904 return 0;
905}
906
907
908
909
910static int slip_esc(unsigned char *s, unsigned char *d, int len)
911{
912 unsigned char *ptr = d;
913 unsigned char c;
914
915
916
917
918
919
920
921 *ptr++ = END;
922
923
924
925
926
927
928 while (len-- > 0) {
929 switch (c = *s++) {
930 case END:
931 *ptr++ = ESC;
932 *ptr++ = ESC_END;
933 break;
934 case ESC:
935 *ptr++ = ESC;
936 *ptr++ = ESC_ESC;
937 break;
938 default:
939 *ptr++ = c;
940 break;
941 }
942 }
943 *ptr++ = END;
944 return (ptr - d);
945}
946
947static void slip_unesc(struct slip *sl, unsigned char s)
948{
949
950 switch (s) {
951 case END:
952#ifdef CONFIG_SLIP_SMART
953
954 if (test_bit(SLF_KEEPTEST, &sl->flags))
955 clear_bit(SLF_KEEPTEST, &sl->flags);
956#endif
957
958 if (!test_and_clear_bit(SLF_ERROR, &sl->flags)
959 && (sl->rcount > 2))
960 sl_bump(sl);
961 clear_bit(SLF_ESCAPE, &sl->flags);
962 sl->rcount = 0;
963 return;
964
965 case ESC:
966 set_bit(SLF_ESCAPE, &sl->flags);
967 return;
968 case ESC_ESC:
969 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
970 s = ESC;
971 break;
972 case ESC_END:
973 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
974 s = END;
975 break;
976 }
977 if (!test_bit(SLF_ERROR, &sl->flags)) {
978 if (sl->rcount < sl->buffsize) {
979 sl->rbuff[sl->rcount++] = s;
980 return;
981 }
982 sl->rx_over_errors++;
983 set_bit(SLF_ERROR, &sl->flags);
984 }
985}
986
987
988#ifdef CONFIG_SLIP_MODE_SLIP6
989
990
991
992
993static int slip_esc6(unsigned char *s, unsigned char *d, int len)
994{
995 unsigned char *ptr = d;
996 unsigned char c;
997 int i;
998 unsigned short v = 0;
999 short bits = 0;
1000
1001
1002
1003
1004
1005
1006
1007 *ptr++ = 0x70;
1008
1009
1010
1011
1012
1013 for (i = 0; i < len; ++i) {
1014 v = (v << 8) | s[i];
1015 bits += 8;
1016 while (bits >= 6) {
1017 bits -= 6;
1018 c = 0x30 + ((v >> bits) & 0x3F);
1019 *ptr++ = c;
1020 }
1021 }
1022 if (bits) {
1023 c = 0x30 + ((v << (6 - bits)) & 0x3F);
1024 *ptr++ = c;
1025 }
1026 *ptr++ = 0x70;
1027 return ptr - d;
1028}
1029
1030static void slip_unesc6(struct slip *sl, unsigned char s)
1031{
1032 unsigned char c;
1033
1034 if (s == 0x70) {
1035#ifdef CONFIG_SLIP_SMART
1036
1037 if (test_bit(SLF_KEEPTEST, &sl->flags))
1038 clear_bit(SLF_KEEPTEST, &sl->flags);
1039#endif
1040
1041 if (!test_and_clear_bit(SLF_ERROR, &sl->flags)
1042 && (sl->rcount > 2))
1043 sl_bump(sl);
1044 sl->rcount = 0;
1045 sl->xbits = 0;
1046 sl->xdata = 0;
1047 } else if (s >= 0x30 && s < 0x70) {
1048 sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
1049 sl->xbits += 6;
1050 if (sl->xbits >= 8) {
1051 sl->xbits -= 8;
1052 c = (unsigned char)(sl->xdata >> sl->xbits);
1053 if (!test_bit(SLF_ERROR, &sl->flags)) {
1054 if (sl->rcount < sl->buffsize) {
1055 sl->rbuff[sl->rcount++] = c;
1056 return;
1057 }
1058 sl->rx_over_errors++;
1059 set_bit(SLF_ERROR, &sl->flags);
1060 }
1061 }
1062 }
1063}
1064#endif
1065
1066
1067static int slip_ioctl(struct tty_struct *tty, struct file *file,
1068 unsigned int cmd, unsigned long arg)
1069{
1070 struct slip *sl = tty->disc_data;
1071 unsigned int tmp;
1072 int __user *p = (int __user *)arg;
1073
1074
1075 if (!sl || sl->magic != SLIP_MAGIC)
1076 return -EINVAL;
1077
1078 switch (cmd) {
1079 case SIOCGIFNAME:
1080 tmp = strlen(sl->dev->name) + 1;
1081 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1082 return -EFAULT;
1083 return 0;
1084
1085 case SIOCGIFENCAP:
1086 if (put_user(sl->mode, p))
1087 return -EFAULT;
1088 return 0;
1089
1090 case SIOCSIFENCAP:
1091 if (get_user(tmp, p))
1092 return -EFAULT;
1093#ifndef SL_INCLUDE_CSLIP
1094 if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE))
1095 return -EINVAL;
1096#else
1097 if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
1098 (SL_MODE_ADAPTIVE | SL_MODE_CSLIP))
1099
1100 tmp &= ~SL_MODE_ADAPTIVE;
1101#endif
1102#ifndef CONFIG_SLIP_MODE_SLIP6
1103 if (tmp & SL_MODE_SLIP6)
1104 return -EINVAL;
1105#endif
1106 sl->mode = tmp;
1107 sl->dev->type = ARPHRD_SLIP + sl->mode;
1108 return 0;
1109
1110 case SIOCSIFHWADDR:
1111 return -EINVAL;
1112
1113#ifdef CONFIG_SLIP_SMART
1114
1115 case SIOCSKEEPALIVE:
1116 if (get_user(tmp, p))
1117 return -EFAULT;
1118 if (tmp > 255)
1119 return -EINVAL;
1120
1121 spin_lock_bh(&sl->lock);
1122 if (!sl->tty) {
1123 spin_unlock_bh(&sl->lock);
1124 return -ENODEV;
1125 }
1126 sl->keepalive = (u8)tmp;
1127 if (sl->keepalive != 0) {
1128 mod_timer(&sl->keepalive_timer,
1129 jiffies + sl->keepalive * HZ);
1130 set_bit(SLF_KEEPTEST, &sl->flags);
1131 } else
1132 del_timer(&sl->keepalive_timer);
1133 spin_unlock_bh(&sl->lock);
1134 return 0;
1135
1136 case SIOCGKEEPALIVE:
1137 if (put_user(sl->keepalive, p))
1138 return -EFAULT;
1139 return 0;
1140
1141 case SIOCSOUTFILL:
1142 if (get_user(tmp, p))
1143 return -EFAULT;
1144 if (tmp > 255)
1145 return -EINVAL;
1146 spin_lock_bh(&sl->lock);
1147 if (!sl->tty) {
1148 spin_unlock_bh(&sl->lock);
1149 return -ENODEV;
1150 }
1151 sl->outfill = (u8)tmp;
1152 if (sl->outfill != 0) {
1153 mod_timer(&sl->outfill_timer,
1154 jiffies + sl->outfill * HZ);
1155 set_bit(SLF_OUTWAIT, &sl->flags);
1156 } else
1157 del_timer(&sl->outfill_timer);
1158 spin_unlock_bh(&sl->lock);
1159 return 0;
1160
1161 case SIOCGOUTFILL:
1162 if (put_user(sl->outfill, p))
1163 return -EFAULT;
1164 return 0;
1165
1166#endif
1167 default:
1168 return tty_mode_ioctl(tty, file, cmd, arg);
1169 }
1170}
1171
1172
1173#ifdef CONFIG_SLIP_SMART
1174
1175
1176
1177
1178static int sl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1179{
1180 struct slip *sl = netdev_priv(dev);
1181 unsigned long *p = (unsigned long *)&rq->ifr_ifru;
1182
1183 if (sl == NULL)
1184 return -ENODEV;
1185
1186 spin_lock_bh(&sl->lock);
1187
1188 if (!sl->tty) {
1189 spin_unlock_bh(&sl->lock);
1190 return -ENODEV;
1191 }
1192
1193 switch (cmd) {
1194 case SIOCSKEEPALIVE:
1195
1196 if ((unsigned)*p > 255) {
1197 spin_unlock_bh(&sl->lock);
1198 return -EINVAL;
1199 }
1200 sl->keepalive = (u8)*p;
1201 if (sl->keepalive != 0) {
1202 sl->keepalive_timer.expires =
1203 jiffies + sl->keepalive * HZ;
1204 mod_timer(&sl->keepalive_timer,
1205 jiffies + sl->keepalive * HZ);
1206 set_bit(SLF_KEEPTEST, &sl->flags);
1207 } else
1208 del_timer(&sl->keepalive_timer);
1209 break;
1210
1211 case SIOCGKEEPALIVE:
1212 *p = sl->keepalive;
1213 break;
1214
1215 case SIOCSOUTFILL:
1216 if ((unsigned)*p > 255) {
1217 spin_unlock_bh(&sl->lock);
1218 return -EINVAL;
1219 }
1220 sl->outfill = (u8)*p;
1221 if (sl->outfill != 0) {
1222 mod_timer(&sl->outfill_timer,
1223 jiffies + sl->outfill * HZ);
1224 set_bit(SLF_OUTWAIT, &sl->flags);
1225 } else
1226 del_timer(&sl->outfill_timer);
1227 break;
1228
1229 case SIOCGOUTFILL:
1230 *p = sl->outfill;
1231 break;
1232
1233 case SIOCSLEASE:
1234
1235
1236
1237 if (sl->tty != current->signal->tty &&
1238 sl->pid != current->pid) {
1239 spin_unlock_bh(&sl->lock);
1240 return -EPERM;
1241 }
1242 sl->leased = 0;
1243 if (*p)
1244 sl->leased = 1;
1245 break;
1246
1247 case SIOCGLEASE:
1248 *p = sl->leased;
1249 };
1250 spin_unlock_bh(&sl->lock);
1251 return 0;
1252}
1253#endif
1254
1255
1256static struct tty_ldisc_ops sl_ldisc = {
1257 .owner = THIS_MODULE,
1258 .magic = TTY_LDISC_MAGIC,
1259 .name = "slip",
1260 .open = slip_open,
1261 .close = slip_close,
1262 .hangup = slip_hangup,
1263 .ioctl = slip_ioctl,
1264 .receive_buf = slip_receive_buf,
1265 .write_wakeup = slip_write_wakeup,
1266};
1267
1268static int __init slip_init(void)
1269{
1270 int status;
1271
1272 if (slip_maxdev < 4)
1273 slip_maxdev = 4;
1274
1275 printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)"
1276#ifdef CONFIG_SLIP_MODE_SLIP6
1277 " (6 bit encapsulation enabled)"
1278#endif
1279 ".\n",
1280 SLIP_VERSION, slip_maxdev);
1281#if defined(SL_INCLUDE_CSLIP)
1282 printk(KERN_INFO "CSLIP: code copyright 1989 Regents of the University of California.\n");
1283#endif
1284#ifdef CONFIG_SLIP_SMART
1285 printk(KERN_INFO "SLIP linefill/keepalive option.\n");
1286#endif
1287
1288 slip_devs = kzalloc(sizeof(struct net_device *)*slip_maxdev,
1289 GFP_KERNEL);
1290 if (!slip_devs) {
1291 printk(KERN_ERR "SLIP: Can't allocate slip devices array.\n");
1292 return -ENOMEM;
1293 }
1294
1295
1296 status = tty_register_ldisc(N_SLIP, &sl_ldisc);
1297 if (status != 0) {
1298 printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status);
1299 kfree(slip_devs);
1300 }
1301 return status;
1302}
1303
1304static void __exit slip_exit(void)
1305{
1306 int i;
1307 struct net_device *dev;
1308 struct slip *sl;
1309 unsigned long timeout = jiffies + HZ;
1310 int busy = 0;
1311
1312 if (slip_devs == NULL)
1313 return;
1314
1315
1316
1317 do {
1318 if (busy)
1319 msleep_interruptible(100);
1320
1321 busy = 0;
1322 for (i = 0; i < slip_maxdev; i++) {
1323 dev = slip_devs[i];
1324 if (!dev)
1325 continue;
1326 sl = netdev_priv(dev);
1327 spin_lock_bh(&sl->lock);
1328 if (sl->tty) {
1329 busy++;
1330 tty_hangup(sl->tty);
1331 }
1332 spin_unlock_bh(&sl->lock);
1333 }
1334 } while (busy && time_before(jiffies, timeout));
1335
1336
1337
1338
1339 for (i = 0; i < slip_maxdev; i++) {
1340 dev = slip_devs[i];
1341 if (!dev)
1342 continue;
1343 slip_devs[i] = NULL;
1344
1345 sl = netdev_priv(dev);
1346 if (sl->tty) {
1347 printk(KERN_ERR "%s: tty discipline still running\n",
1348 dev->name);
1349
1350 dev->destructor = NULL;
1351 }
1352
1353 unregister_netdev(dev);
1354 }
1355
1356 kfree(slip_devs);
1357 slip_devs = NULL;
1358
1359 i = tty_unregister_ldisc(N_SLIP);
1360 if (i != 0)
1361 printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i);
1362}
1363
1364module_init(slip_init);
1365module_exit(slip_exit);
1366
1367#ifdef CONFIG_SLIP_SMART
1368
1369
1370
1371
1372
1373static void sl_outfill(unsigned long sls)
1374{
1375 struct slip *sl = (struct slip *)sls;
1376
1377 spin_lock(&sl->lock);
1378
1379 if (sl->tty == NULL)
1380 goto out;
1381
1382 if (sl->outfill) {
1383 if (test_bit(SLF_OUTWAIT, &sl->flags)) {
1384
1385#ifdef CONFIG_SLIP_MODE_SLIP6
1386 unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
1387#else
1388 unsigned char s = END;
1389#endif
1390
1391 if (!netif_queue_stopped(sl->dev)) {
1392
1393 sl->tty->ops->write(sl->tty, &s, 1);
1394 }
1395 } else
1396 set_bit(SLF_OUTWAIT, &sl->flags);
1397
1398 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1399 }
1400out:
1401 spin_unlock(&sl->lock);
1402}
1403
1404static void sl_keepalive(unsigned long sls)
1405{
1406 struct slip *sl = (struct slip *)sls;
1407
1408 spin_lock(&sl->lock);
1409
1410 if (sl->tty == NULL)
1411 goto out;
1412
1413 if (sl->keepalive) {
1414 if (test_bit(SLF_KEEPTEST, &sl->flags)) {
1415
1416 if (sl->outfill)
1417
1418 (void)del_timer(&sl->outfill_timer);
1419 printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
1420
1421 tty_hangup(sl->tty);
1422
1423 goto out;
1424 } else
1425 set_bit(SLF_KEEPTEST, &sl->flags);
1426
1427 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1428 }
1429out:
1430 spin_unlock(&sl->lock);
1431}
1432
1433#endif
1434MODULE_LICENSE("GPL");
1435MODULE_ALIAS_LDISC(N_SLIP);
1436