This source file includes following definitions.
- sl_alloc
- sl_free
- sl_changedmtu
- sl_lock
- sl_unlock
- sl_bump
- sl_encaps
- slip_write_wakeup
- sl_xmit
- sl_type_trans
- sl_header
- sl_rebuild_header
- sl_open
- sl_close
- slip_receive_room
- slip_receive_buf
- slip_open
- slip_close
- sl_get_stats
- slip_esc
- slip_unesc
- slip_esc6
- slip_unesc6
- sl_set_mac_address
- sl_set_dev_mac_address
- slip_ioctl
- slip_init
- init_module
- cleanup_module
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 #define SL_CHECK_TRANSMIT
47 #include <linux/config.h>
48
49 #ifdef SL_COMPRESSED
50
51
52
53 #define CONFIG_SLIP_COMPRESSED
54 #endif
55
56 #define CONFIG_SLIP_MODE_SLIP6
57
58 #include <asm/system.h>
59 #include <asm/segment.h>
60 #include <asm/bitops.h>
61 #include <linux/string.h>
62 #include <linux/mm.h>
63 #include <linux/interrupt.h>
64 #include <linux/in.h>
65 #include <linux/tty.h>
66 #include <linux/errno.h>
67 #include <linux/netdevice.h>
68 #ifdef CONFIG_AX25
69 #include "ax25.h"
70 #endif
71 #include <linux/etherdevice.h>
72 #include <linux/skbuff.h>
73 #include <linux/if_arp.h>
74 #include "slip.h"
75 #ifdef CONFIG_INET
76 #include "ip.h"
77 #include "tcp.h"
78 #include "slhc.h"
79 #endif
80 #ifdef MODULE
81 #include <linux/module.h>
82 #include <linux/version.h>
83 #endif
84
85
86 #ifdef MODULE
87 #define SLIP_VERSION "0.8.3-NET3.019-NEWTTY-MODULAR"
88 #else
89 #define SLIP_VERSION "0.8.3-NET3.019-NEWTTY"
90 #endif
91
92
93 static struct slip sl_ctrl[SL_NRUNIT];
94 static struct tty_ldisc sl_ldisc;
95 static int already = 0;
96
97 static int slip_esc(unsigned char *p, unsigned char *d, int len);
98 static void slip_unesc(struct slip *sl, unsigned char c);
99 #ifdef CONFIG_SLIP_MODE_SLIP6
100 static int slip_esc6(unsigned char *p, unsigned char *d, int len);
101 static void slip_unesc6(struct slip *sl, unsigned char c);
102 #endif
103
104
105
106 static inline struct slip *
107 sl_alloc(void)
108 {
109 struct slip *sl;
110 int i;
111
112 for (i = 0; i < SL_NRUNIT; i++) {
113 sl = &sl_ctrl[i];
114 if (!set_bit(SLF_INUSE, &sl->flags)) {
115 return sl;
116 }
117 }
118 return NULL;
119 }
120
121
122
123 static inline void
124 sl_free(struct slip *sl)
125 {
126 if (!clear_bit(SLF_INUSE, &sl->flags)) {
127 printk("%s: sl_free for already free unit.\n", sl->dev->name);
128 }
129 }
130
131
132
133
134
135 static void sl_changedmtu(struct slip *sl)
136 {
137 struct device *dev = sl->dev;
138 unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
139 #ifdef SL_INCLUDE_CSLIP
140 unsigned char *cbuff, *ocbuff;
141 #endif
142 int len;
143 unsigned long flags;
144
145 len = dev->mtu * 2;
146
147
148
149
150
151 if (len < 576 * 2) {
152 len = 576 * 2;
153 }
154
155 xbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
156 rbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
157 #ifdef SL_INCLUDE_CSLIP
158 cbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
159 #endif
160
161 #ifdef SL_INCLUDE_CSLIP
162 if (xbuff == NULL || rbuff == NULL || cbuff == NULL) {
163 #else
164 if (xbuff == NULL || rbuff == NULL) {
165 #endif
166 printk("%s: unable to grow slip buffers, MTU change cancelled.\n",
167 sl->dev->name);
168 dev->mtu = sl->mtu;
169 if (xbuff != NULL) {
170 kfree(xbuff);
171 }
172 if (rbuff != NULL) {
173 kfree(rbuff);
174 }
175 #ifdef SL_INCLUDE_CSLIP
176 if (cbuff != NULL) {
177 kfree(cbuff);
178 }
179 #endif
180 return;
181 }
182
183 save_flags(flags); cli();
184
185 oxbuff = sl->xbuff;
186 sl->xbuff = xbuff;
187 orbuff = sl->rbuff;
188 sl->rbuff = rbuff;
189 #ifdef SL_INCLUDE_CSLIP
190 ocbuff = sl->cbuff;
191 sl->cbuff = cbuff;
192 #endif
193 if (sl->xleft) {
194 if (sl->xleft <= len) {
195 memcpy(sl->xbuff, sl->xhead, sl->xleft);
196 } else {
197 sl->xleft = 0;
198 sl->tx_dropped++;
199 }
200 }
201 sl->xhead = sl->xbuff;
202
203 if (sl->rcount) {
204 if (sl->rcount <= len) {
205 memcpy(sl->rbuff, orbuff, sl->rcount);
206 } else {
207 sl->rcount = 0;
208 sl->rx_over_errors++;
209 set_bit(SLF_ERROR, &sl->flags);
210 }
211 }
212 #ifdef CONFIG_AX25
213 sl->mtu = dev->mtu + 73;
214 #else
215 sl->mtu = dev->mtu;
216 #endif
217 sl->buffsize = len;
218
219 restore_flags(flags);
220
221 if (oxbuff != NULL) {
222 kfree(oxbuff);
223 }
224 if (orbuff != NULL) {
225 kfree(orbuff);
226 }
227 #ifdef SL_INCLUDE_CSLIP
228 if (ocbuff != NULL) {
229 kfree(ocbuff);
230 }
231 #endif
232 }
233
234
235
236 static inline void
237 sl_lock(struct slip *sl)
238 {
239 if (set_bit(0, (void *) &sl->dev->tbusy)) {
240 printk("%s: trying to lock already locked device!\n", sl->dev->name);
241 }
242 }
243
244
245
246 static inline void
247 sl_unlock(struct slip *sl)
248 {
249 if (!clear_bit(0, (void *)&sl->dev->tbusy)) {
250 printk("%s: trying to unlock already unlocked device!\n", sl->dev->name);
251 }
252 }
253
254
255 static void
256 sl_bump(struct slip *sl)
257 {
258 struct sk_buff *skb;
259 int count;
260
261 count = sl->rcount;
262 #ifdef SL_INCLUDE_CSLIP
263 if (sl->mode & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) {
264 unsigned char c;
265 if ((c = sl->rbuff[0]) & SL_TYPE_COMPRESSED_TCP) {
266
267 if (!(sl->mode & SL_MODE_CSLIP)) {
268 printk("%s: compressed packet ignored\n", sl->dev->name);
269 return;
270 }
271
272 if (count + 80 > sl->buffsize) {
273 sl->rx_over_errors++;
274 return;
275 }
276 count = slhc_uncompress(sl->slcomp, sl->rbuff, count);
277 if (count <= 0) {
278 return;
279 }
280 } else if (c >= SL_TYPE_UNCOMPRESSED_TCP) {
281 if (!(sl->mode & SL_MODE_CSLIP)) {
282
283 sl->mode |= SL_MODE_CSLIP;
284 sl->mode &= ~SL_MODE_ADAPTIVE;
285 printk("%s: header compression turned on\n", sl->dev->name);
286 }
287 sl->rbuff[0] &= 0x4f;
288 if (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0) {
289 return;
290 }
291 }
292 }
293 #endif
294
295 skb = alloc_skb(count, GFP_ATOMIC);
296 if (skb == NULL) {
297 printk("%s: memory squeeze, dropping packet.\n", sl->dev->name);
298 sl->rx_dropped++;
299 return;
300 }
301 skb->len = count;
302 skb->dev = sl->dev;
303 memcpy(skb->data, sl->rbuff, count);
304 netif_rx(skb);
305 sl->rx_packets++;
306 }
307
308
309 static void
310 sl_encaps(struct slip *sl, unsigned char *icp, int len)
311 {
312 unsigned char *p;
313 int actual, count;
314
315
316 #ifdef CONFIG_AX25
317 if (sl->mtu != sl->dev->mtu + 73) {
318 #else
319 if (sl->mtu != sl->dev->mtu) {
320 #endif
321 sl_changedmtu(sl);
322 }
323
324 if (len > sl->mtu) {
325 len = sl->mtu;
326 printk ("%s: truncating oversized transmit packet!\n", sl->dev->name);
327 sl->tx_dropped++;
328 sl_unlock(sl);
329 return;
330 }
331
332 p = icp;
333 #ifdef SL_INCLUDE_CSLIP
334 if (sl->mode & SL_MODE_CSLIP) {
335 len = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
336 }
337 #endif
338 #ifdef CONFIG_SLIP_MODE_SLIP6
339 if(sl->mode & SL_MODE_SLIP6)
340 count = slip_esc6(p, (unsigned char *) sl->xbuff, len);
341 else
342 #endif
343 count = slip_esc(p, (unsigned char *) sl->xbuff, len);
344
345
346
347
348
349
350
351
352
353 sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
354 actual = sl->tty->driver.write(sl->tty, 0, sl->xbuff, count);
355 #ifdef SL_CHECK_TRANSMIT
356 sl->dev->trans_start = jiffies;
357 #endif
358 sl->xleft = count - actual;
359 sl->xhead = sl->xbuff + actual;
360 }
361
362
363
364
365
366 static void slip_write_wakeup(struct tty_struct *tty)
367 {
368 int actual;
369 struct slip *sl = (struct slip *) tty->disc_data;
370
371
372 if (!sl || sl->magic != SLIP_MAGIC || !sl->dev->start) {
373 return;
374 }
375
376 if (sl->xleft <= 0) {
377
378
379 sl->tx_packets++;
380 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
381 sl_unlock(sl);
382 mark_bh(NET_BH);
383 return;
384 }
385
386 actual = tty->driver.write(tty, 0, sl->xhead, sl->xleft);
387 sl->xleft -= actual;
388 sl->xhead += actual;
389 }
390
391
392 static int
393 sl_xmit(struct sk_buff *skb, struct device *dev)
394 {
395 struct slip *sl = &sl_ctrl[dev->base_addr];
396
397 if (!dev->start) {
398 printk("%s: xmit call when iface is down\n", dev->name);
399 return 1;
400 }
401
402
403
404
405
406
407
408
409
410
411 if (dev->tbusy) {
412
413
414
415 #ifdef SL_CHECK_TRANSMIT
416 if (jiffies - dev->trans_start < 20 * HZ) {
417
418 return 1;
419 }
420 printk("%s: transmit timed out, %s?\n", dev->name,
421 (sl->tty->driver.chars_in_buffer(sl->tty) || sl->xleft) ?
422 "bad line quality" : "driver error");
423 sl->xleft = 0;
424 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
425 sl_unlock(sl);
426 #else
427 return 1;
428 #endif
429 }
430
431
432 if (skb != NULL) {
433 sl_lock(sl);
434 sl_encaps(sl, skb->data, skb->len);
435 dev_kfree_skb(skb, FREE_WRITE);
436 }
437 return 0;
438 }
439
440
441
442 static unsigned short
443 sl_type_trans (struct sk_buff *skb, struct device *dev)
444 {
445 #ifdef CONFIG_AX25
446 struct slip *sl = &sl_ctrl[dev->base_addr];
447
448 if (sl->mode & SL_MODE_AX25) {
449 return htons(ETH_P_AX25);
450 }
451 #endif
452 return htons(ETH_P_IP);
453 }
454
455
456
457 static int
458 sl_header(unsigned char *buff, struct device *dev, unsigned short type,
459 void *daddr, void *saddr, unsigned len, struct sk_buff *skb)
460 {
461 #ifdef CONFIG_AX25
462 #ifdef CONFIG_INET
463 struct slip *sl = &sl_ctrl[dev->base_addr];
464
465 if ((sl->mode & SL_MODE_AX25) && type != htons(ETH_P_AX25)) {
466 return ax25_encapsulate(buff, dev, type, daddr, saddr, len, skb);
467 }
468 #endif
469 #endif
470 return 0;
471 }
472
473
474
475 static int
476 sl_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
477 struct sk_buff *skb)
478 {
479 #ifdef CONFIG_AX25
480 #ifdef CONFIG_INET
481 struct slip *sl = &sl_ctrl[dev->base_addr];
482
483 if (sl->mode & SL_MODE_AX25) {
484 return ax25_rebuild_header(buff, dev, raddr, skb);
485 }
486 #endif
487 #endif
488 return 0;
489 }
490
491
492
493 static int
494 sl_open(struct device *dev)
495 {
496 struct slip *sl = &sl_ctrl[dev->base_addr];
497 unsigned long len;
498
499 if (sl->tty == NULL) {
500 return -ENODEV;
501 }
502
503
504
505
506
507
508
509
510 len = dev->mtu * 2;
511
512
513
514
515
516 if (len < 576 * 2) {
517 len = 576 * 2;
518 }
519 sl->rbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
520 if (sl->rbuff == NULL) {
521 goto norbuff;
522 }
523 sl->xbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
524 if (sl->xbuff == NULL) {
525 goto noxbuff;
526 }
527 #ifdef SL_INCLUDE_CSLIP
528 sl->cbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
529 if (sl->cbuff == NULL) {
530 goto nocbuff;
531 }
532 sl->slcomp = slhc_init(16, 16);
533 if (sl->slcomp == NULL) {
534 goto noslcomp;
535 }
536 #endif
537
538 #ifdef CONFIG_AX25
539 sl->mtu = dev->mtu + 73;
540 #else
541 sl->mtu = dev->mtu;
542 #endif
543 sl->buffsize = len;
544 sl->rcount = 0;
545 sl->xleft = 0;
546 #ifdef CONFIG_SLIP_MODE_SLIP6
547 sl->xdata = 0;
548 sl->xbits = 0;
549 #endif
550 sl->flags &= (1 << SLF_INUSE);
551
552
553 if (dev->pa_addr == 0) {
554 dev->pa_addr=ntohl(0xC0A80001);
555 }
556 dev->tbusy = 0;
557
558 dev->start = 1;
559
560 return 0;
561
562
563 #ifdef SL_INCLUDE_CSLIP
564 noslcomp:
565 kfree(sl->cbuff);
566 nocbuff:
567 #endif
568 kfree(sl->xbuff);
569 noxbuff:
570 kfree(sl->rbuff);
571 norbuff:
572 return -ENOMEM;
573 }
574
575
576
577 static int
578 sl_close(struct device *dev)
579 {
580 struct slip *sl = &sl_ctrl[dev->base_addr];
581
582 if (sl->tty == NULL) {
583 return -EBUSY;
584 }
585 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
586 dev->tbusy = 1;
587 dev->start = 0;
588
589
590
591
592 if (sl->rbuff) {
593 kfree(sl->rbuff);
594 }
595 sl->rbuff = NULL;
596 if (sl->xbuff) {
597 kfree(sl->xbuff);
598 }
599 sl->xbuff = NULL;
600 #ifdef SL_INCLUDE_CSLIP
601
602 if (sl->slcomp) {
603 sl->rx_compressed += sl->slcomp->sls_i_compressed;
604 sl->rx_dropped += sl->slcomp->sls_i_tossed;
605 sl->tx_compressed += sl->slcomp->sls_o_compressed;
606 sl->tx_misses += sl->slcomp->sls_o_misses;
607 }
608 if (sl->cbuff) {
609 kfree(sl->cbuff);
610 }
611 sl->cbuff = NULL;
612 slhc_free(sl->slcomp);
613 sl->slcomp = NULL;
614 #endif
615 return 0;
616 }
617
618 static int
619 slip_receive_room(struct tty_struct *tty)
620 {
621 return 65536;
622 }
623
624
625
626
627
628
629
630 static void
631 slip_receive_buf(struct tty_struct *tty, unsigned char *cp, char *fp, int count)
632 {
633 struct slip *sl = (struct slip *) tty->disc_data;
634
635 if (!sl || sl->magic != SLIP_MAGIC || !sl->dev->start)
636 return;
637
638
639
640
641
642 #ifdef CONFIG_AX25
643 if (sl->mtu != sl->dev->mtu + 73) {
644 #else
645 if (sl->mtu != sl->dev->mtu) {
646 #endif
647 sl_changedmtu(sl);
648 }
649
650
651 while (count--) {
652 if (fp && *fp++) {
653 if (!set_bit(SLF_ERROR, &sl->flags)) {
654 sl->rx_errors++;
655 }
656 cp++;
657 continue;
658 }
659 #ifdef CONFIG_SLIP_MODE_SLIP6
660 if (sl->mode & SL_MODE_SLIP6)
661 slip_unesc6(sl, *cp++);
662 else
663 #endif
664 slip_unesc(sl, *cp++);
665 }
666 }
667
668
669
670
671
672
673
674
675 static int
676 slip_open(struct tty_struct *tty)
677 {
678 struct slip *sl = (struct slip *) tty->disc_data;
679 int err;
680
681
682 if (sl && sl->magic == SLIP_MAGIC) {
683 return -EEXIST;
684 }
685
686
687 if ((sl = sl_alloc()) == NULL) {
688 return -ENFILE;
689 }
690
691 sl->tty = tty;
692 tty->disc_data = sl;
693 if (tty->driver.flush_buffer) {
694 tty->driver.flush_buffer(tty);
695 }
696 if (tty->ldisc.flush_buffer) {
697 tty->ldisc.flush_buffer(tty);
698 }
699
700
701 sl->mode = SL_MODE_DEFAULT;
702 sl->dev->type = ARPHRD_SLIP + sl->mode;
703 #ifdef CONFIG_AX25
704 if (sl->dev->type == 260) {
705 sl->dev->type = ARPHRD_AX25;
706 }
707 #endif
708
709 if ((err = sl_open(sl->dev))) {
710 return err;
711 }
712
713 #ifdef MODULE
714 MOD_INC_USE_COUNT;
715 #endif
716
717
718 return sl->dev->base_addr;
719 }
720
721
722
723
724
725
726
727
728 static void
729 slip_close(struct tty_struct *tty)
730 {
731 struct slip *sl = (struct slip *) tty->disc_data;
732
733
734 if (!sl || sl->magic != SLIP_MAGIC) {
735 return;
736 }
737
738 (void) dev_close(sl->dev);
739
740 tty->disc_data = 0;
741 sl->tty = NULL;
742 sl_free(sl);
743 #ifdef MODULE
744 MOD_DEC_USE_COUNT;
745 #endif
746 }
747
748
749 static struct enet_statistics *
750 sl_get_stats(struct device *dev)
751 {
752 static struct enet_statistics stats;
753 struct slip *sl = &sl_ctrl[dev->base_addr];
754 #ifdef SL_INCLUDE_CSLIP
755 struct slcompress *comp;
756 #endif
757
758 memset(&stats, 0, sizeof(struct enet_statistics));
759
760 stats.rx_packets = sl->rx_packets;
761 stats.tx_packets = sl->tx_packets;
762 stats.rx_dropped = sl->rx_dropped;
763 stats.tx_dropped = sl->tx_dropped;
764 stats.tx_errors = sl->tx_errors;
765 stats.rx_errors = sl->rx_errors;
766 stats.rx_over_errors = sl->rx_over_errors;
767 #ifdef SL_INCLUDE_CSLIP
768 stats.rx_fifo_errors = sl->rx_compressed;
769 stats.tx_fifo_errors = sl->tx_compressed;
770 stats.collisions = sl->tx_misses;
771 comp = sl->slcomp;
772 if (comp) {
773 stats.rx_fifo_errors += comp->sls_i_compressed;
774 stats.rx_dropped += comp->sls_i_tossed;
775 stats.tx_fifo_errors += comp->sls_o_compressed;
776 stats.collisions += comp->sls_o_misses;
777 }
778 #endif
779 return (&stats);
780 }
781
782
783
784
785
786
787 int
788 slip_esc(unsigned char *s, unsigned char *d, int len)
789 {
790 unsigned char *ptr = d;
791 unsigned char c;
792
793
794
795
796
797
798
799 *ptr++ = END;
800
801
802
803
804
805
806 while (len-- > 0) {
807 switch(c = *s++) {
808 case END:
809 *ptr++ = ESC;
810 *ptr++ = ESC_END;
811 break;
812 case ESC:
813 *ptr++ = ESC;
814 *ptr++ = ESC_ESC;
815 break;
816 default:
817 *ptr++ = c;
818 break;
819 }
820 }
821 *ptr++ = END;
822 return (ptr - d);
823 }
824
825 static void
826 slip_unesc(struct slip *sl, unsigned char s)
827 {
828
829 switch(s) {
830 case END:
831 if (!clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2)) {
832 sl_bump(sl);
833 }
834 clear_bit(SLF_ESCAPE, &sl->flags);
835 sl->rcount = 0;
836 return;
837
838 case ESC:
839 set_bit(SLF_ESCAPE, &sl->flags);
840 return;
841 case ESC_ESC:
842 if (clear_bit(SLF_ESCAPE, &sl->flags)) {
843 s = ESC;
844 }
845 break;
846 case ESC_END:
847 if (clear_bit(SLF_ESCAPE, &sl->flags)) {
848 s = END;
849 }
850 break;
851 }
852 if (!test_bit(SLF_ERROR, &sl->flags)) {
853 if (sl->rcount < sl->buffsize) {
854 sl->rbuff[sl->rcount++] = s;
855 return;
856 }
857 sl->rx_over_errors++;
858 set_bit(SLF_ERROR, &sl->flags);
859 }
860 }
861
862
863 #ifdef CONFIG_SLIP_MODE_SLIP6
864
865
866
867
868 int
869 slip_esc6(unsigned char *s, unsigned char *d, int len)
870 {
871 unsigned char *ptr = d;
872 unsigned char c;
873 int i;
874 unsigned short v = 0;
875 short bits = 0;
876
877
878
879
880
881
882
883 *ptr++ = 0x70;
884
885
886
887
888
889 for (i = 0; i < len; ++i) {
890 v = (v << 8) | s[i];
891 bits += 8;
892 while (bits >= 6) {
893 bits -= 6;
894 c = 0x30 + ((v >> bits) & 0x3F);
895 *ptr++ = c;
896 }
897 }
898 if (bits) {
899 c = 0x30 + ((v << (6 - bits)) & 0x3F);
900 *ptr++ = c;
901 }
902 *ptr++ = 0x70;
903 return ptr - d;
904 }
905
906 void
907 slip_unesc6(struct slip *sl, unsigned char s)
908 {
909 unsigned char c;
910
911 if (s == 0x70) {
912 if (!clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2)) {
913 sl_bump(sl);
914 }
915 sl->rcount = 0;
916 sl->xbits = 0;
917 sl->xdata = 0;
918 } else if (s >= 0x30 && s < 0x70) {
919 sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
920 sl->xbits += 6;
921 if (sl->xbits >= 8) {
922 sl->xbits -= 8;
923 c = (unsigned char)(sl->xdata >> sl->xbits);
924 if (!test_bit(SLF_ERROR, &sl->flags)) {
925 if (sl->rcount < sl->buffsize) {
926 sl->rbuff[sl->rcount++] = c;
927 return;
928 }
929 sl->rx_over_errors++;
930 set_bit(SLF_ERROR, &sl->flags);
931 }
932 }
933 }
934 }
935 #endif
936
937 #ifdef CONFIG_AX25
938 int
939 sl_set_mac_address(struct device *dev, void *addr)
940 {
941 int err;
942
943 err = verify_area(VERIFY_READ, addr, 7);
944 if (err) {
945 return err;
946 }
947
948 memcpy_fromfs(dev->dev_addr, addr, 7);
949
950 return 0;
951 }
952
953 static int
954 sl_set_dev_mac_address(struct device *dev, void *addr)
955 {
956 memcpy(dev->dev_addr, addr, 7);
957 return 0;
958 }
959 #endif
960
961
962
963 static int
964 slip_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
965 {
966 struct slip *sl = (struct slip *) tty->disc_data;
967 int err;
968 unsigned int tmp;
969
970
971 if (!sl || sl->magic != SLIP_MAGIC) {
972 return -EINVAL;
973 }
974
975 switch(cmd) {
976 case SIOCGIFNAME:
977 err = verify_area(VERIFY_WRITE, arg, 16);
978 if (err) {
979 return -err;
980 }
981 memcpy_tofs(arg, sl->dev->name, strlen(sl->dev->name) + 1);
982 return 0;
983
984 case SIOCGIFENCAP:
985 err = verify_area(VERIFY_WRITE, arg, sizeof(long));
986 if (err) {
987 return -err;
988 }
989 put_fs_long(sl->mode, (long *)arg);
990 return 0;
991
992 case SIOCSIFENCAP:
993 err = verify_area(VERIFY_READ, arg, sizeof(long));
994 if (err) {
995 return -err;
996 }
997 tmp = get_fs_long((long *)arg);
998 #ifndef SL_INCLUDE_CSLIP
999 if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE)) {
1000 return -EINVAL;
1001 }
1002 #else
1003 if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
1004 (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) {
1005
1006 tmp &= ~SL_MODE_ADAPTIVE;
1007 }
1008 #endif
1009 #ifndef CONFIG_SLIP_MODE_SLIP6
1010 if (tmp & SL_MODE_SLIP6) {
1011 return -EINVAL;
1012 }
1013 #endif
1014 #ifndef CONFIG_AX25
1015 if (tmp & SL_MODE_AX25) {
1016 return -EINVAL;
1017 }
1018 #else
1019 if (tmp & SL_MODE_AX25) {
1020 sl->dev->addr_len=7;
1021 sl->dev->hard_header_len=17;
1022 } else {
1023 sl->dev->addr_len=0;
1024 sl->dev->hard_header_len=0;
1025 }
1026 #endif
1027 sl->mode = tmp;
1028 sl->dev->type = ARPHRD_SLIP+sl->mode;
1029 #ifdef CONFIG_AX25
1030 if (sl->dev->type == 260) {
1031 sl->dev->type = ARPHRD_AX25;
1032 }
1033 #endif
1034 return 0;
1035
1036 case SIOCSIFHWADDR:
1037 #ifdef CONFIG_AX25
1038 return sl_set_mac_address(sl->dev, arg);
1039 #else
1040 return -EINVAL;
1041 #endif
1042
1043
1044 case TCGETS:
1045 case TCGETA:
1046 return n_tty_ioctl(tty, (struct file *) file, cmd, (unsigned long) arg);
1047
1048 default:
1049 return -ENOIOCTLCMD;
1050 }
1051 }
1052
1053
1054
1055 int
1056 slip_init(struct device *dev)
1057 {
1058 struct slip *sl = &sl_ctrl[dev->base_addr];
1059 int i;
1060 #ifdef CONFIG_AX25
1061 static char ax25_bcast[7] =
1062 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
1063 static char ax25_test[7] =
1064 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
1065 #endif
1066
1067 if (already++ == 0) {
1068 printk("SLIP: version %s (%d channels) %s\n",
1069 SLIP_VERSION, SL_NRUNIT,
1070 #ifdef CONFIG_SLIP_MODE_SLIP6
1071 "(6 bit encapsulation enabled)"
1072 #else
1073 ""
1074 #endif
1075 );
1076 #if defined(SL_INCLUDE_CSLIP) && !defined(MODULE)
1077 printk("CSLIP: code copyright 1989 Regents of the University of California\n");
1078 #endif
1079 #ifdef CONFIG_AX25
1080 printk("AX25: KISS encapsulation enabled\n");
1081 #endif
1082
1083 memset(&sl_ldisc, 0, sizeof(sl_ldisc));
1084 sl_ldisc.magic = TTY_LDISC_MAGIC;
1085 sl_ldisc.flags = 0;
1086 sl_ldisc.open = slip_open;
1087 sl_ldisc.close = slip_close;
1088 sl_ldisc.read = NULL;
1089 sl_ldisc.write = NULL;
1090 sl_ldisc.ioctl = (int (*)(struct tty_struct *, struct file *,
1091 unsigned int, unsigned long)) slip_ioctl;
1092 sl_ldisc.select = NULL;
1093 sl_ldisc.receive_buf = slip_receive_buf;
1094 sl_ldisc.receive_room = slip_receive_room;
1095 sl_ldisc.write_wakeup = slip_write_wakeup;
1096 if ((i = tty_register_ldisc(N_SLIP, &sl_ldisc)) != 0) {
1097 printk("SLIP: can't register line discipline (err = %d)\n", i);
1098 }
1099 }
1100
1101
1102
1103 memset(sl, 0, sizeof (struct slip));
1104 sl->magic = SLIP_MAGIC;
1105 sl->dev = dev;
1106
1107
1108 dev->mtu = SL_MTU;
1109 dev->hard_start_xmit = sl_xmit;
1110 dev->open = sl_open;
1111 dev->stop = sl_close;
1112 dev->hard_header = sl_header;
1113 dev->type_trans = sl_type_trans;
1114 dev->get_stats = sl_get_stats;
1115 #ifdef HAVE_SET_MAC_ADDR
1116 #ifdef CONFIG_AX25
1117 dev->set_mac_address = sl_set_dev_mac_address;
1118 #endif
1119 #endif
1120 dev->hard_header_len = 0;
1121 dev->addr_len = 0;
1122 dev->type = ARPHRD_SLIP + SL_MODE_DEFAULT;
1123 #ifdef CONFIG_AX25
1124 if (sl->dev->type == 260) {
1125 sl->dev->type = ARPHRD_AX25;
1126 }
1127 memcpy(dev->broadcast, ax25_bcast, 7);
1128 memcpy(dev->dev_addr, ax25_test, 7);
1129 #endif
1130 dev->rebuild_header = sl_rebuild_header;
1131
1132 for (i = 0; i < DEV_NUMBUFFS; i++) {
1133 skb_queue_head_init(&dev->buffs[i]);
1134 }
1135
1136
1137 dev->flags = 0;
1138 dev->family = AF_INET;
1139 dev->pa_addr = 0;
1140 dev->pa_brdaddr = 0;
1141 dev->pa_mask = 0;
1142 dev->pa_alen = sizeof(unsigned long);
1143
1144 return 0;
1145 }
1146 #ifdef MODULE
1147 char kernel_version[] = UTS_RELEASE;
1148
1149 static struct device dev_slip[SL_NRUNIT] = {
1150 {
1151 "sl0",
1152 0, 0, 0, 0,
1153 0, 0,
1154 0, 0, 0, NULL, slip_init,
1155 },
1156 { "sl1" , 0, 0, 0, 0, 1, 0, 0, 0, 0, NULL, slip_init },
1157 { "sl2" , 0, 0, 0, 0, 2, 0, 0, 0, 0, NULL, slip_init },
1158 { "sl3" , 0, 0, 0, 0, 3, 0, 0, 0, 0, NULL, slip_init },
1159 #ifdef SL_SLIP_LOTS
1160 { "sl4" , 0, 0, 0, 0, 4, 0, 0, 0, 0, NULL, slip_init },
1161 { "sl5" , 0, 0, 0, 0, 5, 0, 0, 0, 0, NULL, slip_init },
1162 { "sl6" , 0, 0, 0, 0, 6, 0, 0, 0, 0, NULL, slip_init },
1163 { "sl7" , 0, 0, 0, 0, 7, 0, 0, 0, 0, NULL, slip_init },
1164 { "sl8" , 0, 0, 0, 0, 8, 0, 0, 0, 0, NULL, slip_init },
1165 { "sl9" , 0, 0, 0, 0, 9, 0, 0, 0, 0, NULL, slip_init },
1166 { "sl10", 0, 0, 0, 0, 10, 0, 0, 0, 0, NULL, slip_init },
1167 { "sl11", 0, 0, 0, 0, 11, 0, 0, 0, 0, NULL, slip_init },
1168 { "sl12", 0, 0, 0, 0, 12, 0, 0, 0, 0, NULL, slip_init },
1169 { "sl13", 0, 0, 0, 0, 13, 0, 0, 0, 0, NULL, slip_init },
1170 { "sl14", 0, 0, 0, 0, 14, 0, 0, 0, 0, NULL, slip_init },
1171 { "sl15", 0, 0, 0, 0, 15, 0, 0, 0, 0, NULL, slip_init },
1172 #endif
1173 };
1174
1175 int
1176 init_module(void)
1177 {
1178 int err;
1179 int i;
1180
1181 for (i = 0; i < SL_NRUNIT; i++) {
1182 if ((err = register_netdev(&dev_slip[i]))) {
1183 if (err == -EEXIST) {
1184 printk("SLIP: devices already present. Module not loaded.\n");
1185 }
1186 return err;
1187 }
1188 }
1189 return 0;
1190 }
1191
1192 void
1193 cleanup_module(void)
1194 {
1195 int i;
1196
1197 if (MOD_IN_USE) {
1198 printk("SLIP: device busy, remove delayed\n");
1199 return;
1200 }
1201 for (i = 0; i < SL_NRUNIT; i++) {
1202 unregister_netdev(&dev_slip[i]);
1203 }
1204 if ((i = tty_register_ldisc(N_SLIP, NULL))) {
1205 printk("SLIP: can't unregister line discipline (err = %d)\n", i);
1206 }
1207 already = 0;
1208 }
1209 #endif