This source file includes following definitions.
- ppp_init
- ppp_init_ctrl_blk
- ppp_changedmtu
- ppp_release
- ppp_close
- ppp_open
- ppp_dev_open
- ppp_dev_close
- ppp_dev_ioctl
- ppp_output_done
- ppp_kick_tty
- ppp_kick_tty
- ppp_write_wakeup
- ppp_enqueue
- ppp_dump_inqueue
- ppp_tty_input_ready
- ppp_unesc
- ppp_receive_room
- ppp_receive_buf
- ppp_doframe
- ppp_do_ip
- ppp_us_queue
- ppp_read
- ppp_stuff_char
- ppp_write
- ppp_ioctl
- ppp_select
- ppp_xmit
- ppp_type_trans
- ppp_header
- ppp_rebuild_header
- ppp_add_arp
- ppp_header
- ppp_rebuild_header
- ppp_get_stats
- ppp_find
- ppp_alloc
- ppp_lock
- ppp_unlock
- ppp_add_fcs
- ppp_check_fcs
- ppp_print_hex
- ppp_print_char
- ppp_print_buffer
- 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 #define NEW_TTY_DRIVERS
33 #define OPTIMIZE_FLAG_TIME ((HZ * 3)/2)
34 #define CHECK_CHARACTERS
35
36 #ifdef MODULE
37 #include <linux/module.h>
38 #include <linux/version.h>
39 #endif
40
41 #include <linux/kernel.h>
42 #include <linux/sched.h>
43 #include <linux/types.h>
44 #include <linux/fcntl.h>
45 #include <linux/interrupt.h>
46 #include <linux/ptrace.h>
47 #include <linux/ioport.h>
48 #include <linux/in.h>
49 #include <linux/malloc.h>
50 #include <linux/tty.h>
51 #include <linux/errno.h>
52 #include <linux/sched.h>
53 #include <linux/string.h>
54 #include <linux/signal.h>
55 #include <asm/system.h>
56 #include <asm/bitops.h>
57 #include <asm/segment.h>
58
59 #ifdef NET02D
60 #include <dev.h>
61 #include <skbuff.h>
62 #include <inet.h>
63 #define skb_queue_head_init(buf) *(buf) = NULL
64 #else
65 #include <linux/netdevice.h>
66 #include <linux/skbuff.h>
67 #include <linux/inet.h>
68 #endif
69
70 #include <linux/ppp.h>
71
72 #include <linux/ip.h>
73 #include <linux/tcp.h>
74
75 #include "slhc.h"
76
77 #include <linux/if_arp.h>
78 #ifndef ARPHRD_PPP
79 #define ARPHRD_PPP 0
80 #endif
81
82 #define PRINTK(p) printk p ;
83 #define ASSERT(p) if (!p) PRINTK ((KERN_CRIT "assertion failed: " # p))
84 #define PRINTKN(n,p) {if (ppp_debug >= n) PRINTK (p)}
85 #define CHECK_PPP(a) if (!ppp->inuse) { PRINTK ((ppp_warning, __LINE__)) return a;}
86 #define CHECK_PPP_VOID() if (!ppp->inuse) { PRINTK ((ppp_warning, __LINE__)) return;}
87
88 #define in_xmap(ppp,c) (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
89 #define in_rmap(ppp,c) ((((unsigned int) (unsigned char) (c)) < 0x20) && \
90 ppp->recv_async_map & (1 << (c)))
91
92 #define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
93
94 int ppp_debug = 2;
95 int ppp_debug_netpackets = 0;
96
97
98 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
99
100 int ppp_init(struct device *);
101 static void ppp_init_ctrl_blk(struct ppp *);
102 static int ppp_dev_open(struct device *);
103 static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
104 static int ppp_dev_close(struct device *);
105 static void ppp_kick_tty(struct ppp *);
106
107 #ifdef NEW_TTY_DRIVERS
108 #define ppp_find(tty) ((struct ppp *) tty->disc_data)
109 #else
110 static void ppp_output_done(void *);
111 static void ppp_unesc(struct ppp *ppp, unsigned char *c, int n);
112 static struct ppp *ppp_find(struct tty_struct *);
113 #endif
114
115 static void ppp_doframe(struct ppp *);
116 static int ppp_do_ip(struct ppp *, unsigned short, unsigned char *, int);
117 static int ppp_us_queue(struct ppp *, unsigned short, unsigned char *, int);
118 static int ppp_xmit(struct sk_buff *, struct device *);
119 static unsigned short ppp_type_trans(struct sk_buff *, struct device *);
120
121 #ifdef NET02D
122 static int ppp_header(unsigned char *buff, struct device *dev,
123 unsigned short type, unsigned long daddr,
124 unsigned long saddr, unsigned len);
125 static int ppp_rebuild_header(void *buff, struct device *dev);
126 static void ppp_add_arp(unsigned long addr, struct sk_buff *skb,
127 struct device *dev);
128 #else
129 static int ppp_header(unsigned char *, struct device *, unsigned short,
130 void *, void *, unsigned, struct sk_buff *);
131 static int ppp_rebuild_header(void *, struct device *, unsigned long,
132 struct sk_buff *);
133 #endif
134
135 static struct enet_statistics *ppp_get_stats (struct device *);
136 static struct ppp *ppp_alloc(void);
137 static int ppp_lock(struct ppp *);
138 static void ppp_unlock(struct ppp *);
139 static void ppp_add_fcs(struct ppp *);
140 static int ppp_check_fcs(struct ppp *);
141 static void ppp_print_buffer(const char *,char *,int,int);
142
143 static int ppp_read(struct tty_struct *, struct file *, unsigned char *,
144 unsigned int);
145 static int ppp_write(struct tty_struct *, struct file *, unsigned char *,
146 unsigned int);
147 static int ppp_ioctl(struct tty_struct *, struct file *, unsigned int,
148 unsigned long);
149 static int ppp_select(struct tty_struct *tty, struct inode * inode,
150 struct file * filp, int sel_type, select_table * wait);
151 static int ppp_open(struct tty_struct *);
152 static void ppp_close(struct tty_struct *);
153
154 #ifdef NEW_TTY_DRIVERS
155 static int ppp_receive_room(struct tty_struct *tty);
156 static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
157 char *fp, int count);
158 static void ppp_write_wakeup(struct tty_struct *tty);
159 #else
160 static void ppp_tty_input_ready(struct tty_struct *);
161 #endif
162
163
164
165 static unsigned short fcstab[256] = {
166 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
167 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
168 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
169 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
170 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
171 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
172 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
173 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
174 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
175 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
176 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
177 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
178 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
179 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
180 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
181 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
182 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
183 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
184 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
185 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
186 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
187 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
188 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
189 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
190 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
191 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
192 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
193 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
194 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
195 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
196 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
197 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
198 };
199
200 struct tty_ldisc ppp_ldisc;
201
202 static struct ppp ppp_ctrl[PPP_NRUNIT];
203
204
205
206
207
208 static int first_time = 1;
209
210
211
212 int
213 ppp_init(struct device *dev)
214 {
215 struct ppp *ppp;
216 int i;
217
218 ppp = &ppp_ctrl[dev->base_addr];
219
220 if (first_time) {
221 first_time = 0;
222
223 printk (KERN_INFO "PPP: version %s (%d channels)"
224 #ifdef NET02D
225 " NET02D"
226 #endif
227 #ifdef NEW_TTY_DRIVERS
228 " NEW_TTY_DRIVERS"
229 #endif
230 #ifdef OPTIMIZE_FLAG_TIME
231 " OPTIMIZE_FLAGS"
232 #endif
233 "\n", PPP_VERSION, PPP_NRUNIT);
234
235 printk (KERN_INFO
236 "TCP compression code copyright 1989 Regents of the "
237 "University of California\n");
238
239 (void) memset(&ppp_ldisc, 0, sizeof(ppp_ldisc));
240 ppp_ldisc.open = ppp_open;
241 ppp_ldisc.close = ppp_close;
242 ppp_ldisc.read = ppp_read;
243 ppp_ldisc.write = ppp_write;
244 ppp_ldisc.ioctl = ppp_ioctl;
245 ppp_ldisc.select = ppp_select;
246
247 #ifdef NEW_TTY_DRIVERS
248 ppp_ldisc.magic = TTY_LDISC_MAGIC;
249 ppp_ldisc.receive_room = ppp_receive_room;
250 ppp_ldisc.receive_buf = ppp_receive_buf;
251 ppp_ldisc.write_wakeup = ppp_write_wakeup;
252 #else
253 ppp_ldisc.handler = ppp_tty_input_ready;
254 #endif
255
256 if ((i = tty_register_ldisc(N_PPP, &ppp_ldisc)) == 0)
257 printk(KERN_INFO "PPP line discipline registered.\n");
258 else
259 printk(KERN_ERR "error registering line discipline: %d\n", i);
260 }
261
262
263 ppp_init_ctrl_blk (ppp);
264 ppp->inuse = 0;
265 ppp->line = dev->base_addr;
266 ppp->tty = NULL;
267 ppp->dev = dev;
268
269
270 memset (&ppp->stats, '\0', sizeof (struct ppp_stats));
271
272
273 dev->mtu = PPP_MTU;
274 dev->hard_start_xmit = ppp_xmit;
275 dev->open = ppp_dev_open;
276 dev->stop = ppp_dev_close;
277 dev->get_stats = ppp_get_stats;
278 dev->hard_header = ppp_header;
279 dev->type_trans = ppp_type_trans;
280 dev->rebuild_header = ppp_rebuild_header;
281 dev->hard_header_len = 0;
282 dev->addr_len = 0;
283 dev->type = ARPHRD_PPP;
284
285 #ifdef NET02D
286 dev->add_arp = ppp_add_arp;
287 dev->queue_xmit = dev_queue_xmit;
288 #else
289 dev->do_ioctl = ppp_dev_ioctl;
290 #endif
291
292 for (i = 0; i < DEV_NUMBUFFS; i++)
293 skb_queue_head_init(&dev->buffs[i]);
294
295
296 dev->flags = IFF_POINTOPOINT;
297 dev->family = AF_INET;
298 dev->pa_addr = 0;
299 dev->pa_brdaddr = 0;
300 dev->pa_mask = 0;
301 dev->pa_alen = sizeof(unsigned long);
302
303 return 0;
304 }
305
306 static void
307 ppp_init_ctrl_blk(struct ppp *ppp)
308 {
309 ppp->magic = PPP_MAGIC;
310 ppp->sending = 0;
311 ppp->toss = 0xFE;
312 ppp->escape = 0;
313
314 ppp->flags = 0;
315 ppp->mtu = PPP_MTU;
316 ppp->mru = PPP_MRU;
317 ppp->fcs = 0;
318
319 memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
320 ppp->xmit_async_map[0] = 0xffffffff;
321 ppp->xmit_async_map[3] = 0x60000000;
322 ppp->recv_async_map = 0x00000000;
323
324 ppp->slcomp = NULL;
325 ppp->rbuff = NULL;
326 ppp->xbuff = NULL;
327 ppp->cbuff = NULL;
328
329 ppp->rhead = NULL;
330 ppp->rend = NULL;
331 ppp->rcount = 0;
332 ppp->xhead = NULL;
333 ppp->xtail = NULL;
334
335 ppp->us_rbuff = NULL;
336 ppp->us_rbuff_end = NULL;
337 ppp->us_rbuff_head = NULL;
338 ppp->us_rbuff_tail = NULL;
339 ppp->read_wait = NULL;
340 ppp->write_wait = NULL;
341 ppp->us_rbuff_lock = 0;
342 ppp->inp_sig = 0;
343 ppp->inp_sig_pid = 0;
344
345 #ifdef OPTIMIZE_FLAG_TIME
346 ppp->last_xmit = jiffies - OPTIMIZE_FLAG_TIME;
347 #else
348 ppp->last_xmit = 0;
349 #endif
350
351
352 memset (&ppp->stats, '\0', sizeof (struct ppp_stats));
353
354
355 ppp->ddinfo.ip_sjiffies =
356 ppp->ddinfo.ip_rjiffies =
357 ppp->ddinfo.nip_sjiffies =
358 ppp->ddinfo.nip_rjiffies = jiffies;
359 }
360
361
362
363
364
365
366
367 static void
368 ppp_changedmtu (struct ppp *ppp, int new_mtu, int new_mru)
369 {
370 struct device *dev;
371 unsigned char *new_rbuff, *new_xbuff, *new_cbuff;
372 unsigned char *old_rbuff, *old_xbuff, *old_cbuff;
373 int mtu, mru;
374
375
376
377 dev = ppp->dev;
378 mru = new_mru;
379 mtu = new_mtu;
380
381
382 if (mru < PPP_MRU)
383 mru = PPP_MRU;
384
385 mtu = (mtu * 2) + 20;
386 mru = (mru * 2) + 20;
387
388 PRINTKN (2,(KERN_INFO "ppp: channel %s mtu = %d, mru = %d\n",
389 dev->name, new_mtu, new_mru));
390
391 new_xbuff = (unsigned char *) kmalloc(mtu + 4, GFP_ATOMIC);
392 new_rbuff = (unsigned char *) kmalloc(mru + 4, GFP_ATOMIC);
393 new_cbuff = (unsigned char *) kmalloc(mru + 4, GFP_ATOMIC);
394
395
396
397 if (new_xbuff == NULL || new_rbuff == NULL || new_cbuff == NULL)
398 {
399 PRINTKN (2,(KERN_ERR "ppp: failed to allocate new buffers\n"));
400
401
402
403 if (new_rbuff != NULL)
404 kfree (new_rbuff);
405
406 if (new_xbuff != NULL)
407 kfree (new_xbuff);
408
409 if (new_cbuff != NULL)
410 kfree (new_cbuff);
411 }
412
413
414
415 else
416 {
417 cli();
418 old_xbuff = ppp->xbuff;
419 old_rbuff = ppp->rbuff;
420 old_cbuff = ppp->cbuff;
421
422 ppp->xbuff = new_xbuff;
423 ppp->rbuff = new_rbuff;
424 ppp->cbuff = new_cbuff;
425
426 dev->mem_start = (unsigned long) new_xbuff;
427 dev->mem_end = (unsigned long) (dev->mem_start + mtu);
428
429 dev->rmem_start = (unsigned long) new_rbuff;
430 ppp->rend = (unsigned char *)
431 dev->rmem_end = (unsigned long) (dev->rmem_start + mru);
432
433 ppp->rhead = new_rbuff;
434
435
436
437 ppp->toss = 0xFE;
438 ppp->escape = 0;
439 ppp->sending = 0;
440 ppp->rcount = 0;
441
442 ppp->mru = new_mru;
443
444 ppp->mtu =
445 dev->mtu = new_mtu;
446
447 sti();
448
449
450
451 if (old_rbuff != NULL)
452 kfree (old_rbuff);
453
454 if (old_xbuff != NULL)
455 kfree (old_xbuff);
456
457 if (old_cbuff != NULL)
458 kfree (old_cbuff);
459 }
460 }
461
462
463
464 static void
465 ppp_release(struct ppp *ppp)
466 {
467 #ifdef NEW_TTY_DRIVERS
468 if (ppp->tty != NULL && ppp->tty->disc_data == ppp)
469 ppp->tty->disc_data = NULL;
470 #endif
471
472 if (ppp->dev) {
473 dev_close (ppp->dev);
474 ppp->dev->flags = 0;
475 }
476
477 kfree (ppp->xbuff);
478 kfree (ppp->cbuff);
479 kfree (ppp->rbuff);
480 kfree (ppp->us_rbuff);
481
482 ppp->xbuff =
483 ppp->cbuff =
484 ppp->rbuff =
485 ppp->us_rbuff = NULL;
486
487 if (ppp->slcomp) {
488 slhc_free(ppp->slcomp);
489 ppp->slcomp = NULL;
490 }
491
492 ppp->inuse = 0;
493 ppp->tty = NULL;
494 }
495
496 static void
497 ppp_close(struct tty_struct *tty)
498 {
499 struct ppp *ppp = ppp_find(tty);
500
501 if (ppp == NULL || ppp->magic != PPP_MAGIC) {
502 PRINTKN (1,(KERN_WARNING "ppp: trying to close unopened tty!\n"));
503 } else {
504 CHECK_PPP_VOID();
505 ppp_release (ppp);
506
507 PRINTKN (2,(KERN_INFO "ppp: channel %s closing.\n", ppp->dev->name));
508 }
509 }
510
511
512 static int
513 ppp_open(struct tty_struct *tty)
514 {
515 struct ppp *ppp = ppp_find(tty);
516
517 if (ppp) {
518 PRINTKN (1,(KERN_ERR "ppp_open: gack! tty already associated to %s!\n",
519 ppp->magic == PPP_MAGIC ? ppp->dev->name : "unknown"));
520 return -EEXIST;
521 }
522
523 ppp = ppp_alloc();
524 if (ppp == NULL) {
525 PRINTKN (1,(KERN_ERR "ppp_open: couldn't allocate ppp channel\n"));
526 return -ENFILE;
527 }
528
529
530 ppp_init_ctrl_blk (ppp);
531
532 ppp->tty = tty;
533
534 #ifdef NEW_TTY_DRIVERS
535 tty->disc_data = ppp;
536 if (tty->driver.flush_buffer)
537 tty->driver.flush_buffer(tty);
538 if (tty->ldisc.flush_buffer)
539 tty->ldisc.flush_buffer(tty);
540 #else
541 tty_read_flush (tty);
542 tty_write_flush (tty);
543 #endif
544
545 if ((ppp->slcomp = slhc_init(16, 16)) == NULL) {
546 PRINTKN (1,(KERN_ERR "ppp: no space for compression buffers!\n"));
547 ppp_release (ppp);
548 return -ENOMEM;
549 }
550
551
552 ppp_changedmtu (ppp, ppp->dev->mtu, ppp->mru);
553 if (ppp->rbuff == NULL) {
554 ppp_release (ppp);
555 return -ENOMEM;
556 }
557
558
559 ppp->us_rbuff = (unsigned char *) kmalloc (RBUFSIZE, GFP_KERNEL);
560 if (ppp->us_rbuff == NULL) {
561 PRINTKN (1,(KERN_ERR "ppp: no space for user receive buffer\n"));
562 ppp_release (ppp);
563 return -ENOMEM;
564 }
565
566 ppp->us_rbuff_head =
567 ppp->us_rbuff_tail = ppp->us_rbuff;
568 ppp->us_rbuff_end = ppp->us_rbuff + RBUFSIZE;
569
570 PRINTKN (2,(KERN_INFO "ppp: channel %s open\n", ppp->dev->name));
571
572 #ifdef MODULE
573 MOD_INC_USE_COUNT;
574 #endif
575
576 return (ppp->line);
577 }
578
579
580
581 static int
582 ppp_dev_open(struct device *dev)
583 {
584 struct ppp *ppp = &ppp_ctrl[dev->base_addr];
585
586
587 dev->flags |= IFF_POINTOPOINT;
588
589 if (ppp->tty == NULL) {
590 PRINTKN (1,(KERN_ERR "ppp: %s not connected to a TTY! can't go open!\n",
591 dev->name));
592 return -ENXIO;
593 }
594
595 PRINTKN (2,(KERN_INFO "ppp: channel %s going up for IP packets!\n",
596 dev->name));
597
598 CHECK_PPP(-ENXIO);
599 return 0;
600 }
601
602 static int
603 ppp_dev_close(struct device *dev)
604 {
605 struct ppp *ppp = &ppp_ctrl[dev->base_addr];
606
607 if (ppp->tty == NULL) {
608 PRINTKN (1,(KERN_ERR "ppp: %s not connected to a TTY! can't go down!\n",
609 dev->name));
610 return -ENXIO;
611 }
612
613 PRINTKN (2,(KERN_INFO "ppp: channel %s going down for IP packets!\n",
614 dev->name));
615 CHECK_PPP(-ENXIO);
616 #ifdef MODULE
617 MOD_DEC_USE_COUNT;
618 #endif
619 return 0;
620 }
621
622 #ifndef NET02D
623 static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
624 {
625 struct ppp *ppp = &ppp_ctrl[dev->base_addr];
626 int error;
627
628 struct stats
629 {
630 struct ppp_stats ppp_stats;
631 struct slcompress slhc;
632 } *result;
633
634 error = verify_area (VERIFY_READ,
635 ifr->ifr_ifru.ifru_data,
636 sizeof (struct stats));
637
638 if (error == 0) {
639 result = (struct stats *) ifr->ifr_ifru.ifru_data;
640
641 memcpy_tofs (&result->ppp_stats, &ppp->stats, sizeof (struct ppp_stats));
642 if (ppp->slcomp)
643 memcpy_tofs (&result->slhc, ppp->slcomp, sizeof (struct slcompress));
644 }
645
646 return error;
647 }
648 #endif
649
650
651
652
653
654
655
656 #ifdef NEW_TTY_DRIVERS
657 static inline void
658 #else
659 static void
660 #endif
661 ppp_output_done (void *ppp)
662 {
663
664 ppp_unlock ((struct ppp *) ppp);
665
666
667
668 if (((struct ppp *) ppp)->dev->flags & IFF_UP)
669 #ifndef NET02D
670 mark_bh (NET_BH);
671 #else
672 dev_tint (((struct ppp *) ppp)->dev);
673 #endif
674
675
676 wake_up_interruptible (&((struct ppp *) ppp)->write_wait);
677 }
678
679 #ifndef NEW_TTY_DRIVERS
680 static void
681 ppp_kick_tty (struct ppp *ppp)
682 {
683 register int count = ppp->xhead - ppp->xbuff;
684 register int answer;
685
686 ppp->stats.sbytes += count;
687
688 answer = tty_write_data (ppp->tty,
689 ppp->xbuff,
690 count,
691 ppp_output_done,
692 (void *) ppp);
693
694 if (answer == 0)
695 ppp_output_done (ppp);
696 else
697 if (answer < 0) {
698 ppp->stats.serrors++;
699 ppp_output_done (ppp);
700 }
701 }
702
703 #else
704
705 static void
706 ppp_kick_tty (struct ppp *ppp)
707 {
708 register int count, actual;
709
710 count = ppp->xhead - ppp->xbuff;
711
712 actual = ppp->tty->driver.write(ppp->tty, 0, ppp->xbuff, count);
713 ppp->stats.sbytes += actual;
714 if (actual == count) {
715 ppp_output_done(ppp);
716 } else {
717 ppp->xtail = ppp->xbuff + actual;
718 ppp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
719 }
720 }
721
722 static void ppp_write_wakeup(struct tty_struct *tty)
723 {
724 register int count, actual;
725 struct ppp *ppp = ppp_find(tty);
726
727 if (!ppp || ppp->magic != PPP_MAGIC) {
728 PRINTKN (1,
729 (KERN_ERR "PPP: write_wakeup called but couldn't "
730 "find PPP struct.\n"));
731 return;
732 }
733
734 if (!ppp->xtail)
735 return;
736
737 cli();
738 if (ppp->flags & SC_XMIT_BUSY) {
739 sti();
740 return;
741 }
742 ppp->flags |= SC_XMIT_BUSY;
743 sti();
744
745 count = ppp->xhead - ppp->xtail;
746
747 actual = tty->driver.write(tty, 0, ppp->xtail, count);
748 ppp->stats.sbytes += actual;
749 if (actual == count) {
750 ppp->xtail = 0;
751 tty->flags &= ~TTY_DO_WRITE_WAKEUP;
752
753 ppp_output_done(ppp);
754 } else {
755 ppp->xtail += actual;
756 }
757 ppp->flags &= ~SC_XMIT_BUSY;
758 }
759 #endif
760
761
762
763
764
765
766
767
768
769
770
771 static inline void
772 ppp_enqueue(struct ppp *ppp, unsigned char c)
773 {
774 unsigned long flags;
775
776 save_flags(flags);
777 cli();
778 if (ppp->rhead < ppp->rend) {
779 *ppp->rhead = c;
780 ppp->rhead++;
781 ppp->rcount++;
782 } else
783 ppp->stats.roverrun++;
784 restore_flags(flags);
785 }
786
787 #ifdef CHECK_CHARACTERS
788 static unsigned paritytab[8] = {
789 0x96696996, 0x69969669, 0x69969669, 0x96696996,
790 0x69969669, 0x96696996, 0x96696996, 0x69969669
791 };
792 #endif
793
794 #ifndef NEW_TTY_DRIVERS
795 static void
796 ppp_dump_inqueue(struct tty_struct *tty)
797 {
798 int head = tty->read_q.head,
799 tail = tty->read_q.tail,
800 i, count;
801 char buffer[8];
802
803 PRINTK ((KERN_DEBUG "INQUEUE: head %d tail %d imode %x:\n", head, tail,
804 (unsigned int) tty->termios->c_iflag))
805
806 i = tail;
807 count = 0;
808
809 while (i != head) {
810 buffer [count] = tty->read_q.buf[i];
811 if (++count == 8) {
812 ppp_print_buffer (NULL, buffer, 8, KERNEL_DS);
813 count = 0;
814 }
815 i = (i + 1) & (TTY_BUF_SIZE - 1);
816 }
817 ppp_print_buffer (NULL, buffer, count, KERNEL_DS);
818 }
819
820
821
822
823 void ppp_tty_input_ready(struct tty_struct *tty)
824 {
825 struct ppp *ppp = ppp_find(tty);
826 int n, error;
827 unsigned char buff[128];
828
829
830 if (!ppp || ppp->magic != PPP_MAGIC) {
831 PRINTKN (1,
832 (KERN_ERR "PPP: handler called but couldn't find PPP struct.\n"));
833 return;
834 }
835
836 CHECK_PPP_VOID();
837
838
839 if (ppp_debug >= 5)
840 ppp_dump_inqueue(ppp->tty);
841
842 do {
843 n = tty_read_raw_data(tty, buff, 128);
844 if ( n == 0 )
845 break;
846
847 if (ppp_debug >= 5)
848 ppp_print_buffer ("receive buffer", buff, n > 0 ? n : -n, KERNEL_DS);
849
850 if ( n < 0 ) {
851
852
853 n = (-n) - 1;
854 error = buff[n];
855 } else error = 0;
856 ppp->stats.rbytes += n;
857 ppp_unesc(ppp,buff,n);
858 if (error)
859 ppp->toss = error;
860 } while (1);
861 }
862
863
864
865
866
867
868 static void
869 ppp_unesc(struct ppp *ppp, unsigned char *c, int n)
870 {
871 int i;
872
873 for (i = 0; i < n; i++, c++) {
874 PRINTKN (6,(KERN_DEBUG "(%x)", (unsigned int) *c));
875
876 #ifdef CHECK_CHARACTERS
877 if (*c & 0x80)
878 sc->sc_flags |= SC_RCV_B7_1;
879 else
880 sc->sc_flags |= SC_RCV_B7_0;
881
882 if (paritytab[*c >> 5] & (1 << (*c & 0x1F)))
883 sc->sc_flags |= SC_RCV_ODDP;
884 else
885 sc->sc_flags |= SC_RCV_EVNP;
886 #endif
887
888 switch (*c) {
889 case PPP_ESC:
890 ppp->escape = PPP_TRANS;
891 break;
892
893 case PPP_FLAG:
894 if (ppp->escape)
895 ppp->toss = 0xFF;
896
897 if ((ppp->toss & 0x80) == 0)
898 ppp_doframe(ppp);
899
900 ppp->rcount = 0;
901 ppp->rhead = ppp->rbuff;
902 ppp->escape = 0;
903 ppp->toss = 0;
904 break;
905
906 default:
907 if (!in_rmap (ppp, *c)) {
908 if (ppp->toss == 0)
909 ppp_enqueue (ppp, *c ^ ppp->escape);
910 ppp->escape = 0;
911 }
912 break;
913 }
914 }
915 }
916
917 #else
918 static int ppp_receive_room(struct tty_struct *tty)
919 {
920 return 65536;
921 }
922
923
924 static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
925 char *fp, int count)
926 {
927 register struct ppp *ppp = ppp_find (tty);
928 unsigned char c;
929
930
931
932 if (!ppp || ppp->magic != PPP_MAGIC) {
933 PRINTKN (1,("PPP: handler called but couldn't find "
934 "PPP struct.\n"));
935 return;
936 }
937
938 CHECK_PPP_VOID();
939
940 if (ppp_debug >= 5) {
941 ppp_print_buffer ("receive buffer", cp, count, KERNEL_DS);
942 }
943
944 ppp->stats.rbytes += count;
945
946 while (count-- > 0) {
947 c = *cp++;
948
949 if (fp) {
950 if (*fp && ppp->toss == 0)
951 ppp->toss = *fp;
952 fp++;
953 }
954
955 #ifdef CHECK_CHARACTERS
956 if (c & 0x80)
957 ppp->flags |= SC_RCV_B7_1;
958 else
959 ppp->flags |= SC_RCV_B7_0;
960
961 if (paritytab[c >> 5] & (1 << (c & 0x1F)))
962 ppp->flags |= SC_RCV_ODDP;
963 else
964 ppp->flags |= SC_RCV_EVNP;
965 #endif
966
967 switch (c) {
968 case PPP_ESC:
969 ppp->escape = PPP_TRANS;
970 break;
971
972 case PPP_FLAG:
973 if (ppp->escape)
974 ppp->toss = 0xFF;
975
976 if ((ppp->toss & 0x80) == 0)
977 ppp_doframe(ppp);
978
979 ppp->rcount = 0;
980 ppp->rhead = ppp->rbuff;
981 ppp->escape = 0;
982 ppp->toss = 0;
983 break;
984
985 default:
986 if (!in_rmap (ppp, c)) {
987 if (ppp->toss == 0)
988 ppp_enqueue (ppp, c ^ ppp->escape);
989 ppp->escape = 0;
990 }
991 }
992 }
993 }
994 #endif
995
996
997
998 static void
999 ppp_doframe(struct ppp *ppp)
1000 {
1001 u_char *c = ppp->rbuff;
1002 u_short proto;
1003 int count = ppp->rcount;
1004
1005
1006 if (ppp->toss) {
1007 PRINTKN (1, (KERN_WARNING "ppp_toss: tossing frame, reason = %d\n",
1008 ppp->toss));
1009 slhc_toss (ppp->slcomp);
1010 ppp->stats.rerrors++;
1011 return;
1012 }
1013
1014
1015 if (count == 0)
1016 return;
1017
1018 if (ppp_debug >= 3)
1019 ppp_print_buffer ("receive frame", c, count, KERNEL_DS);
1020
1021 if (count < 4) {
1022 PRINTKN (1,(KERN_WARNING "ppp: got runt ppp frame, %d chars\n", count));
1023 slhc_toss (ppp->slcomp);
1024 ppp->stats.runts++;
1025 return;
1026 }
1027
1028
1029 if (!ppp_check_fcs(ppp)) {
1030 PRINTKN (1,(KERN_WARNING "ppp: frame with bad fcs\n"));
1031 slhc_toss (ppp->slcomp);
1032 ppp->stats.rerrors++;
1033 return;
1034 }
1035
1036 count -= 2;
1037
1038
1039
1040 if ((c[0] == PPP_ADDRESS) && (c[1] == PPP_CONTROL)) {
1041 c = c + 2;
1042 count -= 2;
1043 }
1044
1045 proto = (u_short) *c++;
1046 if (proto & 1) {
1047 count--;
1048 } else {
1049 proto = (proto << 8) | (u_short) *c++;
1050 count -= 2;
1051 }
1052
1053
1054 if ((ppp->dev->flags & IFF_UP) && ppp_do_ip(ppp, proto, c, count)) {
1055 ppp->ddinfo.ip_rjiffies = jiffies;
1056 return;
1057 }
1058
1059
1060
1061
1062
1063
1064
1065 if (ppp_us_queue (ppp, proto, c, count+2)) {
1066 ppp->ddinfo.nip_rjiffies = jiffies;
1067 ppp->stats.rothers++;
1068 return;
1069 }
1070
1071
1072 PRINTKN (1,(KERN_WARNING
1073 "ppp: dropping packet on the floor: nobody could take it.\n"));
1074 slhc_toss (ppp->slcomp);
1075 ppp->stats.tossed++;
1076 }
1077
1078
1079
1080
1081
1082 static int
1083 ppp_do_ip (struct ppp *ppp, unsigned short proto, unsigned char *c,
1084 int count)
1085 {
1086 int flags, done;
1087
1088 PRINTKN (4,(KERN_DEBUG "ppp_do_ip: proto %x len %d first byte %x\n",
1089 (int) proto, count, c[0]));
1090
1091 if (ppp_debug_netpackets) {
1092 PRINTK (("KERN_DEBUG %s <-- proto %x len %d\n", ppp->dev->name,
1093 (int) proto, count));
1094 }
1095
1096 if (proto == PROTO_IP) {
1097 ppp->stats.runcomp++;
1098 goto sendit;
1099 }
1100
1101 if ((proto == PROTO_VJCOMP) && !(ppp->flags & SC_REJ_COMP_TCP)) {
1102
1103 done = 0;
1104 save_flags (flags);
1105 cli();
1106 if ((ppp->rhead + 80) < ppp->rend) {
1107 ppp->rhead += 80;
1108 ppp->rcount += 80;
1109 done = 1;
1110 }
1111 restore_flags(flags);
1112
1113 if (! done) {
1114 PRINTKN (1,(KERN_NOTICE
1115 "ppp: no space to decompress VJ compressed TCP header.\n"));
1116 ppp->stats.roverrun++;
1117 slhc_toss (ppp->slcomp);
1118 return 1;
1119 }
1120
1121 count = slhc_uncompress(ppp->slcomp, c, count);
1122 if (count <= 0) {
1123 ppp->stats.rerrors++;
1124 PRINTKN (1,(KERN_NOTICE "ppp: error in VJ decompression\n"));
1125 slhc_toss (ppp->slcomp);
1126 return 1;
1127 }
1128 ppp->stats.rcomp++;
1129 goto sendit;
1130 }
1131
1132 if ((proto == PROTO_VJUNCOMP) && !(ppp->flags & SC_REJ_COMP_TCP)) {
1133 if (slhc_remember(ppp->slcomp, c, count) <= 0) {
1134 ppp->stats.rerrors++;
1135 PRINTKN (1,(KERN_NOTICE "ppp: error in VJ memorizing\n"));
1136 slhc_toss (ppp->slcomp);
1137 return 1;
1138 }
1139 ppp->stats.runcomp++;
1140 goto sendit;
1141 }
1142
1143
1144 return 0;
1145
1146 sendit:
1147 if (ppp_debug_netpackets) {
1148 struct iphdr *iph = (struct iphdr *) c;
1149 PRINTK ((KERN_INFO "%s <-- src %lx dst %lx len %d\n", ppp->dev->name,
1150 iph->saddr, iph->daddr, count))
1151 }
1152
1153
1154 (void) dev_rint (c, count, 0, ppp->dev);
1155 return 1;
1156 }
1157
1158
1159
1160
1161 #define PUTC(c,label) *ppp->us_rbuff_head++ = c; \
1162 if (ppp->us_rbuff_head == ppp->us_rbuff_end) \
1163 ppp->us_rbuff_head = ppp->us_rbuff; \
1164 if (ppp->us_rbuff_head == ppp->us_rbuff_tail) \
1165 goto label;
1166 #define GETC(c) c = *ppp->us_rbuff_tail++; \
1167 if (ppp->us_rbuff_tail == ppp->us_rbuff_end) \
1168 ppp->us_rbuff_tail = ppp->us_rbuff;
1169
1170 static int
1171 ppp_us_queue(struct ppp *ppp, unsigned short proto,
1172 unsigned char *buf, int len)
1173 {
1174 int totlen;
1175 unsigned char *saved_head;
1176
1177 totlen = len+2;
1178
1179 if (set_bit(1, &ppp->us_rbuff_lock)) {
1180 PRINTKN (1, (KERN_NOTICE "ppp_us_queue: can't get lock\n"));
1181 return 0;
1182 }
1183 saved_head = ppp->us_rbuff_head;
1184
1185 PUTC((totlen & 0xff00) >> 8, failure);
1186 PUTC(totlen & 0x00ff, failure);
1187 PUTC((proto & 0xff00) >> 8, failure);
1188 PUTC(proto & 0x00ff, failure);
1189
1190 while (len-- > 0) {
1191 PUTC(*buf++, failure);
1192 }
1193
1194 PRINTKN (3, (KERN_INFO "ppp: successfully queued %d bytes\n", totlen));
1195 clear_bit(1, &ppp->us_rbuff_lock);
1196 wake_up_interruptible (&ppp->read_wait);
1197
1198 #ifdef NEW_TTY_DRIVERS
1199 kill_fasync(ppp->tty->fasync, SIGIO);
1200 #endif
1201
1202 if (ppp->inp_sig && ppp->inp_sig_pid)
1203 if (kill_proc (ppp->inp_sig_pid, ppp->inp_sig, 1) != 0) {
1204
1205 PRINTKN (2,(KERN_NOTICE
1206 "ppp: process that requested notification is gone\n"));
1207 ppp->inp_sig = 0;
1208 ppp->inp_sig_pid = 0;
1209 }
1210 return 1;
1211
1212 failure:
1213 ppp->us_rbuff_head = saved_head;
1214 clear_bit(1, &ppp->us_rbuff_lock);
1215
1216 PRINTKN (1, (KERN_NOTICE "ppp_us_queue: ran out of buffer space.\n"));
1217
1218 return 0;
1219 }
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233 static int
1234 ppp_read(struct tty_struct *tty, struct file *file, unsigned char *buf, unsigned int nr)
1235 {
1236 struct ppp *ppp = ppp_find(tty);
1237 unsigned char c;
1238 int len, i;
1239
1240 if (!ppp || ppp->magic != PPP_MAGIC) {
1241 PRINTKN (1,(KERN_ERR "ppp_read: cannot find ppp channel\n"));
1242 return -EIO;
1243 }
1244
1245 CHECK_PPP(-ENXIO);
1246
1247 PRINTKN (4,(KERN_DEBUG "ppp_read: called %x num %u\n",
1248 (unsigned int) buf,
1249 nr));
1250
1251 do {
1252
1253 if (set_bit(0, &ppp->us_rbuff_lock) == 0) {
1254
1255 if (ppp->us_rbuff_head == ppp->us_rbuff_tail) {
1256
1257 PRINTKN (4,(KERN_DEBUG "ppp_read: no data\n"));
1258 clear_bit(0, &ppp->us_rbuff_lock);
1259 if (ppp->inp_sig) {
1260 PRINTKN (4,(KERN_DEBUG "ppp_read: EWOULDBLOCK\n"));
1261 return -EWOULDBLOCK;
1262 } else goto wait;
1263 }
1264
1265
1266 ppp->ddinfo.nip_rjiffies = jiffies;
1267
1268 GETC (c); len = c << 8; GETC (c); len += c;
1269
1270 PRINTKN (4,(KERN_DEBUG "ppp_read: len = %d\n", len));
1271
1272 if (len + 2 > nr) {
1273
1274 PRINTKN (1,(KERN_DEBUG
1275 "ppp: read of %u bytes too small for %d frame\n",
1276 nr, len+2));
1277 ppp->us_rbuff_head += len;
1278 if (ppp->us_rbuff_head > ppp->us_rbuff_end)
1279 ppp->us_rbuff_head += - (ppp->us_rbuff_end - ppp->us_rbuff);
1280 clear_bit(0, &ppp->us_rbuff_lock);
1281 wake_up_interruptible (&ppp->read_wait);
1282 ppp->stats.rgiants++;
1283 return -EOVERFLOW;
1284 } else {
1285
1286 put_fs_byte (PPP_ADDRESS, buf++);
1287 put_fs_byte (PPP_CONTROL, buf++);
1288 i = len;
1289 while (i-- > 0) {
1290 GETC (c);
1291 put_fs_byte (c, buf++);
1292 }
1293 }
1294
1295 clear_bit(0, &ppp->us_rbuff_lock);
1296 PRINTKN (3,(KERN_DEBUG "ppp_read: passing %d bytes up\n", len + 2));
1297 ppp->stats.rothers++;
1298 return len + 2;
1299 }
1300
1301
1302 wait:
1303 current->timeout = 0;
1304 PRINTKN (3,(KERN_DEBUG "ppp_read: sleeping\n"));
1305 interruptible_sleep_on (&ppp->read_wait);
1306 if (current->signal & ~current->blocked)
1307 return -EINTR;
1308 } while (1);
1309 }
1310
1311
1312
1313
1314 static inline void
1315 ppp_stuff_char(struct ppp *ppp, unsigned char c)
1316 {
1317 int curpt = ppp->xhead - ppp->xbuff;
1318 if ((curpt < 0) || (curpt > 3000)) {
1319 PRINTK ((KERN_DEBUG "ppp_stuff_char: %x %x %d\n",
1320 (unsigned int) ppp->xbuff, (unsigned int) ppp->xhead, curpt))
1321 }
1322 if (in_xmap (ppp, c)) {
1323 *ppp->xhead++ = PPP_ESC;
1324 *ppp->xhead++ = c ^ PPP_TRANS;
1325 } else
1326 *ppp->xhead++ = c;
1327 ppp->fcs = (ppp->fcs >> 8) ^ fcstab[(ppp->fcs ^ c) & 0xff];
1328 }
1329
1330
1331
1332
1333
1334 static int
1335 ppp_write(struct tty_struct *tty, struct file *file, unsigned char *buf, unsigned int nr)
1336 {
1337 struct ppp *ppp = ppp_find(tty);
1338 int i;
1339
1340 if (!ppp || ppp->magic != PPP_MAGIC) {
1341 PRINTKN (1,(KERN_ERR "ppp_write: cannot find ppp unit\n"));
1342 return -EIO;
1343 }
1344
1345 CHECK_PPP(-ENXIO);
1346
1347 if (ppp->mtu != ppp->dev->mtu)
1348 ppp_changedmtu (ppp, ppp->dev->mtu, ppp->mru);
1349
1350 if (nr > ppp->mtu) {
1351 PRINTKN (1,(KERN_WARNING
1352 "ppp_write: truncating user packet from %u to mtu %d\n",
1353 nr, ppp->mtu));
1354 nr = ppp->mtu;
1355 }
1356
1357 if (ppp_debug >= 3)
1358 ppp_print_buffer ("write frame", buf, nr, USER_DS);
1359
1360
1361
1362 while ((ppp->sending == 1) || !ppp_lock(ppp)) {
1363 current->timeout = 0;
1364 PRINTKN (3,(KERN_DEBUG "ppp_write: sleeping\n"));
1365 interruptible_sleep_on(&ppp->write_wait);
1366 if (current->signal & ~current->blocked)
1367 return -EINTR;
1368 }
1369
1370
1371
1372 PRINTKN(4,(KERN_DEBUG "ppp_write: acquired write lock\n"));
1373 ppp->xhead = ppp->xbuff;
1374
1375 #ifdef OPTIMIZE_FLAG_TIME
1376 if (jiffies - ppp->last_xmit > OPTIMIZE_FLAG_TIME)
1377 *ppp->xhead++ = PPP_FLAG;
1378 ppp->last_xmit = jiffies;
1379 #else
1380 *ppp->xhead++ = PPP_FLAG;
1381 #endif
1382
1383 ppp->fcs = PPP_FCS_INIT;
1384 i = nr;
1385 while (i-- > 0)
1386 ppp_stuff_char(ppp,get_fs_byte(buf++));
1387
1388 ppp_add_fcs(ppp);
1389
1390 *ppp->xhead++ = PPP_FLAG;
1391
1392
1393 ppp->ddinfo.nip_sjiffies = jiffies;
1394
1395 if (ppp_debug >= 6)
1396 ppp_print_buffer ("xmit buffer", ppp->xbuff, ppp->xhead - ppp->xbuff, KERNEL_DS);
1397 else {
1398 PRINTKN (4,(KERN_DEBUG
1399 "ppp_write: writing %d chars\n", ppp->xhead - ppp->xbuff));
1400 }
1401
1402
1403 ++ppp->stats.sothers;
1404 ppp_kick_tty(ppp);
1405
1406 return((int)nr);
1407 }
1408
1409 static int
1410 ppp_ioctl(struct tty_struct *tty, struct file *file, unsigned int i,
1411 unsigned long l)
1412 {
1413 struct ppp *ppp = ppp_find(tty);
1414 register int temp_i = 0;
1415 int error;
1416
1417 if (!ppp || ppp->magic != PPP_MAGIC) {
1418 PRINTK ((KERN_ERR "ppp_ioctl: can't find PPP block from tty!\n"))
1419 return -EBADF;
1420 }
1421
1422 CHECK_PPP(-ENXIO);
1423
1424
1425 if (!suser())
1426 return -EPERM;
1427
1428 switch (i) {
1429 case PPPIOCSMRU:
1430 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1431 if (error == 0) {
1432 temp_i = (int) get_fs_long (l);
1433 PRINTKN (3,(KERN_INFO "ppp_ioctl: set mru to %d\n", temp_i));
1434 if (ppp->mru != temp_i)
1435 ppp_changedmtu (ppp, ppp->dev->mtu, temp_i);
1436 }
1437 break;
1438
1439 case PPPIOCGFLAGS:
1440 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
1441 if (error == 0) {
1442 temp_i = (ppp->flags & SC_MASK);
1443 #ifndef CHECK_CHARACTERS
1444 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP;
1445 #endif
1446 put_fs_long ((long) temp_i, l);
1447 PRINTKN (3,(KERN_DEBUG "ppp_ioctl: get flags: addr %lx flags %x\n",
1448 l,
1449 temp_i));
1450 }
1451 break;
1452
1453 case PPPIOCSFLAGS:
1454 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1455 if (error == 0) {
1456 temp_i = (int) get_fs_long (l);
1457 ppp->flags ^= ((ppp->flags ^ temp_i) & SC_MASK);
1458 PRINTKN (3,(KERN_INFO "ppp_ioctl: set flags to %x\n", temp_i));
1459 }
1460 break;
1461
1462 case PPPIOCGASYNCMAP:
1463 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
1464 if (error == 0) {
1465 put_fs_long (ppp->xmit_async_map[0], l);
1466 PRINTKN (3,(KERN_INFO "ppp_ioctl: get asyncmap: addr %lx asyncmap %lx\n",
1467 l, ppp->xmit_async_map[0]));
1468 }
1469 break;
1470
1471 case PPPIOCSASYNCMAP:
1472 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1473 if (error == 0) {
1474 ppp->xmit_async_map[0] = get_fs_long (l);
1475 bset (ppp->xmit_async_map, PPP_FLAG);
1476 bset (ppp->xmit_async_map, PPP_ESC);
1477 PRINTKN (3,(KERN_INFO "ppp_ioctl: set xmit asyncmap %lx\n",
1478 ppp->xmit_async_map[0]));
1479 }
1480 break;
1481
1482 case PPPIOCRASYNCMAP:
1483 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1484 if (error == 0) {
1485 ppp->recv_async_map = get_fs_long (l);
1486 PRINTKN (3,(KERN_INFO "ppp_ioctl: set recv asyncmap %lx\n",
1487 ppp->recv_async_map));
1488 }
1489 break;
1490
1491 case PPPIOCGUNIT:
1492 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
1493 if (error == 0) {
1494 put_fs_long (ppp->dev->base_addr, l);
1495 PRINTKN (3,(KERN_INFO "ppp_ioctl: get unit: %ld", ppp->dev->base_addr));
1496 }
1497 break;
1498
1499 case PPPIOCSINPSIG:
1500 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1501 if (error == 0) {
1502 ppp->inp_sig = (int) get_fs_long (l);
1503 ppp->inp_sig_pid = current->pid;
1504 PRINTKN (3,(KERN_INFO "ppp_ioctl: set input signal %d\n", ppp->inp_sig));
1505 }
1506 break;
1507
1508 case PPPIOCSDEBUG:
1509 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1510 if (error == 0) {
1511 ppp_debug = (int) get_fs_long (l);
1512 ppp_debug_netpackets = (ppp_debug & 0xff00) >> 8;
1513 ppp_debug &= 0xff;
1514 PRINTKN (1, (KERN_INFO "ppp_ioctl: set debug level %d, netpacket %d\n",
1515 ppp_debug, ppp_debug_netpackets));
1516 }
1517 break;
1518
1519 case PPPIOCGDEBUG:
1520 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
1521 if (error == 0) {
1522 put_fs_long ((long) (ppp_debug | (ppp_debug_netpackets << 8)), l);
1523 PRINTKN (3,(KERN_INFO "ppp_ioctl: get debug level %d\n",
1524 ppp_debug | (ppp_debug_netpackets << 8)));
1525 }
1526 break;
1527
1528 case PPPIOCGSTAT:
1529 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (struct ppp_stats));
1530 if (error == 0) {
1531 memcpy_tofs ((void *) l, &ppp->stats, sizeof (struct ppp_stats));
1532 PRINTKN (3,(KERN_INFO "ppp_ioctl: read statistics\n"));
1533 }
1534 break;
1535
1536 case PPPIOCGTIME:
1537 error = verify_area (VERIFY_WRITE, (void *) l, sizeof (struct ppp_ddinfo));
1538 if (error == 0) {
1539 struct ppp_ddinfo cur_ddinfo;
1540 unsigned long cur_jiffies = jiffies;
1541
1542
1543 cur_ddinfo.ip_sjiffies = cur_jiffies - ppp->ddinfo.ip_sjiffies;
1544 cur_ddinfo.ip_rjiffies = cur_jiffies - ppp->ddinfo.ip_rjiffies;
1545 cur_ddinfo.nip_sjiffies = cur_jiffies - ppp->ddinfo.nip_sjiffies;
1546 cur_ddinfo.nip_rjiffies = cur_jiffies - ppp->ddinfo.nip_rjiffies;
1547
1548 memcpy_tofs ((void *) l, &cur_ddinfo, sizeof (struct ppp_ddinfo));
1549 PRINTKN (3,(KERN_INFO "ppp_ioctl: read demand dial info\n"));
1550 }
1551 break;
1552
1553 case PPPIOCGXASYNCMAP:
1554 error = verify_area (VERIFY_WRITE,
1555 (void *) l,
1556 sizeof (ppp->xmit_async_map));
1557 if (error == 0) {
1558 memcpy_tofs ((void *) l,
1559 ppp->xmit_async_map,
1560 sizeof (ppp->xmit_async_map));
1561 PRINTKN (3,(KERN_INFO "ppp_ioctl: get xasyncmap: addr %lx\n", l));
1562 }
1563 break;
1564
1565 case PPPIOCSXASYNCMAP:
1566 error = verify_area (VERIFY_READ, (void *) l,
1567 sizeof (ppp->xmit_async_map));
1568 if (error == 0) {
1569 unsigned long temp_tbl [8];
1570
1571 memcpy_fromfs (temp_tbl, (void *) l, sizeof (ppp->xmit_async_map));
1572 temp_tbl[1] = 0x00000000;
1573 temp_tbl[2] &= ~0x40000000;
1574 temp_tbl[3] |= 0x60000000;
1575
1576 if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
1577 (temp_tbl[4] & temp_tbl[5]) != 0 ||
1578 (temp_tbl[6] & temp_tbl[7]) != 0)
1579 error = -EINVAL;
1580 else {
1581 memcpy (ppp->xmit_async_map, temp_tbl, sizeof (ppp->xmit_async_map));
1582 PRINTKN (3,(KERN_INFO "ppp_ioctl: set xasyncmap\n"));
1583 }
1584 }
1585 break;
1586
1587 case PPPIOCSMAXCID:
1588 error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
1589 if (error == 0) {
1590 temp_i = (int) get_fs_long (l) + 1;
1591 PRINTKN (3,(KERN_INFO "ppp_ioctl: set maxcid to %d\n", temp_i));
1592 if (ppp->slcomp != NULL)
1593 slhc_free (ppp->slcomp);
1594
1595 ppp->slcomp = slhc_init (temp_i, temp_i);
1596
1597 if (ppp->slcomp == NULL) {
1598 PRINTKN (1,(KERN_ERR "ppp: no space for compression buffers!\n"));
1599 ppp_release (ppp);
1600 error = -ENOMEM;
1601 }
1602 }
1603 break;
1604
1605 #ifdef NEW_TTY_DRIVERS
1606
1607 case TCGETS:
1608 case TCGETA:
1609 error = n_tty_ioctl(tty, file, i, l);
1610 break;
1611 #endif
1612
1613
1614
1615
1616
1617 default:
1618 PRINTKN (1,(KERN_ERR "ppp_ioctl: invalid ioctl: %x, addr %lx\n",
1619 i,
1620 l));
1621 #ifdef NEW_TTY_DRIVERS
1622 error = -ENOIOCTLCMD;
1623 #else
1624 error = -EINVAL;
1625 #endif
1626 break;
1627 }
1628 return error;
1629 }
1630
1631 static int
1632 ppp_select (struct tty_struct *tty, struct inode * inode,
1633 struct file * filp, int sel_type, select_table * wait)
1634 {
1635 struct ppp *ppp = ppp_find (tty);
1636
1637 if (!ppp || ppp->magic != PPP_MAGIC) {
1638 PRINTK ((KERN_ERR "ppp_select: can't find PPP block from tty!\n"))
1639 return -EBADF;
1640 }
1641
1642
1643 CHECK_PPP (0);
1644
1645
1646 switch (sel_type) {
1647 case SEL_IN:
1648 if (set_bit(0, &ppp->us_rbuff_lock) == 0) {
1649
1650 if (ppp->us_rbuff_head != ppp->us_rbuff_tail) {
1651 clear_bit (0, &ppp->us_rbuff_lock);
1652 return 1;
1653 }
1654 clear_bit (0, &ppp->us_rbuff_lock);
1655 }
1656
1657 case SEL_EX:
1658
1659 if (tty->packet && tty->link->ctrl_status)
1660 return 1;
1661
1662
1663 if (tty->flags & (1 << TTY_SLAVE_CLOSED))
1664 return 1;
1665
1666
1667 if (tty_hung_up_p(filp))
1668 return 1;
1669
1670 select_wait (&ppp->read_wait, wait);
1671 break;
1672
1673 case SEL_OUT:
1674 if (ppp_lock (ppp)) {
1675 if (ppp->sending == 0) {
1676 ppp_unlock (ppp);
1677 return 1;
1678 }
1679 ppp_unlock (ppp);
1680 }
1681 select_wait (&ppp->write_wait, wait);
1682 break;
1683 }
1684 return 0;
1685 }
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695 int
1696 ppp_xmit(struct sk_buff *skb, struct device *dev)
1697 {
1698 struct tty_struct *tty;
1699 struct ppp *ppp;
1700 unsigned char *p;
1701 unsigned short proto;
1702 int len;
1703
1704
1705 if (skb == NULL) {
1706 PRINTKN(3,(KERN_WARNING "ppp_xmit: null packet!\n"));
1707 return 0;
1708 }
1709
1710
1711 ppp = &ppp_ctrl[dev->base_addr];
1712 tty = ppp->tty;
1713 p = (unsigned char *) (skb + 1);
1714 len = skb->len;
1715 proto = PROTO_IP;
1716
1717 PRINTKN(4,(KERN_DEBUG "ppp_xmit [%s]: skb %lX busy %d\n", dev->name,
1718 (unsigned long int) skb, ppp->sending));
1719
1720
1721 if (!ppp->inuse) {
1722 dev_kfree_skb(skb, FREE_WRITE);
1723 dev_close (dev);
1724 return 0;
1725 }
1726
1727 if (tty == NULL) {
1728 PRINTKN(1,(KERN_ERR "ppp_xmit: %s not connected to a TTY!\n", dev->name));
1729 goto done;
1730 }
1731
1732 if (!(dev->flags & IFF_UP)) {
1733 PRINTKN(1,(KERN_WARNING
1734 "ppp_xmit: packet sent on interface %s, which is down for IP\n",
1735 dev->name));
1736 goto done;
1737 }
1738
1739
1740 if (len < sizeof(struct iphdr)) {
1741 PRINTKN(0,(KERN_ERR "ppp_xmit: given runt packet, ignoring\n"));
1742 goto done;
1743 }
1744 len = ntohs( ((struct iphdr *)(skb->data)) -> tot_len );
1745
1746
1747 if (ppp->flags & SC_IP_DOWN) {
1748 if (ppp->flags & SC_IP_FLUSH == 0) {
1749 if (ppp_us_queue (ppp, proto, p, len))
1750 ppp->flags |= SC_IP_FLUSH;
1751 }
1752 goto done;
1753 }
1754
1755
1756 if (ppp->sending || !ppp_lock(ppp)) {
1757 PRINTKN(3,(KERN_WARNING "ppp_xmit: busy\n"));
1758 ppp->stats.sbusy++;
1759 return 1;
1760 }
1761
1762 ppp->xhead = ppp->xbuff;
1763
1764
1765 if (ppp->flags & SC_COMP_TCP) {
1766 len = slhc_compress(ppp->slcomp, p, len, ppp->cbuff, &p,
1767 !(ppp->flags & SC_NO_TCP_CCID));
1768 if (p[0] & SL_TYPE_COMPRESSED_TCP)
1769 proto = PROTO_VJCOMP;
1770 else {
1771 if (p[0] >= SL_TYPE_UNCOMPRESSED_TCP) {
1772 proto = PROTO_VJUNCOMP;
1773 p[0] = (p[0] & 0x0f) | 0x40;
1774 }
1775 }
1776 }
1777
1778
1779 if (proto == PROTO_VJCOMP)
1780 ++ppp->stats.scomp;
1781 else
1782 ++ppp->stats.suncomp;
1783
1784 if (ppp_debug_netpackets) {
1785 struct iphdr *iph = (struct iphdr *) (skb + 1);
1786 PRINTK ((KERN_DEBUG "%s ==> proto %x len %d src %x dst %x proto %d\n",
1787 dev->name, (int) proto, (int) len, (int) iph->saddr,
1788 (int) iph->daddr, (int) iph->protocol))
1789 }
1790
1791
1792 #ifdef OPTIMIZE_FLAG_TIME
1793 if (jiffies - ppp->last_xmit > OPTIMIZE_FLAG_TIME)
1794 *ppp->xhead++ = PPP_FLAG;
1795 ppp->last_xmit = jiffies;
1796 #else
1797 *ppp->xhead++ = PPP_FLAG;
1798 #endif
1799
1800 ppp->fcs = PPP_FCS_INIT;
1801 if (!(ppp->flags & SC_COMP_AC)) {
1802 ppp_stuff_char(ppp, PPP_ADDRESS);
1803 ppp_stuff_char(ppp, PPP_CONTROL);
1804 }
1805
1806 if (!(ppp->flags & SC_COMP_PROT) || (proto & 0xff00))
1807 ppp_stuff_char(ppp, proto>>8);
1808 ppp_stuff_char(ppp, proto&0xff);
1809
1810
1811 while (len-- > 0)
1812 ppp_stuff_char(ppp, *p++);
1813
1814
1815 ppp_add_fcs(ppp);
1816 *ppp->xhead++ = PPP_FLAG;
1817
1818
1819 ppp->ddinfo.ip_sjiffies = jiffies;
1820
1821
1822 if (ppp_debug >= 6)
1823 ppp_print_buffer ("xmit buffer", ppp->xbuff, ppp->xhead - ppp->xbuff, KERNEL_DS);
1824 else {
1825 PRINTKN (4,(KERN_DEBUG
1826 "ppp_write: writing %d chars\n", ppp->xhead - ppp->xbuff));
1827 }
1828
1829 ppp_kick_tty(ppp);
1830
1831 done:
1832 dev_kfree_skb(skb, FREE_WRITE);
1833 return 0;
1834 }
1835
1836 static unsigned short
1837 ppp_type_trans (struct sk_buff *skb, struct device *dev)
1838 {
1839 return(htons(ETH_P_IP));
1840 }
1841
1842 #ifdef NET02D
1843 static int
1844 ppp_header(unsigned char *buff, struct device *dev, unsigned short type,
1845 unsigned long daddr, unsigned long saddr, unsigned len)
1846 {
1847 return(0);
1848 }
1849
1850 static int
1851 ppp_rebuild_header(void *buff, struct device *dev)
1852 {
1853 return(0);
1854 }
1855
1856 static void
1857 ppp_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
1858 {
1859 }
1860
1861 #else
1862
1863 static int
1864 ppp_header(unsigned char *buff, struct device *dev, unsigned short type,
1865 void *daddr, void *saddr, unsigned len, struct sk_buff *skb)
1866 {
1867 return(0);
1868 }
1869
1870 static int
1871 ppp_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
1872 struct sk_buff *skb)
1873 {
1874 return(0);
1875 }
1876 #endif
1877
1878 static struct enet_statistics *
1879 ppp_get_stats (struct device *dev)
1880 {
1881 struct ppp *ppp = &ppp_ctrl[dev->base_addr];
1882 static struct enet_statistics ppp_stats;
1883
1884 ppp_stats.rx_packets = ppp->stats.rcomp + ppp->stats.runcomp;
1885 ppp_stats.rx_errors = ppp->stats.rerrors;
1886 ppp_stats.rx_dropped = ppp->stats.tossed;
1887 ppp_stats.rx_fifo_errors = 0;
1888 ppp_stats.rx_length_errors = ppp->stats.runts;
1889 ppp_stats.rx_over_errors = ppp->stats.roverrun;
1890 ppp_stats.rx_crc_errors = 0;
1891 ppp_stats.rx_frame_errors = 0;
1892 ppp_stats.tx_packets = ppp->stats.scomp + ppp->stats.suncomp;
1893 ppp_stats.tx_errors = ppp->stats.serrors;
1894 ppp_stats.tx_dropped = 0;
1895 ppp_stats.tx_fifo_errors = 0;
1896 ppp_stats.collisions = ppp->stats.sbusy;
1897 ppp_stats.tx_carrier_errors = 0;
1898 ppp_stats.tx_aborted_errors = 0;
1899 ppp_stats.tx_window_errors = 0;
1900 ppp_stats.tx_heartbeat_errors = 0;
1901
1902 PRINTKN (3, (KERN_INFO "ppp_get_stats called"));
1903 return &ppp_stats;
1904 }
1905
1906
1907
1908
1909
1910
1911 #ifndef NEW_TTY_DRIVERS
1912
1913 struct ppp *
1914 ppp_find(struct tty_struct *tty)
1915 {
1916 int i;
1917 for (i = 0; i < PPP_NRUNIT; i++)
1918 if (ppp_ctrl[i].inuse && (ppp_ctrl[i].tty == tty)) return &ppp_ctrl[i];
1919
1920 return NULL;
1921 }
1922 #endif
1923
1924
1925 static struct ppp *
1926 ppp_alloc(void)
1927 {
1928 int i;
1929 for (i = 0; i < PPP_NRUNIT; i++)
1930 if (!set_bit(0, &ppp_ctrl[i].inuse)) return &ppp_ctrl[i];
1931
1932 return NULL;
1933 }
1934
1935
1936
1937
1938
1939
1940 static int
1941 ppp_lock(struct ppp *ppp)
1942 {
1943 int flags, locked;
1944 save_flags(flags);
1945 cli();
1946 locked = ppp->sending;
1947 ppp->sending = 1;
1948 if (ppp->dev->flags & IFF_UP)
1949 ppp->dev->tbusy = 1;
1950 restore_flags(flags);
1951 return locked == 0;
1952 }
1953
1954 static void
1955 ppp_unlock(struct ppp *ppp)
1956 {
1957 int flags;
1958 save_flags(flags);
1959 cli();
1960 ppp->sending = 0;
1961 if (ppp->dev->flags & IFF_UP)
1962 ppp->dev->tbusy = 0;
1963 restore_flags(flags);
1964 }
1965
1966
1967
1968 static void
1969 ppp_add_fcs(struct ppp *ppp)
1970 {
1971 unsigned short fcs = ppp->fcs;
1972
1973 fcs ^= 0xffff;
1974 ppp_stuff_char(ppp, fcs & 0x00ff);
1975 ppp_stuff_char(ppp, (fcs & 0xff00) >> 8);
1976 ASSERT (ppp->fcs == PPP_FCS_GOOD);
1977 PRINTKN (4,(KERN_DEBUG "ppp_add_fcs: fcs is %lx\n",
1978 (long) (unsigned long) fcs));
1979 }
1980
1981 static int
1982 ppp_check_fcs(struct ppp *ppp)
1983 {
1984 unsigned short fcs = PPP_FCS_INIT, msgfcs;
1985 unsigned char *c = ppp->rbuff;
1986 int i;
1987
1988 for (i = 0; i < ppp->rcount - 2; i++, c++)
1989 fcs = (fcs >> 8) ^ fcstab[(fcs ^ *c) & 0xff];
1990
1991 fcs ^= 0xffff;
1992 msgfcs = (c[1] << 8) + c[0];
1993 PRINTKN (4,(KERN_INFO "ppp_check_fcs: got %lx want %lx\n",
1994 (unsigned long) msgfcs, (unsigned long) fcs));
1995 return fcs == msgfcs;
1996 }
1997
1998 static char hex[] = "0123456789ABCDEF";
1999
2000 static inline void ppp_print_hex (register char *out, char *in, int count)
2001 {
2002 register unsigned char next_ch;
2003
2004 while (count-- > 0) {
2005 next_ch = (unsigned char) get_fs_byte (in);
2006
2007 *out++ = hex[(next_ch >> 4) & 0x0F];
2008 *out++ = hex[next_ch & 0x0F];
2009 ++out;
2010 ++in;
2011 }
2012 }
2013
2014 static inline void ppp_print_char (register char *out, char *in, int count)
2015 {
2016 register unsigned char next_ch;
2017
2018 while (count-- > 0) {
2019 next_ch = (unsigned char) get_fs_byte (in);
2020
2021 if (next_ch < 0x20 || next_ch > 0x7e)
2022 *out++ = '.';
2023 else {
2024 *out++ = next_ch;
2025 if (next_ch == '%')
2026 *out++ = '%';
2027 }
2028 ++in;
2029 }
2030 *out = '\0';
2031 }
2032
2033 static void ppp_print_buffer(const char *name, char *buf, int count, int seg)
2034 {
2035 char line [44];
2036 int old_fs = get_fs();
2037
2038 set_fs (seg);
2039
2040 if (name != NULL)
2041 PRINTK ((KERN_DEBUG "ppp: %s, count = %d\n", name, count));
2042
2043 while (count > 8) {
2044 memset (line, ' ', sizeof (line));
2045 ppp_print_hex (line, buf, 8);
2046 ppp_print_char (&line[8 * 3], buf, 8);
2047 PRINTK ((KERN_DEBUG "%s\n", line));
2048 count -= 8;
2049 buf += 8;
2050 }
2051
2052 if (count > 0) {
2053 memset (line, ' ', sizeof (line));
2054 ppp_print_hex (line, buf, count);
2055 ppp_print_char (&line[8 * 3], buf, count);
2056 PRINTK ((KERN_DEBUG "%s\n", line));
2057 }
2058
2059 set_fs (old_fs);
2060 }
2061
2062 #ifdef MODULE
2063 char kernel_version[] = UTS_RELEASE;
2064
2065 static struct device dev_ppp[PPP_NRUNIT] = {
2066 {
2067 "ppp0",
2068 0, 0, 0, 0,
2069 0, 0,
2070 0, 0, 0, NULL, ppp_init,
2071 }
2072 , { "ppp1" , 0, 0, 0, 0, 1, 0, 0, 0, 0, NULL, ppp_init }
2073 , { "ppp2" , 0, 0, 0, 0, 2, 0, 0, 0, 0, NULL, ppp_init }
2074 , { "ppp3" , 0, 0, 0, 0, 3, 0, 0, 0, 0, NULL, ppp_init }
2075
2076 #ifdef PPP_PPP_LOTS
2077 , { "ppp4" , 0, 0, 0, 0, 4, 0, 0, 0, 0, NULL, ppp_init }
2078 , { "ppp5" , 0, 0, 0, 0, 5, 0, 0, 0, 0, NULL, ppp_init }
2079 , { "ppp6" , 0, 0, 0, 0, 6, 0, 0, 0, 0, NULL, ppp_init }
2080 , { "ppp7" , 0, 0, 0, 0, 7, 0, 0, 0, 0, NULL, ppp_init }
2081 , { "ppp8" , 0, 0, 0, 0, 8, 0, 0, 0, 0, NULL, ppp_init }
2082 , { "ppp9" , 0, 0, 0, 0, 9, 0, 0, 0, 0, NULL, ppp_init }
2083 , { "ppp10" , 0, 0, 0, 0, 10, 0, 0, 0, 0, NULL, ppp_init }
2084 , { "ppp11" , 0, 0, 0, 0, 11, 0, 0, 0, 0, NULL, ppp_init }
2085 , { "ppp12" , 0, 0, 0, 0, 12, 0, 0, 0, 0, NULL, ppp_init }
2086 , { "ppp13" , 0, 0, 0, 0, 13, 0, 0, 0, 0, NULL, ppp_init }
2087 , { "ppp14" , 0, 0, 0, 0, 14, 0, 0, 0, 0, NULL, ppp_init }
2088 , { "ppp15" , 0, 0, 0, 0, 15, 0, 0, 0, 0, NULL, ppp_init }
2089 #endif
2090 };
2091
2092 int
2093 init_module(void)
2094 {
2095 int err;
2096 int i;
2097
2098 for (i = 0; i < PPP_NRUNIT; i++) {
2099 if ((err = register_netdev(&dev_ppp[i]))) {
2100 if (err == -EEXIST) {
2101 printk("PPP: devices already present. Module not loaded.\n");
2102 }
2103 return err;
2104 }
2105 }
2106 return 0;
2107 }
2108
2109 void
2110 cleanup_module(void)
2111 {
2112 int i;
2113
2114 if (MOD_IN_USE) {
2115 printk("PPP: device busy, remove delayed\n");
2116 return;
2117 }
2118 for (i = 0; i < PPP_NRUNIT; i++) {
2119 unregister_netdev(&dev_ppp[i]);
2120 }
2121 if ((i = tty_register_ldisc(N_PPP, NULL))) {
2122 printk("PPP: can't unregister line discipline (err = %d)\n", i);
2123 }
2124 }
2125
2126 #endif