]> git.gir.st - tmk_keyboard.git/blob - tool/mbed/mbed-sdk/libraries/net/lwip/lwip/netif/ppp/ppp.c
git://git.gir.st / tmk_keyboard.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Squashed 'tmk_core/' changes from 7967731..b9e0ea0
[tmk_keyboard.git] / tool / mbed / mbed-sdk / libraries / net / lwip / lwip / netif / ppp / ppp.c
1 /*****************************************************************************
2 * ppp.c - Network Point to Point Protocol program file.
3 *
4 * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.
5 * portions Copyright (c) 1997 by Global Election Systems Inc.
6 *
7 * The authors hereby grant permission to use, copy, modify, distribute,
8 * and license this software and its documentation for any purpose, provided
9 * that existing copyright notices are retained in all copies and that this
10 * notice and the following disclaimer are included verbatim in any
11 * distributions. No written agreement, license, or royalty fee is required
12 * for any of the authorized uses.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *
25 ******************************************************************************
26 * REVISION HISTORY
27 *
28 * 03-01-01 Marc Boucher <marc@mbsi.ca>
29 * Ported to lwIP.
30 * 97-11-05 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
31 * Original.
32 *****************************************************************************/
33
34 /*
35 * ppp_defs.h - PPP definitions.
36 *
37 * if_pppvar.h - private structures and declarations for PPP.
38 *
39 * Copyright (c) 1994 The Australian National University.
40 * All rights reserved.
41 *
42 * Permission to use, copy, modify, and distribute this software and its
43 * documentation is hereby granted, provided that the above copyright
44 * notice appears in all copies. This software is provided without any
45 * warranty, express or implied. The Australian National University
46 * makes no representations about the suitability of this software for
47 * any purpose.
48 *
49 * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
50 * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
51 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
52 * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
53 * OF SUCH DAMAGE.
54 *
55 * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
56 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
57 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
58 * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
59 * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
60 * OR MODIFICATIONS.
61 */
62
63 /*
64 * if_ppp.h - Point-to-Point Protocol definitions.
65 *
66 * Copyright (c) 1989 Carnegie Mellon University.
67 * All rights reserved.
68 *
69 * Redistribution and use in source and binary forms are permitted
70 * provided that the above copyright notice and this paragraph are
71 * duplicated in all such forms and that any documentation,
72 * advertising materials, and other materials related to such
73 * distribution and use acknowledge that the software was developed
74 * by Carnegie Mellon University. The name of the
75 * University may not be used to endorse or promote products derived
76 * from this software without specific prior written permission.
77 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
78 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
79 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
80 */
81
82 #include "lwip/opt.h"
83
84 #if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */
85
86 #include "lwip/ip.h" /* for ip_input() */
87
88 #include "ppp.h"
89 #include "pppdebug.h"
90
91 #include "randm.h"
92 #include "fsm.h"
93 #if PAP_SUPPORT
94 #include "pap.h"
95 #endif /* PAP_SUPPORT */
96 #if CHAP_SUPPORT
97 #include "chap.h"
98 #endif /* CHAP_SUPPORT */
99 #include "ipcp.h"
100 #include "lcp.h"
101 #include "magic.h"
102 #include "auth.h"
103 #if VJ_SUPPORT
104 #include "vj.h"
105 #endif /* VJ_SUPPORT */
106 #if PPPOE_SUPPORT
107 #include "netif/ppp_oe.h"
108 #endif /* PPPOE_SUPPORT */
109
110 #include "lwip/tcpip.h"
111 #include "lwip/api.h"
112 #include "lwip/snmp.h"
113
114 #include <string.h>
115
116 /*************************/
117 /*** LOCAL DEFINITIONS ***/
118 /*************************/
119
120 /** PPP_INPROC_MULTITHREADED==1 call pppInput using tcpip_callback().
121 * Set this to 0 if pppInProc is called inside tcpip_thread or with NO_SYS==1.
122 * Default is 1 for NO_SYS==0 (multithreaded) and 0 for NO_SYS==1 (single-threaded).
123 */
124 #ifndef PPP_INPROC_MULTITHREADED
125 #define PPP_INPROC_MULTITHREADED (NO_SYS==0)
126 #endif
127
128 /** PPP_INPROC_OWNTHREAD==1: start a dedicated RX thread per PPP session.
129 * Default is 0: call pppos_input() for received raw characters, charcater
130 * reception is up to the port */
131 #ifndef PPP_INPROC_OWNTHREAD
132 #define PPP_INPROC_OWNTHREAD PPP_INPROC_MULTITHREADED
133 #endif
134
135 #if PPP_INPROC_OWNTHREAD && !PPP_INPROC_MULTITHREADED
136 #error "PPP_INPROC_OWNTHREAD needs PPP_INPROC_MULTITHREADED==1"
137 #endif
138
139 /*
140 * The basic PPP frame.
141 */
142 #define PPP_ADDRESS(p) (((u_char *)(p))[0])
143 #define PPP_CONTROL(p) (((u_char *)(p))[1])
144 #define PPP_PROTOCOL(p) ((((u_char *)(p))[2] << 8) + ((u_char *)(p))[3])
145
146 /* PPP packet parser states. Current state indicates operation yet to be
147 * completed. */
148 typedef enum {
149 PDIDLE = 0, /* Idle state - waiting. */
150 PDSTART, /* Process start flag. */
151 PDADDRESS, /* Process address field. */
152 PDCONTROL, /* Process control field. */
153 PDPROTOCOL1, /* Process protocol field 1. */
154 PDPROTOCOL2, /* Process protocol field 2. */
155 PDDATA /* Process data byte. */
156 } PPPDevStates;
157
158 #define ESCAPE_P(accm, c) ((accm)[(c) >> 3] & pppACCMMask[c & 0x07])
159
160 /************************/
161 /*** LOCAL DATA TYPES ***/
162 /************************/
163
164 /** RX buffer size: this may be configured smaller! */
165 #ifndef PPPOS_RX_BUFSIZE
166 #define PPPOS_RX_BUFSIZE (PPP_MRU + PPP_HDRLEN)
167 #endif
168
169 typedef struct PPPControlRx_s {
170 /** unit number / ppp descriptor */
171 int pd;
172 /** the rx file descriptor */
173 sio_fd_t fd;
174 /** receive buffer - encoded data is stored here */
175 u_char rxbuf[PPPOS_RX_BUFSIZE];
176
177 /* The input packet. */
178 struct pbuf *inHead, *inTail;
179
180 #if PPPOS_SUPPORT
181 u16_t inProtocol; /* The input protocol code. */
182 u16_t inFCS; /* Input Frame Check Sequence value. */
183 #endif /* PPPOS_SUPPORT */
184 PPPDevStates inState; /* The input process state. */
185 char inEscaped; /* Escape next character. */
186 ext_accm inACCM; /* Async-Ctl-Char-Map for input. */
187 } PPPControlRx;
188
189 /*
190 * PPP interface control block.
191 */
192 typedef struct PPPControl_s {
193 PPPControlRx rx;
194 char openFlag; /* True when in use. */
195 #if PPPOE_SUPPORT
196 struct netif *ethif;
197 struct pppoe_softc *pppoe_sc;
198 #endif /* PPPOE_SUPPORT */
199 int if_up; /* True when the interface is up. */
200 int errCode; /* Code indicating why interface is down. */
201 #if PPPOS_SUPPORT
202 sio_fd_t fd; /* File device ID of port. */
203 #endif /* PPPOS_SUPPORT */
204 u16_t mtu; /* Peer's mru */
205 int pcomp; /* Does peer accept protocol compression? */
206 int accomp; /* Does peer accept addr/ctl compression? */
207 u_long lastXMit; /* Time of last transmission. */
208 ext_accm outACCM; /* Async-Ctl-Char-Map for output. */
209 #if PPPOS_SUPPORT && VJ_SUPPORT
210 int vjEnabled; /* Flag indicating VJ compression enabled. */
211 struct vjcompress vjComp; /* Van Jacobson compression header. */
212 #endif /* PPPOS_SUPPORT && VJ_SUPPORT */
213
214 struct netif netif;
215
216 struct ppp_addrs addrs;
217
218 void (*linkStatusCB)(void *ctx, int errCode, void *arg);
219 void *linkStatusCtx;
220
221 } PPPControl;
222
223
224 /*
225 * Ioctl definitions.
226 */
227
228 struct npioctl {
229 int protocol; /* PPP procotol, e.g. PPP_IP */
230 enum NPmode mode;
231 };
232
233
234
235 /***********************************/
236 /*** LOCAL FUNCTION DECLARATIONS ***/
237 /***********************************/
238 #if PPPOS_SUPPORT
239 #if PPP_INPROC_OWNTHREAD
240 static void pppInputThread(void *arg);
241 #endif /* PPP_INPROC_OWNTHREAD */
242 static void pppDrop(PPPControlRx *pcrx);
243 static void pppInProc(PPPControlRx *pcrx, u_char *s, int l);
244 #endif /* PPPOS_SUPPORT */
245
246
247 /******************************/
248 /*** PUBLIC DATA STRUCTURES ***/
249 /******************************/
250 u_long subnetMask;
251
252 static PPPControl pppControl[NUM_PPP] __attribute((section("AHBSRAM1"))); /* The PPP interface control blocks. */
253
254 sys_mbox_t pppMbox; //Used to signal PPP thread that a PPP session begins
255
256 /*
257 * PPP Data Link Layer "protocol" table.
258 * One entry per supported protocol.
259 * The last entry must be NULL.
260 */
261 struct protent *ppp_protocols[] = {
262 &lcp_protent,
263 #if PAP_SUPPORT
264 &pap_protent,
265 #endif /* PAP_SUPPORT */
266 #if CHAP_SUPPORT
267 &chap_protent,
268 #endif /* CHAP_SUPPORT */
269 #if CBCP_SUPPORT
270 &cbcp_protent,
271 #endif /* CBCP_SUPPORT */
272 &ipcp_protent,
273 #if CCP_SUPPORT
274 &ccp_protent,
275 #endif /* CCP_SUPPORT */
276 NULL
277 };
278
279
280 /*
281 * Buffers for outgoing packets. This must be accessed only from the appropriate
282 * PPP task so that it doesn't need to be protected to avoid collisions.
283 */
284 u_char outpacket_buf[NUM_PPP][PPP_MRU+PPP_HDRLEN] __attribute((section("AHBSRAM1")));
285
286
287 /*****************************/
288 /*** LOCAL DATA STRUCTURES ***/
289 /*****************************/
290
291 #if PPPOS_SUPPORT
292 /*
293 * FCS lookup table as calculated by genfcstab.
294 * @todo: smaller, slower implementation for lower memory footprint?
295 */
296 static const u_short fcstab[256] = {
297 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
298 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
299 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
300 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
301 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
302 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
303 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
304 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
305 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
306 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
307 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
308 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
309 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
310 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
311 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
312 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
313 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
314 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
315 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
316 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
317 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
318 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
319 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
320 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
321 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
322 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
323 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
324 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
325 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
326 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
327 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
328 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
329 };
330
331 /* PPP's Asynchronous-Control-Character-Map. The mask array is used
332 * to select the specific bit for a character. */
333 static u_char pppACCMMask[] = {
334 0x01,
335 0x02,
336 0x04,
337 0x08,
338 0x10,
339 0x20,
340 0x40,
341 0x80
342 };
343
344 /** Wake up the task blocked in reading from serial line (if any) */
345 static void
346 pppRecvWakeup(int pd)
347 {
348 PPPDEBUG(LOG_DEBUG, ("pppRecvWakeup: unit %d\n", pd));
349 if (pppControl[pd].openFlag != 0) {
350 sio_read_abort(pppControl[pd].fd);
351 }
352 }
353 #endif /* PPPOS_SUPPORT */
354
355 void
356 pppLinkTerminated(int pd)
357 {
358 PPPDEBUG(LOG_DEBUG, ("pppLinkTerminated: unit %d\n", pd));
359
360 #if PPPOE_SUPPORT
361 if (pppControl[pd].ethif) {
362 pppoe_disconnect(pppControl[pd].pppoe_sc);
363 } else
364 #endif /* PPPOE_SUPPORT */
365 {
366 #if PPPOS_SUPPORT
367 PPPControl* pc;
368 pppRecvWakeup(pd);
369 pc = &pppControl[pd];
370
371 PPPDEBUG(LOG_DEBUG, ("pppLinkTerminated: unit %d: linkStatusCB=%p errCode=%d\n", pd, pc->linkStatusCB, pc->errCode));
372 if (pc->linkStatusCB) {
373 pc->linkStatusCB(pc->linkStatusCtx, pc->errCode ? pc->errCode : PPPERR_PROTOCOL, NULL);
374 }
375
376 pc->openFlag = 0;/**/
377 #endif /* PPPOS_SUPPORT */
378 }
379 PPPDEBUG(LOG_DEBUG, ("pppLinkTerminated: finished.\n"));
380 }
381
382 void
383 pppLinkDown(int pd)
384 {
385 PPPDEBUG(LOG_DEBUG, ("pppLinkDown: unit %d\n", pd));
386
387 #if PPPOE_SUPPORT
388 if (pppControl[pd].ethif) {
389 pppoe_disconnect(pppControl[pd].pppoe_sc);
390 } else
391 #endif /* PPPOE_SUPPORT */
392 {
393 #if PPPOS_SUPPORT
394 pppRecvWakeup(pd);
395 #endif /* PPPOS_SUPPORT */
396 }
397 }
398
399 /** Initiate LCP open request */
400 static void
401 pppStart(int pd)
402 {
403 PPPDEBUG(LOG_DEBUG, ("pppStart: unit %d\n", pd));
404 lcp_lowerup(pd);
405 lcp_open(pd); /* Start protocol */
406 PPPDEBUG(LOG_DEBUG, ("pppStart: finished\n"));
407 }
408
409 /** LCP close request */
410 static void
411 pppStop(int pd)
412 {
413 PPPDEBUG(LOG_DEBUG, ("pppStop: unit %d\n", pd));
414 lcp_close(pd, "User request");
415 }
416
417 /** Called when carrier/link is lost */
418 static void
419 pppHup(int pd)
420 {
421 PPPDEBUG(LOG_DEBUG, ("pppHupCB: unit %d\n", pd));
422 lcp_lowerdown(pd);
423 link_terminated(pd);
424 }
425
426 /***********************************/
427 /*** PUBLIC FUNCTION DEFINITIONS ***/
428 /***********************************/
429 /* Initialize the PPP subsystem. */
430
431 struct ppp_settings ppp_settings;
432
433 void
434 pppInit(void)
435 {
436 struct protent *protp;
437 int i, j;
438
439 memset(&ppp_settings, 0, sizeof(ppp_settings));
440 ppp_settings.usepeerdns = 1;
441 pppSetAuth(PPPAUTHTYPE_NONE, NULL, NULL);
442
443 magicInit();
444
445 subnetMask = PP_HTONL(0xffffff00UL);
446
447 for (i = 0; i < NUM_PPP; i++) {
448 /* Initialize each protocol to the standard option set. */
449 for (j = 0; (protp = ppp_protocols[j]) != NULL; ++j) {
450 (*protp->init)(i);
451 }
452 }
453
454 sys_mbox_new(&pppMbox, 1);
455 sys_thread_new(PPP_THREAD_NAME, pppInputThread, (void*)NULL, PPP_THREAD_STACKSIZE, PPP_THREAD_PRIO); //Create PPP thread here
456 }
457
458 void
459 pppSetAuth(enum pppAuthType authType, const char *user, const char *passwd)
460 {
461 switch(authType) {
462 case PPPAUTHTYPE_NONE:
463 default:
464 #ifdef LWIP_PPP_STRICT_PAP_REJECT
465 ppp_settings.refuse_pap = 1;
466 #else /* LWIP_PPP_STRICT_PAP_REJECT */
467 /* some providers request pap and accept an empty login/pw */
468 ppp_settings.refuse_pap = 0;
469 #endif /* LWIP_PPP_STRICT_PAP_REJECT */
470 ppp_settings.refuse_chap = 1;
471 break;
472
473 case PPPAUTHTYPE_ANY:
474 /* Warning: Using PPPAUTHTYPE_ANY might have security consequences.
475 * RFC 1994 says:
476 *
477 * In practice, within or associated with each PPP server, there is a
478 * database which associates "user" names with authentication
479 * information ("secrets"). It is not anticipated that a particular
480 * named user would be authenticated by multiple methods. This would
481 * make the user vulnerable to attacks which negotiate the least secure
482 * method from among a set (such as PAP rather than CHAP). If the same
483 * secret was used, PAP would reveal the secret to be used later with
484 * CHAP.
485 *
486 * Instead, for each user name there should be an indication of exactly
487 * one method used to authenticate that user name. If a user needs to
488 * make use of different authentication methods under different
489 * circumstances, then distinct user names SHOULD be employed, each of
490 * which identifies exactly one authentication method.
491 *
492 */
493 ppp_settings.refuse_pap = 0;
494 ppp_settings.refuse_chap = 0;
495 break;
496
497 case PPPAUTHTYPE_PAP:
498 ppp_settings.refuse_pap = 0;
499 ppp_settings.refuse_chap = 1;
500 break;
501
502 case PPPAUTHTYPE_CHAP:
503 ppp_settings.refuse_pap = 1;
504 ppp_settings.refuse_chap = 0;
505 break;
506 }
507
508 if(user) {
509 strncpy(ppp_settings.user, user, sizeof(ppp_settings.user)-1);
510 ppp_settings.user[sizeof(ppp_settings.user)-1] = '\0';
511 } else {
512 ppp_settings.user[0] = '\0';
513 }
514
515 if(passwd) {
516 strncpy(ppp_settings.passwd, passwd, sizeof(ppp_settings.passwd)-1);
517 ppp_settings.passwd[sizeof(ppp_settings.passwd)-1] = '\0';
518 } else {
519 ppp_settings.passwd[0] = '\0';
520 }
521 }
522
523 #if PPPOS_SUPPORT
524 /** Open a new PPP connection using the given I/O device.
525 * This initializes the PPP control block but does not
526 * attempt to negotiate the LCP session. If this port
527 * connects to a modem, the modem connection must be
528 * established before calling this.
529 * Return a new PPP connection descriptor on success or
530 * an error code (negative) on failure.
531 *
532 * pppOpen() is directly defined to this function.
533 */
534 int
535 pppOverSerialOpen(sio_fd_t fd, void (*linkStatusCB)(void *ctx, int errCode, void *arg), void *linkStatusCtx)
536 {
537 PPPControl *pc;
538 int pd;
539
540 if (linkStatusCB == NULL) {
541 /* PPP is single-threaded: without a callback,
542 * there is no way to know when the link is up. */
543 return PPPERR_PARAM;
544 }
545
546 /* Find a free PPP session descriptor. */
547 for (pd = 0; pd < NUM_PPP && pppControl[pd].openFlag != 0; pd++);
548
549 if (pd >= NUM_PPP) {
550 pd = PPPERR_OPEN;
551 } else {
552 pc = &pppControl[pd];
553 /* @todo: is this correct or do I overwrite something? */
554 memset(pc, 0, sizeof(PPPControl));
555 pc->rx.pd = pd;
556 pc->rx.fd = fd;
557
558 pc->openFlag = 1;
559 pc->fd = fd;
560
561 #if VJ_SUPPORT
562 vj_compress_init(&pc->vjComp);
563 #endif /* VJ_SUPPORT */
564
565 /*
566 * Default the in and out accm so that escape and flag characters
567 * are always escaped.
568 */
569 pc->rx.inACCM[15] = 0x60; /* no need to protect since RX is not running */
570 pc->outACCM[15] = 0x60;
571
572 pc->linkStatusCB = linkStatusCB;
573 pc->linkStatusCtx = linkStatusCtx;
574
575 /*
576 * Start the connection and handle incoming events (packet or timeout).
577 */
578 PPPDEBUG(LOG_INFO, ("pppOverSerialOpen: unit %d: Connecting\n", pd));
579 pppStart(pd);
580 #if PPP_INPROC_OWNTHREAD
581 sys_mbox_post(&pppMbox, (void*)&pc->rx);
582 #endif
583 }
584
585 return pd;
586 }
587 #endif /* PPPOS_SUPPORT */
588
589 #if PPPOE_SUPPORT
590 static void pppOverEthernetLinkStatusCB(int pd, int up);
591
592 void
593 pppOverEthernetClose(int pd)
594 {
595 PPPControl* pc = &pppControl[pd];
596
597 /* *TJL* There's no lcp_deinit */
598 lcp_close(pd, NULL);
599
600 pppoe_destroy(&pc->netif);
601 }
602
603 int pppOverEthernetOpen(struct netif *ethif, const char *service_name, const char *concentrator_name, void (*linkStatusCB)(void *ctx, int errCode, void *arg), void *linkStatusCtx)
604 {
605 PPPControl *pc;
606 int pd;
607
608 LWIP_UNUSED_ARG(service_name);
609 LWIP_UNUSED_ARG(concentrator_name);
610
611 if (linkStatusCB == NULL) {
612 /* PPP is single-threaded: without a callback,
613 * there is no way to know when the link is up. */
614 return PPPERR_PARAM;
615 }
616
617 /* Find a free PPP session descriptor. Critical region? */
618 for (pd = 0; pd < NUM_PPP && pppControl[pd].openFlag != 0; pd++);
619 if (pd >= NUM_PPP) {
620 pd = PPPERR_OPEN;
621 } else {
622 pc = &pppControl[pd];
623 memset(pc, 0, sizeof(PPPControl));
624 pc->openFlag = 1;
625 pc->ethif = ethif;
626
627 pc->linkStatusCB = linkStatusCB;
628 pc->linkStatusCtx = linkStatusCtx;
629
630 lcp_wantoptions[pd].mru = PPPOE_MAXMTU;
631 lcp_wantoptions[pd].neg_asyncmap = 0;
632 lcp_wantoptions[pd].neg_pcompression = 0;
633 lcp_wantoptions[pd].neg_accompression = 0;
634
635 lcp_allowoptions[pd].mru = PPPOE_MAXMTU;
636 lcp_allowoptions[pd].neg_asyncmap = 0;
637 lcp_allowoptions[pd].neg_pcompression = 0;
638 lcp_allowoptions[pd].neg_accompression = 0;
639
640 if(pppoe_create(ethif, pd, pppOverEthernetLinkStatusCB, &pc->pppoe_sc) != ERR_OK) {
641 pc->openFlag = 0;
642 return PPPERR_OPEN;
643 }
644
645 pppoe_connect(pc->pppoe_sc);
646 }
647
648 return pd;
649 }
650 #endif /* PPPOE_SUPPORT */
651
652
653 /* Close a PPP connection and release the descriptor.
654 * Any outstanding packets in the queues are dropped.
655 * Return 0 on success, an error code on failure. */
656 int
657 pppClose(int pd)
658 {
659 PPPControl *pc = &pppControl[pd];
660 int st = 0;
661
662 PPPDEBUG(LOG_DEBUG, ("pppClose() called\n"));
663
664 /* Disconnect */
665 #if PPPOE_SUPPORT
666 if(pc->ethif) {
667 PPPDEBUG(LOG_DEBUG, ("pppClose: unit %d kill_link -> pppStop\n", pd));
668 pc->errCode = PPPERR_USER;
669 /* This will leave us at PHASE_DEAD. */
670 pppStop(pd);
671 } else
672 #endif /* PPPOE_SUPPORT */
673 {
674 #if PPPOS_SUPPORT
675 PPPDEBUG(LOG_DEBUG, ("pppClose: unit %d kill_link -> pppStop\n", pd));
676 pc->errCode = PPPERR_USER;
677 /* This will leave us at PHASE_DEAD. */
678 pppStop(pd);
679 pppRecvWakeup(pd);
680 #endif /* PPPOS_SUPPORT */
681 }
682
683 return st;
684 }
685
686 /* This function is called when carrier is lost on the PPP channel. */
687 void
688 pppSigHUP(int pd)
689 {
690 PPPDEBUG(LOG_DEBUG, ("pppSigHUP: unit %d sig_hup -> pppHupCB\n", pd));
691 pppHup(pd);
692 }
693
694 #if PPPOS_SUPPORT
695 static void
696 nPut(PPPControl *pc, struct pbuf *nb)
697 {
698 struct pbuf *b;
699 int c;
700
701 for(b = nb; b != NULL; b = b->next) {
702 if((c = sio_write(pc->fd, b->payload, b->len)) != b->len) {
703 PPPDEBUG(LOG_WARNING,
704 ("PPP nPut: incomplete sio_write(fd:%"SZT_F", len:%d, c: 0x%"X8_F") c = %d\n", (size_t)pc->fd, b->len, c, c));
705 LINK_STATS_INC(link.err);
706 pc->lastXMit = 0; /* prepend PPP_FLAG to next packet */
707 snmp_inc_ifoutdiscards(&pc->netif);
708 pbuf_free(nb);
709 return;
710 }
711 }
712
713 snmp_add_ifoutoctets(&pc->netif, nb->tot_len);
714 snmp_inc_ifoutucastpkts(&pc->netif);
715 pbuf_free(nb);
716 LINK_STATS_INC(link.xmit);
717 }
718
719 /*
720 * pppAppend - append given character to end of given pbuf. If outACCM
721 * is not NULL and the character needs to be escaped, do so.
722 * If pbuf is full, append another.
723 * Return the current pbuf.
724 */
725 static struct pbuf *
726 pppAppend(u_char c, struct pbuf *nb, ext_accm *outACCM)
727 {
728 struct pbuf *tb = nb;
729
730 /* Make sure there is room for the character and an escape code.
731 * Sure we don't quite fill the buffer if the character doesn't
732 * get escaped but is one character worth complicating this? */
733 /* Note: We assume no packet header. */
734 if (nb && (PBUF_POOL_BUFSIZE - nb->len) < 2) {
735 tb = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
736 if (tb) {
737 nb->next = tb;
738 } else {
739 LINK_STATS_INC(link.memerr);
740 }
741 nb = tb;
742 }
743
744 if (nb) {
745 if (outACCM && ESCAPE_P(*outACCM, c)) {
746 *((u_char*)nb->payload + nb->len++) = PPP_ESCAPE;
747 *((u_char*)nb->payload + nb->len++) = c ^ PPP_TRANS;
748 } else {
749 *((u_char*)nb->payload + nb->len++) = c;
750 }
751 }
752
753 return tb;
754 }
755 #endif /* PPPOS_SUPPORT */
756
757 #if PPPOE_SUPPORT
758 static err_t
759 pppifOutputOverEthernet(int pd, struct pbuf *p)
760 {
761 PPPControl *pc = &pppControl[pd];
762 struct pbuf *pb;
763 u_short protocol = PPP_IP;
764 int i=0;
765 u16_t tot_len;
766
767 /* @todo: try to use pbuf_header() here! */
768 pb = pbuf_alloc(PBUF_LINK, PPPOE_HDRLEN + sizeof(protocol), PBUF_RAM);
769 if(!pb) {
770 LINK_STATS_INC(link.memerr);
771 LINK_STATS_INC(link.proterr);
772 snmp_inc_ifoutdiscards(&pc->netif);
773 return ERR_MEM;
774 }
775
776 pbuf_header(pb, -(s16_t)PPPOE_HDRLEN);
777
778 pc->lastXMit = sys_jiffies();
779
780 if (!pc->pcomp || protocol > 0xFF) {
781 *((u_char*)pb->payload + i++) = (protocol >> 8) & 0xFF;
782 }
783 *((u_char*)pb->payload + i) = protocol & 0xFF;
784
785 pbuf_chain(pb, p);
786 tot_len = pb->tot_len;
787
788 if(pppoe_xmit(pc->pppoe_sc, pb) != ERR_OK) {
789 LINK_STATS_INC(link.err);
790 snmp_inc_ifoutdiscards(&pc->netif);
791 return PPPERR_DEVICE;
792 }
793
794 snmp_add_ifoutoctets(&pc->netif, tot_len);
795 snmp_inc_ifoutucastpkts(&pc->netif);
796 LINK_STATS_INC(link.xmit);
797 return ERR_OK;
798 }
799 #endif /* PPPOE_SUPPORT */
800
801 /* Send a packet on the given connection. */
802 static err_t
803 pppifOutput(struct netif *netif, struct pbuf *pb, ip_addr_t *ipaddr)
804 {
805 int pd = (int)(size_t)netif->state;
806 PPPControl *pc = &pppControl[pd];
807 #if PPPOS_SUPPORT
808 u_short protocol = PPP_IP;
809 u_int fcsOut = PPP_INITFCS;
810 struct pbuf *headMB = NULL, *tailMB = NULL, *p;
811 u_char c;
812 #endif /* PPPOS_SUPPORT */
813
814 LWIP_UNUSED_ARG(ipaddr);
815
816 /* Validate parameters. */
817 /* We let any protocol value go through - it can't hurt us
818 * and the peer will just drop it if it's not accepting it. */
819 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag || !pb) {
820 PPPDEBUG(LOG_WARNING, ("pppifOutput[%d]: bad parms prot=%d pb=%p\n",
821 pd, PPP_IP, pb));
822 LINK_STATS_INC(link.opterr);
823 LINK_STATS_INC(link.drop);
824 snmp_inc_ifoutdiscards(netif);
825 return ERR_ARG;
826 }
827
828 /* Check that the link is up. */
829 if (lcp_phase[pd] == PHASE_DEAD) {
830 PPPDEBUG(LOG_ERR, ("pppifOutput[%d]: link not up\n", pd));
831 LINK_STATS_INC(link.rterr);
832 LINK_STATS_INC(link.drop);
833 snmp_inc_ifoutdiscards(netif);
834 return ERR_RTE;
835 }
836
837 #if PPPOE_SUPPORT
838 if(pc->ethif) {
839 return pppifOutputOverEthernet(pd, pb);
840 }
841 #endif /* PPPOE_SUPPORT */
842
843 #if PPPOS_SUPPORT
844 /* Grab an output buffer. */
845 headMB = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
846 if (headMB == NULL) {
847 PPPDEBUG(LOG_WARNING, ("pppifOutput[%d]: first alloc fail\n", pd));
848 LINK_STATS_INC(link.memerr);
849 LINK_STATS_INC(link.drop);
850 snmp_inc_ifoutdiscards(netif);
851 return ERR_MEM;
852 }
853
854 #if VJ_SUPPORT
855 /*
856 * Attempt Van Jacobson header compression if VJ is configured and
857 * this is an IP packet.
858 */
859 if (protocol == PPP_IP && pc->vjEnabled) {
860 switch (vj_compress_tcp(&pc->vjComp, pb)) {
861 case TYPE_IP:
862 /* No change...
863 protocol = PPP_IP_PROTOCOL; */
864 break;
865 case TYPE_COMPRESSED_TCP:
866 protocol = PPP_VJC_COMP;
867 break;
868 case TYPE_UNCOMPRESSED_TCP:
869 protocol = PPP_VJC_UNCOMP;
870 break;
871 default:
872 PPPDEBUG(LOG_WARNING, ("pppifOutput[%d]: bad IP packet\n", pd));
873 LINK_STATS_INC(link.proterr);
874 LINK_STATS_INC(link.drop);
875 snmp_inc_ifoutdiscards(netif);
876 pbuf_free(headMB);
877 return ERR_VAL;
878 }
879 }
880 #endif /* VJ_SUPPORT */
881
882 tailMB = headMB;
883
884 /* Build the PPP header. */
885 if ((sys_jiffies() - pc->lastXMit) >= PPP_MAXIDLEFLAG) {
886 tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
887 }
888
889 pc->lastXMit = sys_jiffies();
890 if (!pc->accomp) {
891 fcsOut = PPP_FCS(fcsOut, PPP_ALLSTATIONS);
892 tailMB = pppAppend(PPP_ALLSTATIONS, tailMB, &pc->outACCM);
893 fcsOut = PPP_FCS(fcsOut, PPP_UI);
894 tailMB = pppAppend(PPP_UI, tailMB, &pc->outACCM);
895 }
896 if (!pc->pcomp || protocol > 0xFF) {
897 c = (protocol >> 8) & 0xFF;
898 fcsOut = PPP_FCS(fcsOut, c);
899 tailMB = pppAppend(c, tailMB, &pc->outACCM);
900 }
901 c = protocol & 0xFF;
902 fcsOut = PPP_FCS(fcsOut, c);
903 tailMB = pppAppend(c, tailMB, &pc->outACCM);
904
905 /* Load packet. */
906 for(p = pb; p; p = p->next) {
907 int n;
908 u_char *sPtr;
909
910 sPtr = (u_char*)p->payload;
911 n = p->len;
912 while (n-- > 0) {
913 c = *sPtr++;
914
915 /* Update FCS before checking for special characters. */
916 fcsOut = PPP_FCS(fcsOut, c);
917
918 /* Copy to output buffer escaping special characters. */
919 tailMB = pppAppend(c, tailMB, &pc->outACCM);
920 }
921 }
922
923 /* Add FCS and trailing flag. */
924 c = ~fcsOut & 0xFF;
925 tailMB = pppAppend(c, tailMB, &pc->outACCM);
926 c = (~fcsOut >> 8) & 0xFF;
927 tailMB = pppAppend(c, tailMB, &pc->outACCM);
928 tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
929
930 /* If we failed to complete the packet, throw it away. */
931 if (!tailMB) {
932 PPPDEBUG(LOG_WARNING,
933 ("pppifOutput[%d]: Alloc err - dropping proto=%d\n",
934 pd, protocol));
935 pbuf_free(headMB);
936 LINK_STATS_INC(link.memerr);
937 LINK_STATS_INC(link.drop);
938 snmp_inc_ifoutdiscards(netif);
939 return ERR_MEM;
940 }
941
942 /* Send it. */
943 PPPDEBUG(LOG_INFO, ("pppifOutput[%d]: proto=0x%"X16_F"\n", pd, protocol));
944
945 nPut(pc, headMB);
946 #endif /* PPPOS_SUPPORT */
947
948 return ERR_OK;
949 }
950
951 /* Get and set parameters for the given connection.
952 * Return 0 on success, an error code on failure. */
953 int
954 pppIOCtl(int pd, int cmd, void *arg)
955 {
956 PPPControl *pc = &pppControl[pd];
957 int st = 0;
958
959 if (pd < 0 || pd >= NUM_PPP) {
960 st = PPPERR_PARAM;
961 } else {
962 switch(cmd) {
963 case PPPCTLG_UPSTATUS: /* Get the PPP up status. */
964 if (arg) {
965 *(int *)arg = (int)(pc->if_up);
966 } else {
967 st = PPPERR_PARAM;
968 }
969 break;
970 case PPPCTLS_ERRCODE: /* Set the PPP error code. */
971 if (arg) {
972 pc->errCode = *(int *)arg;
973 } else {
974 st = PPPERR_PARAM;
975 }
976 break;
977 case PPPCTLG_ERRCODE: /* Get the PPP error code. */
978 if (arg) {
979 *(int *)arg = (int)(pc->errCode);
980 } else {
981 st = PPPERR_PARAM;
982 }
983 break;
984 #if PPPOS_SUPPORT
985 case PPPCTLG_FD: /* Get the fd associated with the ppp */
986 if (arg) {
987 *(sio_fd_t *)arg = pc->fd;
988 } else {
989 st = PPPERR_PARAM;
990 }
991 break;
992 #endif /* PPPOS_SUPPORT */
993 default:
994 st = PPPERR_PARAM;
995 break;
996 }
997 }
998
999 return st;
1000 }
1001
1002 /*
1003 * Return the Maximum Transmission Unit for the given PPP connection.
1004 */
1005 u_short
1006 pppMTU(int pd)
1007 {
1008 PPPControl *pc = &pppControl[pd];
1009 u_short st;
1010
1011 /* Validate parameters. */
1012 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1013 st = 0;
1014 } else {
1015 st = pc->mtu;
1016 }
1017
1018 return st;
1019 }
1020
1021 #if PPPOE_SUPPORT
1022 int
1023 pppWriteOverEthernet(int pd, const u_char *s, int n)
1024 {
1025 PPPControl *pc = &pppControl[pd];
1026 struct pbuf *pb;
1027
1028 /* skip address & flags */
1029 s += 2;
1030 n -= 2;
1031
1032 LWIP_ASSERT("PPPOE_HDRLEN + n <= 0xffff", PPPOE_HDRLEN + n <= 0xffff);
1033 pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HDRLEN + n), PBUF_RAM);
1034 if(!pb) {
1035 LINK_STATS_INC(link.memerr);
1036 LINK_STATS_INC(link.proterr);
1037 snmp_inc_ifoutdiscards(&pc->netif);
1038 return PPPERR_ALLOC;
1039 }
1040
1041 pbuf_header(pb, -(s16_t)PPPOE_HDRLEN);
1042
1043 pc->lastXMit = sys_jiffies();
1044
1045 MEMCPY(pb->payload, s, n);
1046
1047 if(pppoe_xmit(pc->pppoe_sc, pb) != ERR_OK) {
1048 LINK_STATS_INC(link.err);
1049 snmp_inc_ifoutdiscards(&pc->netif);
1050 return PPPERR_DEVICE;
1051 }
1052
1053 snmp_add_ifoutoctets(&pc->netif, (u16_t)n);
1054 snmp_inc_ifoutucastpkts(&pc->netif);
1055 LINK_STATS_INC(link.xmit);
1056 return PPPERR_NONE;
1057 }
1058 #endif /* PPPOE_SUPPORT */
1059
1060 /*
1061 * Write n characters to a ppp link.
1062 * RETURN: >= 0 Number of characters written
1063 * -1 Failed to write to device
1064 */
1065 int
1066 pppWrite(int pd, const u_char *s, int n)
1067 {
1068 PPPControl *pc = &pppControl[pd];
1069 #if PPPOS_SUPPORT
1070 u_char c;
1071 u_int fcsOut;
1072 struct pbuf *headMB, *tailMB;
1073 #endif /* PPPOS_SUPPORT */
1074
1075 #if PPPOE_SUPPORT
1076 if(pc->ethif) {
1077 return pppWriteOverEthernet(pd, s, n);
1078 }
1079 #endif /* PPPOE_SUPPORT */
1080
1081 #if PPPOS_SUPPORT
1082 headMB = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
1083 if (headMB == NULL) {
1084 LINK_STATS_INC(link.memerr);
1085 LINK_STATS_INC(link.proterr);
1086 snmp_inc_ifoutdiscards(&pc->netif);
1087 return PPPERR_ALLOC;
1088 }
1089
1090 tailMB = headMB;
1091
1092 /* If the link has been idle, we'll send a fresh flag character to
1093 * flush any noise. */
1094 if ((sys_jiffies() - pc->lastXMit) >= PPP_MAXIDLEFLAG) {
1095 tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
1096 }
1097 pc->lastXMit = sys_jiffies();
1098
1099 fcsOut = PPP_INITFCS;
1100 /* Load output buffer. */
1101 while (n-- > 0) {
1102 c = *s++;
1103
1104 /* Update FCS before checking for special characters. */
1105 fcsOut = PPP_FCS(fcsOut, c);
1106
1107 /* Copy to output buffer escaping special characters. */
1108 tailMB = pppAppend(c, tailMB, &pc->outACCM);
1109 }
1110
1111 /* Add FCS and trailing flag. */
1112 c = ~fcsOut & 0xFF;
1113 tailMB = pppAppend(c, tailMB, &pc->outACCM);
1114 c = (~fcsOut >> 8) & 0xFF;
1115 tailMB = pppAppend(c, tailMB, &pc->outACCM);
1116 tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
1117
1118 /* If we failed to complete the packet, throw it away.
1119 * Otherwise send it. */
1120 if (!tailMB) {
1121 PPPDEBUG(LOG_WARNING,
1122 ("pppWrite[%d]: Alloc err - dropping pbuf len=%d\n", pd, headMB->len));
1123 /*"pppWrite[%d]: Alloc err - dropping %d:%.*H", pd, headMB->len, LWIP_MIN(headMB->len * 2, 40), headMB->payload)); */
1124 pbuf_free(headMB);
1125 LINK_STATS_INC(link.memerr);
1126 LINK_STATS_INC(link.proterr);
1127 snmp_inc_ifoutdiscards(&pc->netif);
1128 return PPPERR_ALLOC;
1129 }
1130
1131 PPPDEBUG(LOG_INFO, ("pppWrite[%d]: len=%d\n", pd, headMB->len));
1132 /* "pppWrite[%d]: %d:%.*H", pd, headMB->len, LWIP_MIN(headMB->len * 2, 40), headMB->payload)); */
1133 nPut(pc, headMB);
1134 #endif /* PPPOS_SUPPORT */
1135
1136 return PPPERR_NONE;
1137 }
1138
1139 /*
1140 * ppp_send_config - configure the transmit characteristics of
1141 * the ppp interface.
1142 */
1143 void
1144 ppp_send_config( int unit, u16_t mtu, u32_t asyncmap, int pcomp, int accomp)
1145 {
1146 PPPControl *pc = &pppControl[unit];
1147 int i;
1148
1149 pc->mtu = mtu;
1150 pc->pcomp = pcomp;
1151 pc->accomp = accomp;
1152
1153 /* Load the ACCM bits for the 32 control codes. */
1154 for (i = 0; i < 32/8; i++) {
1155 pc->outACCM[i] = (u_char)((asyncmap >> (8 * i)) & 0xFF);
1156 }
1157 PPPDEBUG(LOG_INFO, ("ppp_send_config[%d]: outACCM=%X %X %X %X\n",
1158 unit,
1159 pc->outACCM[0], pc->outACCM[1], pc->outACCM[2], pc->outACCM[3]));
1160 }
1161
1162
1163 /*
1164 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
1165 */
1166 void
1167 ppp_set_xaccm(int unit, ext_accm *accm)
1168 {
1169 SMEMCPY(pppControl[unit].outACCM, accm, sizeof(ext_accm));
1170 PPPDEBUG(LOG_INFO, ("ppp_set_xaccm[%d]: outACCM=%X %X %X %X\n",
1171 unit,
1172 pppControl[unit].outACCM[0],
1173 pppControl[unit].outACCM[1],
1174 pppControl[unit].outACCM[2],
1175 pppControl[unit].outACCM[3]));
1176 }
1177
1178
1179 /*
1180 * ppp_recv_config - configure the receive-side characteristics of
1181 * the ppp interface.
1182 */
1183 void
1184 ppp_recv_config( int unit, int mru, u32_t asyncmap, int pcomp, int accomp)
1185 {
1186 PPPControl *pc = &pppControl[unit];
1187 int i;
1188 SYS_ARCH_DECL_PROTECT(lev);
1189
1190 LWIP_UNUSED_ARG(accomp);
1191 LWIP_UNUSED_ARG(pcomp);
1192 LWIP_UNUSED_ARG(mru);
1193
1194 /* Load the ACCM bits for the 32 control codes. */
1195 SYS_ARCH_PROTECT(lev);
1196 for (i = 0; i < 32 / 8; i++) {
1197 /* @todo: does this work? ext_accm has been modified from pppd! */
1198 pc->rx.inACCM[i] = (u_char)(asyncmap >> (i * 8));
1199 }
1200 SYS_ARCH_UNPROTECT(lev);
1201 PPPDEBUG(LOG_INFO, ("ppp_recv_config[%d]: inACCM=%X %X %X %X\n",
1202 unit,
1203 pc->rx.inACCM[0], pc->rx.inACCM[1], pc->rx.inACCM[2], pc->rx.inACCM[3]));
1204 }
1205
1206 #if 0
1207 /*
1208 * ccp_test - ask kernel whether a given compression method
1209 * is acceptable for use. Returns 1 if the method and parameters
1210 * are OK, 0 if the method is known but the parameters are not OK
1211 * (e.g. code size should be reduced), or -1 if the method is unknown.
1212 */
1213 int
1214 ccp_test( int unit, int opt_len, int for_transmit, u_char *opt_ptr)
1215 {
1216 return 0; /* XXX Currently no compression. */
1217 }
1218
1219 /*
1220 * ccp_flags_set - inform kernel about the current state of CCP.
1221 */
1222 void
1223 ccp_flags_set(int unit, int isopen, int isup)
1224 {
1225 /* XXX */
1226 }
1227
1228 /*
1229 * ccp_fatal_error - returns 1 if decompression was disabled as a
1230 * result of an error detected after decompression of a packet,
1231 * 0 otherwise. This is necessary because of patent nonsense.
1232 */
1233 int
1234 ccp_fatal_error(int unit)
1235 {
1236 /* XXX */
1237 return 0;
1238 }
1239 #endif
1240
1241 /*
1242 * get_idle_time - return how long the link has been idle.
1243 */
1244 int
1245 get_idle_time(int u, struct ppp_idle *ip)
1246 {
1247 /* XXX */
1248 LWIP_UNUSED_ARG(u);
1249 LWIP_UNUSED_ARG(ip);
1250
1251 return 0;
1252 }
1253
1254
1255 /*
1256 * Return user specified netmask, modified by any mask we might determine
1257 * for address `addr' (in network byte order).
1258 * Here we scan through the system's list of interfaces, looking for
1259 * any non-point-to-point interfaces which might appear to be on the same
1260 * network as `addr'. If we find any, we OR in their netmask to the
1261 * user-specified netmask.
1262 */
1263 u32_t
1264 GetMask(u32_t addr)
1265 {
1266 u32_t mask, nmask;
1267
1268 htonl(addr);
1269 if (IP_CLASSA(addr)) { /* determine network mask for address class */
1270 nmask = IP_CLASSA_NET;
1271 } else if (IP_CLASSB(addr)) {
1272 nmask = IP_CLASSB_NET;
1273 } else {
1274 nmask = IP_CLASSC_NET;
1275 }
1276
1277 /* class D nets are disallowed by bad_ip_adrs */
1278 mask = subnetMask | htonl(nmask);
1279
1280 /* XXX
1281 * Scan through the system's network interfaces.
1282 * Get each netmask and OR them into our mask.
1283 */
1284
1285 return mask;
1286 }
1287
1288 /*
1289 * sifvjcomp - config tcp header compression
1290 */
1291 int
1292 sifvjcomp(int pd, int vjcomp, u8_t cidcomp, u8_t maxcid)
1293 {
1294 #if PPPOS_SUPPORT && VJ_SUPPORT
1295 PPPControl *pc = &pppControl[pd];
1296
1297 pc->vjEnabled = vjcomp;
1298 pc->vjComp.compressSlot = cidcomp;
1299 pc->vjComp.maxSlotIndex = maxcid;
1300 PPPDEBUG(LOG_INFO, ("sifvjcomp: VJ compress enable=%d slot=%d max slot=%d\n",
1301 vjcomp, cidcomp, maxcid));
1302 #else /* PPPOS_SUPPORT && VJ_SUPPORT */
1303 LWIP_UNUSED_ARG(pd);
1304 LWIP_UNUSED_ARG(vjcomp);
1305 LWIP_UNUSED_ARG(cidcomp);
1306 LWIP_UNUSED_ARG(maxcid);
1307 #endif /* PPPOS_SUPPORT && VJ_SUPPORT */
1308
1309 return 0;
1310 }
1311
1312 /*
1313 * pppifNetifInit - netif init callback
1314 */
1315 static err_t
1316 pppifNetifInit(struct netif *netif)
1317 {
1318 netif->name[0] = 'p';
1319 netif->name[1] = 'p';
1320 netif->output = pppifOutput;
1321 netif->mtu = pppMTU((int)(size_t)netif->state);
1322 netif->flags = NETIF_FLAG_POINTTOPOINT | NETIF_FLAG_LINK_UP;
1323 #if LWIP_NETIF_HOSTNAME
1324 /* @todo: Initialize interface hostname */
1325 /* netif_set_hostname(netif, "lwip"); */
1326 #endif /* LWIP_NETIF_HOSTNAME */
1327 return ERR_OK;
1328 }
1329
1330
1331 /*
1332 * sifup - Config the interface up and enable IP packets to pass.
1333 */
1334 int
1335 sifup(int pd)
1336 {
1337 PPPControl *pc = &pppControl[pd];
1338 int st = 1;
1339
1340 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1341 st = 0;
1342 PPPDEBUG(LOG_WARNING, ("sifup[%d]: bad parms\n", pd));
1343 } else {
1344 netif_remove(&pc->netif);
1345 if (netif_add(&pc->netif, &pc->addrs.our_ipaddr, &pc->addrs.netmask,
1346 &pc->addrs.his_ipaddr, (void *)(size_t)pd, pppifNetifInit, ip_input)) {
1347 netif_set_up(&pc->netif);
1348 pc->if_up = 1;
1349 pc->errCode = PPPERR_NONE;
1350
1351 PPPDEBUG(LOG_DEBUG, ("sifup: unit %d: linkStatusCB=%p errCode=%d\n", pd, pc->linkStatusCB, pc->errCode));
1352 if (pc->linkStatusCB) {
1353 pc->linkStatusCB(pc->linkStatusCtx, pc->errCode, &pc->addrs);
1354 }
1355 } else {
1356 st = 0;
1357 PPPDEBUG(LOG_ERR, ("sifup[%d]: netif_add failed\n", pd));
1358 }
1359 }
1360
1361 return st;
1362 }
1363
1364 /*
1365 * sifnpmode - Set the mode for handling packets for a given NP.
1366 */
1367 int
1368 sifnpmode(int u, int proto, enum NPmode mode)
1369 {
1370 LWIP_UNUSED_ARG(u);
1371 LWIP_UNUSED_ARG(proto);
1372 LWIP_UNUSED_ARG(mode);
1373 return 0;
1374 }
1375
1376 /*
1377 * sifdown - Config the interface down and disable IP.
1378 */
1379 int
1380 sifdown(int pd)
1381 {
1382 PPPControl *pc = &pppControl[pd];
1383 int st = 1;
1384
1385 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1386 st = 0;
1387 PPPDEBUG(LOG_WARNING, ("sifdown[%d]: bad parms\n", pd));
1388 } else {
1389 pc->if_up = 0;
1390 /* make sure the netif status callback is called */
1391 netif_set_down(&pc->netif);
1392 netif_remove(&pc->netif);
1393 PPPDEBUG(LOG_DEBUG, ("sifdown: unit %d: linkStatusCB=%p errCode=%d\n", pd, pc->linkStatusCB, pc->errCode));
1394 if (pc->linkStatusCB) {
1395 pc->linkStatusCB(pc->linkStatusCtx, PPPERR_CONNECT, NULL);
1396 }
1397 }
1398 return st;
1399 }
1400
1401 /**
1402 * sifaddr - Config the interface IP addresses and netmask.
1403 * @param pd Interface unit ???
1404 * @param o Our IP address ???
1405 * @param h His IP address ???
1406 * @param m IP subnet mask ???
1407 * @param ns1 Primary DNS
1408 * @param ns2 Secondary DNS
1409 */
1410 int
1411 sifaddr( int pd, u32_t o, u32_t h, u32_t m, u32_t ns1, u32_t ns2)
1412 {
1413 PPPControl *pc = &pppControl[pd];
1414 int st = 1;
1415
1416 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1417 st = 0;
1418 PPPDEBUG(LOG_WARNING, ("sifup[%d]: bad parms\n", pd));
1419 } else {
1420 SMEMCPY(&pc->addrs.our_ipaddr, &o, sizeof(o));
1421 SMEMCPY(&pc->addrs.his_ipaddr, &h, sizeof(h));
1422 SMEMCPY(&pc->addrs.netmask, &m, sizeof(m));
1423 SMEMCPY(&pc->addrs.dns1, &ns1, sizeof(ns1));
1424 SMEMCPY(&pc->addrs.dns2, &ns2, sizeof(ns2));
1425 }
1426 return st;
1427 }
1428
1429 /**
1430 * cifaddr - Clear the interface IP addresses, and delete routes
1431 * through the interface if possible.
1432 * @param pd Interface unit ???
1433 * @param o Our IP address ???
1434 * @param h IP broadcast address ???
1435 */
1436 int
1437 cifaddr( int pd, u32_t o, u32_t h)
1438 {
1439 PPPControl *pc = &pppControl[pd];
1440 int st = 1;
1441
1442 LWIP_UNUSED_ARG(o);
1443 LWIP_UNUSED_ARG(h);
1444 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1445 st = 0;
1446 PPPDEBUG(LOG_WARNING, ("sifup[%d]: bad parms\n", pd));
1447 } else {
1448 IP4_ADDR(&pc->addrs.our_ipaddr, 0,0,0,0);
1449 IP4_ADDR(&pc->addrs.his_ipaddr, 0,0,0,0);
1450 IP4_ADDR(&pc->addrs.netmask, 255,255,255,0);
1451 IP4_ADDR(&pc->addrs.dns1, 0,0,0,0);
1452 IP4_ADDR(&pc->addrs.dns2, 0,0,0,0);
1453 }
1454 return st;
1455 }
1456
1457 /*
1458 * sifdefaultroute - assign a default route through the address given.
1459 */
1460 int
1461 sifdefaultroute(int pd, u32_t l, u32_t g)
1462 {
1463 PPPControl *pc = &pppControl[pd];
1464 int st = 1;
1465
1466 LWIP_UNUSED_ARG(l);
1467 LWIP_UNUSED_ARG(g);
1468
1469 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1470 st = 0;
1471 PPPDEBUG(LOG_WARNING, ("sifup[%d]: bad parms\n", pd));
1472 } else {
1473 netif_set_default(&pc->netif);
1474 }
1475
1476 /* TODO: check how PPP handled the netMask, previously not set by ipSetDefault */
1477
1478 return st;
1479 }
1480
1481 /*
1482 * cifdefaultroute - delete a default route through the address given.
1483 */
1484 int
1485 cifdefaultroute(int pd, u32_t l, u32_t g)
1486 {
1487 PPPControl *pc = &pppControl[pd];
1488 int st = 1;
1489
1490 LWIP_UNUSED_ARG(l);
1491 LWIP_UNUSED_ARG(g);
1492
1493 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1494 st = 0;
1495 PPPDEBUG(LOG_WARNING, ("sifup[%d]: bad parms\n", pd));
1496 } else {
1497 netif_set_default(NULL);
1498 }
1499
1500 return st;
1501 }
1502
1503 /**********************************/
1504 /*** LOCAL FUNCTION DEFINITIONS ***/
1505 /**********************************/
1506
1507 #if PPPOS_SUPPORT && PPP_INPROC_OWNTHREAD
1508 /* The main PPP process function. This implements the state machine according
1509 * to section 4 of RFC 1661: The Point-To-Point Protocol. */
1510 static void
1511 pppInputThread(void *arg)
1512 {
1513 int count;
1514 PPPControlRx *pcrx = arg;
1515
1516 do
1517 {
1518 sys_arch_mbox_fetch(&pppMbox, (void**)&pcrx, 0); //Wait indefinitely
1519
1520 while (lcp_phase[pcrx->pd] != PHASE_DEAD) {
1521 count = sio_read(pcrx->fd, pcrx->rxbuf, PPPOS_RX_BUFSIZE);
1522 if(count > 0) {
1523 pppInProc(pcrx, pcrx->rxbuf, count);
1524 } else {
1525 /* nothing received, give other tasks a chance to run */
1526 sys_msleep(1);
1527 }
1528 }
1529 } while(1); //Never terminates
1530 }
1531 #endif /* PPPOS_SUPPORT && PPP_INPROC_OWNTHREAD */
1532
1533 #if PPPOE_SUPPORT
1534
1535 void
1536 pppOverEthernetInitFailed(int pd)
1537 {
1538 PPPControl* pc;
1539
1540 pppHup(pd);
1541 pppStop(pd);
1542
1543 pc = &pppControl[pd];
1544 pppoe_destroy(&pc->netif);
1545 pc->openFlag = 0;
1546
1547 if(pc->linkStatusCB) {
1548 pc->linkStatusCB(pc->linkStatusCtx, pc->errCode ? pc->errCode : PPPERR_PROTOCOL, NULL);
1549 }
1550 }
1551
1552 static void
1553 pppOverEthernetLinkStatusCB(int pd, int up)
1554 {
1555 if(up) {
1556 PPPDEBUG(LOG_INFO, ("pppOverEthernetLinkStatusCB: unit %d: Connecting\n", pd));
1557 pppStart(pd);
1558 } else {
1559 pppOverEthernetInitFailed(pd);
1560 }
1561 }
1562 #endif /* PPPOE_SUPPORT */
1563
1564 struct pbuf *
1565 pppSingleBuf(struct pbuf *p)
1566 {
1567 struct pbuf *q, *b;
1568 u_char *pl;
1569
1570 if(p->tot_len == p->len) {
1571 return p;
1572 }
1573
1574 q = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);
1575 if(!q) {
1576 PPPDEBUG(LOG_ERR,
1577 ("pppSingleBuf: unable to alloc new buf (%d)\n", p->tot_len));
1578 return p; /* live dangerously */
1579 }
1580
1581 for(b = p, pl = q->payload; b != NULL; b = b->next) {
1582 MEMCPY(pl, b->payload, b->len);
1583 pl += b->len;
1584 }
1585
1586 pbuf_free(p);
1587
1588 return q;
1589 }
1590
1591 struct pppInputHeader {
1592 int unit;
1593 u16_t proto;
1594 };
1595
1596 /*
1597 * Pass the processed input packet to the appropriate handler.
1598 * This function and all handlers run in the context of the tcpip_thread
1599 */
1600 static void
1601 pppInput(void *arg)
1602 {
1603 struct pbuf *nb = (struct pbuf *)arg;
1604 u16_t protocol;
1605 int pd;
1606
1607 pd = ((struct pppInputHeader *)nb->payload)->unit;
1608 protocol = ((struct pppInputHeader *)nb->payload)->proto;
1609
1610 if(pbuf_header(nb, -(int)sizeof(struct pppInputHeader))) {
1611 LWIP_ASSERT("pbuf_header failed\n", 0);
1612 goto drop;
1613 }
1614
1615 LINK_STATS_INC(link.recv);
1616 snmp_inc_ifinucastpkts(&pppControl[pd].netif);
1617 snmp_add_ifinoctets(&pppControl[pd].netif, nb->tot_len);
1618
1619 /*
1620 * Toss all non-LCP packets unless LCP is OPEN.
1621 * Until we get past the authentication phase, toss all packets
1622 * except LCP, LQR and authentication packets.
1623 */
1624 if((lcp_phase[pd] <= PHASE_AUTHENTICATE) && (protocol != PPP_LCP)) {
1625 if(!((protocol == PPP_LQR) || (protocol == PPP_PAP) || (protocol == PPP_CHAP)) ||
1626 (lcp_phase[pd] != PHASE_AUTHENTICATE)) {
1627 PPPDEBUG(LOG_INFO, ("pppInput: discarding proto 0x%"X16_F" in phase %d\n", protocol, lcp_phase[pd]));
1628 goto drop;
1629 }
1630 }
1631
1632 switch(protocol) {
1633 case PPP_VJC_COMP: /* VJ compressed TCP */
1634 #if PPPOS_SUPPORT && VJ_SUPPORT
1635 PPPDEBUG(LOG_INFO, ("pppInput[%d]: vj_comp in pbuf len=%d\n", pd, nb->len));
1636 /*
1637 * Clip off the VJ header and prepend the rebuilt TCP/IP header and
1638 * pass the result to IP.
1639 */
1640 if ((vj_uncompress_tcp(&nb, &pppControl[pd].vjComp) >= 0) && (pppControl[pd].netif.input)) {
1641 pppControl[pd].netif.input(nb, &pppControl[pd].netif);
1642 return;
1643 }
1644 /* Something's wrong so drop it. */
1645 PPPDEBUG(LOG_WARNING, ("pppInput[%d]: Dropping VJ compressed\n", pd));
1646 #else /* PPPOS_SUPPORT && VJ_SUPPORT */
1647 /* No handler for this protocol so drop the packet. */
1648 PPPDEBUG(LOG_INFO, ("pppInput[%d]: drop VJ Comp in %d:%s\n", pd, nb->len, nb->payload));
1649 #endif /* PPPOS_SUPPORT && VJ_SUPPORT */
1650 break;
1651
1652 case PPP_VJC_UNCOMP: /* VJ uncompressed TCP */
1653 #if PPPOS_SUPPORT && VJ_SUPPORT
1654 PPPDEBUG(LOG_INFO, ("pppInput[%d]: vj_un in pbuf len=%d\n", pd, nb->len));
1655 /*
1656 * Process the TCP/IP header for VJ header compression and then pass
1657 * the packet to IP.
1658 */
1659 if ((vj_uncompress_uncomp(nb, &pppControl[pd].vjComp) >= 0) && pppControl[pd].netif.input) {
1660 pppControl[pd].netif.input(nb, &pppControl[pd].netif);
1661 return;
1662 }
1663 /* Something's wrong so drop it. */
1664 PPPDEBUG(LOG_WARNING, ("pppInput[%d]: Dropping VJ uncompressed\n", pd));
1665 #else /* PPPOS_SUPPORT && VJ_SUPPORT */
1666 /* No handler for this protocol so drop the packet. */
1667 PPPDEBUG(LOG_INFO,
1668 ("pppInput[%d]: drop VJ UnComp in %d:.*H\n",
1669 pd, nb->len, LWIP_MIN(nb->len * 2, 40), nb->payload));
1670 #endif /* PPPOS_SUPPORT && VJ_SUPPORT */
1671 break;
1672
1673 case PPP_IP: /* Internet Protocol */
1674 PPPDEBUG(LOG_INFO, ("pppInput[%d]: ip in pbuf len=%d\n", pd, nb->len));
1675 if (pppControl[pd].netif.input) {
1676 pppControl[pd].netif.input(nb, &pppControl[pd].netif);
1677 return;
1678 }
1679 break;
1680
1681 default: {
1682 struct protent *protp;
1683 int i;
1684
1685 /*
1686 * Upcall the proper protocol input routine.
1687 */
1688 for (i = 0; (protp = ppp_protocols[i]) != NULL; ++i) {
1689 if (protp->protocol == protocol && protp->enabled_flag) {
1690 PPPDEBUG(LOG_INFO, ("pppInput[%d]: %s len=%d\n", pd, protp->name, nb->len));
1691 nb = pppSingleBuf(nb);
1692 (*protp->input)(pd, nb->payload, nb->len);
1693 PPPDEBUG(LOG_DETAIL, ("pppInput[%d]: packet processed\n", pd));
1694 goto out;
1695 }
1696 }
1697
1698 /* No handler for this protocol so reject the packet. */
1699 PPPDEBUG(LOG_INFO, ("pppInput[%d]: rejecting unsupported proto 0x%"X16_F" len=%d\n", pd, protocol, nb->len));
1700 if (pbuf_header(nb, sizeof(protocol))) {
1701 LWIP_ASSERT("pbuf_header failed\n", 0);
1702 goto drop;
1703 }
1704 #if BYTE_ORDER == LITTLE_ENDIAN
1705 protocol = htons(protocol);
1706 #endif /* BYTE_ORDER == LITTLE_ENDIAN */
1707 SMEMCPY(nb->payload, &protocol, sizeof(protocol));
1708 lcp_sprotrej(pd, nb->payload, nb->len);
1709 }
1710 break;
1711 }
1712
1713 drop:
1714 LINK_STATS_INC(link.drop);
1715 snmp_inc_ifindiscards(&pppControl[pd].netif);
1716
1717 out:
1718 pbuf_free(nb);
1719 return;
1720 }
1721
1722 #if PPPOS_SUPPORT
1723 /*
1724 * Drop the input packet.
1725 */
1726 static void
1727 pppDrop(PPPControlRx *pcrx)
1728 {
1729 if (pcrx->inHead != NULL) {
1730 #if 0
1731 PPPDEBUG(LOG_INFO, ("pppDrop: %d:%.*H\n", pcrx->inHead->len, min(60, pcrx->inHead->len * 2), pcrx->inHead->payload));
1732 #endif
1733 PPPDEBUG(LOG_INFO, ("pppDrop: pbuf len=%d, addr %p\n", pcrx->inHead->len, (void*)pcrx->inHead));
1734 if (pcrx->inTail && (pcrx->inTail != pcrx->inHead)) {
1735 pbuf_free(pcrx->inTail);
1736 }
1737 pbuf_free(pcrx->inHead);
1738 pcrx->inHead = NULL;
1739 pcrx->inTail = NULL;
1740 }
1741 #if VJ_SUPPORT
1742 vj_uncompress_err(&pppControl[pcrx->pd].vjComp);
1743 #endif /* VJ_SUPPORT */
1744
1745 LINK_STATS_INC(link.drop);
1746 snmp_inc_ifindiscards(&pppControl[pcrx->pd].netif);
1747 }
1748
1749 /** Pass received raw characters to PPPoS to be decoded. This function is
1750 * thread-safe and can be called from a dedicated RX-thread or from a main-loop.
1751 *
1752 * @param pd PPP descriptor index, returned by pppOpen()
1753 * @param data received data
1754 * @param len length of received data
1755 */
1756 void
1757 pppos_input(int pd, u_char* data, int len)
1758 {
1759 pppInProc(&pppControl[pd].rx, data, len);
1760 }
1761
1762 /**
1763 * Process a received octet string.
1764 */
1765 static void
1766 pppInProc(PPPControlRx *pcrx, u_char *s, int l)
1767 {
1768 struct pbuf *nextNBuf;
1769 u_char curChar;
1770 u_char escaped;
1771 SYS_ARCH_DECL_PROTECT(lev);
1772
1773 PPPDEBUG(LOG_DEBUG, ("pppInProc[%d]: got %d bytes\n", pcrx->pd, l));
1774 while (l-- > 0) {
1775 curChar = *s++;
1776
1777 SYS_ARCH_PROTECT(lev);
1778 escaped = ESCAPE_P(pcrx->inACCM, curChar);
1779 SYS_ARCH_UNPROTECT(lev);
1780 /* Handle special characters. */
1781 if (escaped) {
1782 /* Check for escape sequences. */
1783 /* XXX Note that this does not handle an escaped 0x5d character which
1784 * would appear as an escape character. Since this is an ASCII ']'
1785 * and there is no reason that I know of to escape it, I won't complicate
1786 * the code to handle this case. GLL */
1787 if (curChar == PPP_ESCAPE) {
1788 pcrx->inEscaped = 1;
1789 /* Check for the flag character. */
1790 } else if (curChar == PPP_FLAG) {
1791 /* If this is just an extra flag character, ignore it. */
1792 if (pcrx->inState <= PDADDRESS) {
1793 /* ignore it */;
1794 /* If we haven't received the packet header, drop what has come in. */
1795 } else if (pcrx->inState < PDDATA) {
1796 PPPDEBUG(LOG_WARNING,
1797 ("pppInProc[%d]: Dropping incomplete packet %d\n",
1798 pcrx->pd, pcrx->inState));
1799 LINK_STATS_INC(link.lenerr);
1800 pppDrop(pcrx);
1801 /* If the fcs is invalid, drop the packet. */
1802 } else if (pcrx->inFCS != PPP_GOODFCS) {
1803 PPPDEBUG(LOG_INFO,
1804 ("pppInProc[%d]: Dropping bad fcs 0x%"X16_F" proto=0x%"X16_F"\n",
1805 pcrx->pd, pcrx->inFCS, pcrx->inProtocol));
1806 /* Note: If you get lots of these, check for UART frame errors or try different baud rate */
1807 LINK_STATS_INC(link.chkerr);
1808 pppDrop(pcrx);
1809 /* Otherwise it's a good packet so pass it on. */
1810 } else {
1811 struct pbuf *inp;
1812 /* Trim off the checksum. */
1813 if(pcrx->inTail->len >= 2) {
1814 pcrx->inTail->len -= 2;
1815
1816 pcrx->inTail->tot_len = pcrx->inTail->len;
1817 if (pcrx->inTail != pcrx->inHead) {
1818 pbuf_cat(pcrx->inHead, pcrx->inTail);
1819 }
1820 } else {
1821 pcrx->inTail->tot_len = pcrx->inTail->len;
1822 if (pcrx->inTail != pcrx->inHead) {
1823 pbuf_cat(pcrx->inHead, pcrx->inTail);
1824 }
1825
1826 pbuf_realloc(pcrx->inHead, pcrx->inHead->tot_len - 2);
1827 }
1828
1829 /* Dispatch the packet thereby consuming it. */
1830 inp = pcrx->inHead;
1831 /* Packet consumed, release our references. */
1832 pcrx->inHead = NULL;
1833 pcrx->inTail = NULL;
1834 #if PPP_INPROC_MULTITHREADED
1835 if(tcpip_callback_with_block(pppInput, inp, 0) != ERR_OK) {
1836 PPPDEBUG(LOG_ERR, ("pppInProc[%d]: tcpip_callback() failed, dropping packet\n", pcrx->pd));
1837 pbuf_free(inp);
1838 LINK_STATS_INC(link.drop);
1839 snmp_inc_ifindiscards(&pppControl[pcrx->pd].netif);
1840 }
1841 #else /* PPP_INPROC_MULTITHREADED */
1842 pppInput(inp);
1843 #endif /* PPP_INPROC_MULTITHREADED */
1844 }
1845
1846 /* Prepare for a new packet. */
1847 pcrx->inFCS = PPP_INITFCS;
1848 pcrx->inState = PDADDRESS;
1849 pcrx->inEscaped = 0;
1850 /* Other characters are usually control characters that may have
1851 * been inserted by the physical layer so here we just drop them. */
1852 } else {
1853 PPPDEBUG(LOG_WARNING,
1854 ("pppInProc[%d]: Dropping ACCM char <%d>\n", pcrx->pd, curChar));
1855 }
1856 /* Process other characters. */
1857 } else {
1858 /* Unencode escaped characters. */
1859 if (pcrx->inEscaped) {
1860 pcrx->inEscaped = 0;
1861 curChar ^= PPP_TRANS;
1862 }
1863
1864 /* Process character relative to current state. */
1865 switch(pcrx->inState) {
1866 case PDIDLE: /* Idle state - waiting. */
1867 /* Drop the character if it's not 0xff
1868 * we would have processed a flag character above. */
1869 if (curChar != PPP_ALLSTATIONS) {
1870 break;
1871 }
1872
1873 /* Fall through */
1874 case PDSTART: /* Process start flag. */
1875 /* Prepare for a new packet. */
1876 pcrx->inFCS = PPP_INITFCS;
1877
1878 /* Fall through */
1879 case PDADDRESS: /* Process address field. */
1880 if (curChar == PPP_ALLSTATIONS) {
1881 pcrx->inState = PDCONTROL;
1882 break;
1883 }
1884 /* Else assume compressed address and control fields so
1885 * fall through to get the protocol... */
1886 case PDCONTROL: /* Process control field. */
1887 /* If we don't get a valid control code, restart. */
1888 if (curChar == PPP_UI) {
1889 pcrx->inState = PDPROTOCOL1;
1890 break;
1891 }
1892 #if 0
1893 else {
1894 PPPDEBUG(LOG_WARNING,
1895 ("pppInProc[%d]: Invalid control <%d>\n", pcrx->pd, curChar));
1896 pcrx->inState = PDSTART;
1897 }
1898 #endif
1899 case PDPROTOCOL1: /* Process protocol field 1. */
1900 /* If the lower bit is set, this is the end of the protocol
1901 * field. */
1902 if (curChar & 1) {
1903 pcrx->inProtocol = curChar;
1904 pcrx->inState = PDDATA;
1905 } else {
1906 pcrx->inProtocol = (u_int)curChar << 8;
1907 pcrx->inState = PDPROTOCOL2;
1908 }
1909 break;
1910 case PDPROTOCOL2: /* Process protocol field 2. */
1911 pcrx->inProtocol |= curChar;
1912 pcrx->inState = PDDATA;
1913 break;
1914 case PDDATA: /* Process data byte. */
1915 /* Make space to receive processed data. */
1916 if (pcrx->inTail == NULL || pcrx->inTail->len == PBUF_POOL_BUFSIZE) {
1917 if (pcrx->inTail != NULL) {
1918 pcrx->inTail->tot_len = pcrx->inTail->len;
1919 if (pcrx->inTail != pcrx->inHead) {
1920 pbuf_cat(pcrx->inHead, pcrx->inTail);
1921 /* give up the inTail reference now */
1922 pcrx->inTail = NULL;
1923 }
1924 }
1925 /* If we haven't started a packet, we need a packet header. */
1926 nextNBuf = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
1927 if (nextNBuf == NULL) {
1928 /* No free buffers. Drop the input packet and let the
1929 * higher layers deal with it. Continue processing
1930 * the received pbuf chain in case a new packet starts. */
1931 PPPDEBUG(LOG_ERR, ("pppInProc[%d]: NO FREE MBUFS!\n", pcrx->pd));
1932 LINK_STATS_INC(link.memerr);
1933 pppDrop(pcrx);
1934 pcrx->inState = PDSTART; /* Wait for flag sequence. */
1935 break;
1936 }
1937 if (pcrx->inHead == NULL) {
1938 struct pppInputHeader *pih = nextNBuf->payload;
1939
1940 pih->unit = pcrx->pd;
1941 pih->proto = pcrx->inProtocol;
1942
1943 nextNBuf->len += sizeof(*pih);
1944
1945 pcrx->inHead = nextNBuf;
1946 }
1947 pcrx->inTail = nextNBuf;
1948 }
1949 /* Load character into buffer. */
1950 ((u_char*)pcrx->inTail->payload)[pcrx->inTail->len++] = curChar;
1951 break;
1952 }
1953
1954 /* update the frame check sequence number. */
1955 pcrx->inFCS = PPP_FCS(pcrx->inFCS, curChar);
1956 }
1957 } /* while (l-- > 0), all bytes processed */
1958
1959 avRandomize();
1960 }
1961 #endif /* PPPOS_SUPPORT */
1962
1963 #if PPPOE_SUPPORT
1964 void
1965 pppInProcOverEthernet(int pd, struct pbuf *pb)
1966 {
1967 struct pppInputHeader *pih;
1968 u16_t inProtocol;
1969
1970 if(pb->len < sizeof(inProtocol)) {
1971 PPPDEBUG(LOG_ERR, ("pppInProcOverEthernet: too small for protocol field\n"));
1972 goto drop;
1973 }
1974
1975 inProtocol = (((u8_t *)pb->payload)[0] << 8) | ((u8_t*)pb->payload)[1];
1976
1977 /* make room for pppInputHeader - should not fail */
1978 if (pbuf_header(pb, sizeof(*pih) - sizeof(inProtocol)) != 0) {
1979 PPPDEBUG(LOG_ERR, ("pppInProcOverEthernet: could not allocate room for header\n"));
1980 goto drop;
1981 }
1982
1983 pih = pb->payload;
1984
1985 pih->unit = pd;
1986 pih->proto = inProtocol;
1987
1988 /* Dispatch the packet thereby consuming it. */
1989 pppInput(pb);
1990 return;
1991
1992 drop:
1993 LINK_STATS_INC(link.drop);
1994 snmp_inc_ifindiscards(&pppControl[pd].netif);
1995 pbuf_free(pb);
1996 return;
1997 }
1998 #endif /* PPPOE_SUPPORT */
1999
2000 #if LWIP_NETIF_STATUS_CALLBACK
2001 /** Set the status callback of a PPP's netif
2002 *
2003 * @param pd The PPP descriptor returned by pppOpen()
2004 * @param status_callback pointer to the status callback function
2005 *
2006 * @see netif_set_status_callback
2007 */
2008 void
2009 ppp_set_netif_statuscallback(int pd, netif_status_callback_fn status_callback)
2010 {
2011 netif_set_status_callback(&pppControl[pd].netif, status_callback);
2012 }
2013 #endif /* LWIP_NETIF_STATUS_CALLBACK */
2014
2015 #if LWIP_NETIF_LINK_CALLBACK
2016 /** Set the link callback of a PPP's netif
2017 *
2018 * @param pd The PPP descriptor returned by pppOpen()
2019 * @param link_callback pointer to the link callback function
2020 *
2021 * @see netif_set_link_callback
2022 */
2023 void
2024 ppp_set_netif_linkcallback(int pd, netif_status_callback_fn link_callback)
2025 {
2026 netif_set_link_callback(&pppControl[pd].netif, link_callback);
2027 }
2028 #endif /* LWIP_NETIF_LINK_CALLBACK */
2029
2030 #endif /* PPP_SUPPORT */
custom keymap for my minivan; forked from http://github.com/evangs/tmk_keyboard
Imprint / Impressum