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