1 /*****************************************************************************
2 * ppp.c - Network Point to Point Protocol program file.
4 * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.
5 * portions Copyright (c) 1997 by Global Election Systems Inc.
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.
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.
25 ******************************************************************************
28 * 03-01-01 Marc Boucher <marc@mbsi.ca>
30 * 97-11-05 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
32 *****************************************************************************/
35 * ppp_defs.h - PPP definitions.
37 * if_pppvar.h - private structures and declarations for PPP.
39 * Copyright (c) 1994 The Australian National University.
40 * All rights reserved.
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
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
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,
64 * if_ppp.h - Point-to-Point Protocol definitions.
66 * Copyright (c) 1989 Carnegie Mellon University.
67 * All rights reserved.
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.
102 #include "pppdebug.h"
104 /*************************/
105 /*** LOCAL DEFINITIONS ***/
106 /*************************/
109 * The basic PPP frame.
111 #define PPP_ADDRESS(p) (((u_char *)(p))[0])
112 #define PPP_CONTROL(p) (((u_char *)(p))[1])
113 #define PPP_PROTOCOL(p) ((((u_char *)(p))[2] << 8) + ((u_char *)(p))[3])
115 /* PPP packet parser states. Current state indicates operation yet to be
118 PDIDLE = 0, /* Idle state - waiting. */
119 PDSTART, /* Process start flag. */
120 PDADDRESS, /* Process address field. */
121 PDCONTROL, /* Process control field. */
122 PDPROTOCOL1, /* Process protocol field 1. */
123 PDPROTOCOL2, /* Process protocol field 2. */
124 PDDATA /* Process data byte. */
127 #define ESCAPE_P(accm, c) ((accm)[(c) >> 3] & pppACCMMask[c & 0x07])
129 /************************/
130 /*** LOCAL DATA TYPES ***/
131 /************************/
133 * PPP interface control block.
135 typedef struct PPPControl_s {
136 char openFlag; /* True when in use. */
137 char oldFrame; /* Old framing character for fd. */
138 sio_fd_t fd; /* File device ID of port. */
139 int kill_link; /* Shut the link down. */
140 int sig_hup; /* Carrier lost. */
141 int if_up; /* True when the interface is up. */
142 int errCode; /* Code indicating why interface is down. */
143 struct pbuf *inHead, *inTail; /* The input packet. */
144 PPPDevStates inState; /* The input process state. */
145 char inEscaped; /* Escape next character. */
146 u16_t inProtocol; /* The input protocol code. */
147 u16_t inFCS; /* Input Frame Check Sequence value. */
148 int mtu; /* Peer's mru */
149 int pcomp; /* Does peer accept protocol compression? */
150 int accomp; /* Does peer accept addr/ctl compression? */
151 u_long lastXMit; /* Time of last transmission. */
152 ext_accm inACCM; /* Async-Ctl-Char-Map for input. */
153 ext_accm outACCM; /* Async-Ctl-Char-Map for output. */
155 int vjEnabled; /* Flag indicating VJ compression enabled. */
156 struct vjcompress vjComp; /* Van Jabobsen compression header. */
161 struct ppp_addrs addrs;
163 void (*linkStatusCB)(void *ctx, int errCode, void *arg);
174 int protocol; /* PPP procotol, e.g. PPP_IP */
180 /***********************************/
181 /*** LOCAL FUNCTION DECLARATIONS ***/
182 /***********************************/
183 static void pppMain(void *pd);
184 static void pppDrop(PPPControl *pc);
185 static void pppInProc(int pd, u_char *s, int l);
188 /******************************/
189 /*** PUBLIC DATA STRUCTURES ***/
190 /******************************/
193 static PPPControl pppControl[NUM_PPP]; /* The PPP interface control blocks. */
196 * PPP Data Link Layer "protocol" table.
197 * One entry per supported protocol.
198 * The last entry must be NULL.
200 struct protent *ppp_protocols[] = {
220 * Buffers for outgoing packets. This must be accessed only from the appropriate
221 * PPP task so that it doesn't need to be protected to avoid collisions.
223 u_char outpacket_buf[NUM_PPP][PPP_MRU+PPP_HDRLEN];
226 /*****************************/
227 /*** LOCAL DATA STRUCTURES ***/
228 /*****************************/
231 * FCS lookup table as calculated by genfcstab.
233 static const u_short fcstab[256] = {
234 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
235 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
236 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
237 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
238 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
239 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
240 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
241 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
242 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
243 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
244 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
245 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
246 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
247 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
248 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
249 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
250 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
251 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
252 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
253 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
254 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
255 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
256 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
257 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
258 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
259 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
260 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
261 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
262 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
263 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
264 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
265 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
268 /* PPP's Asynchronous-Control-Character-Map. The mask array is used
269 * to select the specific bit for a character. */
270 static u_char pppACCMMask[] = {
282 /***********************************/
283 /*** PUBLIC FUNCTION DEFINITIONS ***/
284 /***********************************/
285 /* Initialize the PPP subsystem. */
287 struct ppp_settings ppp_settings;
291 struct protent *protp;
294 memset(&ppp_settings, 0, sizeof(ppp_settings));
295 ppp_settings.usepeerdns = 1;
296 pppSetAuth(PPPAUTHTYPE_NONE, NULL, NULL);
300 for (i = 0; i < NUM_PPP; i++) {
301 pppControl[i].openFlag = 0;
303 subnetMask = htonl(0xffffff00);
306 * Initialize to the standard option set.
308 for (j = 0; (protp = ppp_protocols[j]) != NULL; ++j)
313 /* Clear the statistics. */
314 memset(&lwip_stats.link, 0, sizeof(lwip_stats.link));
318 void pppSetAuth(enum pppAuthType authType, const char *user, const char *passwd)
321 case PPPAUTHTYPE_NONE:
323 #ifdef LWIP_PPP_STRICT_PAP_REJECT
324 ppp_settings.refuse_pap = 1;
326 /* some providers request pap and accept an empty login/pw */
327 ppp_settings.refuse_pap = 0;
329 ppp_settings.refuse_chap = 1;
331 case PPPAUTHTYPE_ANY:
332 /* Warning: Using PPPAUTHTYPE_ANY might have security consequences.
335 * In practice, within or associated with each PPP server, there is a
336 * database which associates "user" names with authentication
337 * information ("secrets"). It is not anticipated that a particular
338 * named user would be authenticated by multiple methods. This would
339 * make the user vulnerable to attacks which negotiate the least secure
340 * method from among a set (such as PAP rather than CHAP). If the same
341 * secret was used, PAP would reveal the secret to be used later with
344 * Instead, for each user name there should be an indication of exactly
345 * one method used to authenticate that user name. If a user needs to
346 * make use of different authentication methods under different
347 * circumstances, then distinct user names SHOULD be employed, each of
348 * which identifies exactly one authentication method.
351 ppp_settings.refuse_pap = 0;
352 ppp_settings.refuse_chap = 0;
354 case PPPAUTHTYPE_PAP:
355 ppp_settings.refuse_pap = 0;
356 ppp_settings.refuse_chap = 1;
358 case PPPAUTHTYPE_CHAP:
359 ppp_settings.refuse_pap = 1;
360 ppp_settings.refuse_chap = 0;
365 strncpy(ppp_settings.user, user, sizeof(ppp_settings.user)-1);
366 ppp_settings.user[sizeof(ppp_settings.user)-1] = '\0';
368 ppp_settings.user[0] = '\0';
371 strncpy(ppp_settings.passwd, passwd, sizeof(ppp_settings.passwd)-1);
372 ppp_settings.passwd[sizeof(ppp_settings.passwd)-1] = '\0';
374 ppp_settings.passwd[0] = '\0';
377 /* Open a new PPP connection using the given I/O device.
378 * This initializes the PPP control block but does not
379 * attempt to negotiate the LCP session. If this port
380 * connects to a modem, the modem connection must be
381 * established before calling this.
382 * Return a new PPP connection descriptor on success or
383 * an error code (negative) on failure. */
384 int pppOpen(sio_fd_t fd, void (*linkStatusCB)(void *ctx, int errCode, void *arg), void *linkStatusCtx)
389 /* Find a free PPP session descriptor. Critical region? */
390 for (pd = 0; pd < NUM_PPP && pppControl[pd].openFlag != 0; pd++);
394 pppControl[pd].openFlag = !0;
396 /* Launch a deamon thread. */
399 pppControl[pd].openFlag = 1;
402 pc = &pppControl[pd];
408 pc->inState = PDIDLE;
416 vj_compress_init(&pc->vjComp);
420 * Default the in and out accm so that escape and flag characters
421 * are always escaped.
423 memset(pc->inACCM, 0, sizeof(ext_accm));
424 pc->inACCM[15] = 0x60;
425 memset(pc->outACCM, 0, sizeof(ext_accm));
426 pc->outACCM[15] = 0x60;
428 pc->linkStatusCB = linkStatusCB;
429 pc->linkStatusCtx = linkStatusCtx;
431 sys_thread_new(pppMain, (void*)pd, PPP_THREAD_PRIO);
433 while(pd >= 0 && !pc->if_up) {
435 if (lcp_phase[pd] == PHASE_DEAD) {
448 /* Close a PPP connection and release the descriptor.
449 * Any outstanding packets in the queues are dropped.
450 * Return 0 on success, an error code on failure. */
453 PPPControl *pc = &pppControl[pd];
460 if(!pc->linkStatusCB) {
461 while(st >= 0 && lcp_phase[pd] != PHASE_DEAD) {
469 /* This function is called when carrier is lost on the PPP channel. */
470 void pppSigHUP(int pd)
472 PPPControl *pc = &pppControl[pd];
478 static void nPut(PPPControl *pc, struct pbuf *nb)
483 for(b = nb; b != NULL; b = b->next) {
484 if((c = sio_write(pc->fd, b->payload, b->len)) != b->len) {
485 PPPDEBUG((LOG_WARNING,
486 "PPP nPut: incomplete sio_write(%d,, %u) = %d\n", pc->fd, b->len, c));
488 lwip_stats.link.err++;
489 #endif /* LINK_STATS */
490 pc->lastXMit = 0; /* prepend PPP_FLAG to next packet */
497 lwip_stats.link.xmit++;
498 #endif /* LINK_STATS */
502 * pppAppend - append given character to end of given pbuf. If outACCM
503 * is not NULL and the character needs to be escaped, do so.
504 * If pbuf is full, append another.
505 * Return the current pbuf.
507 static struct pbuf *pppAppend(u_char c, struct pbuf *nb, ext_accm *outACCM)
509 struct pbuf *tb = nb;
511 /* Make sure there is room for the character and an escape code.
512 * Sure we don't quite fill the buffer if the character doesn't
513 * get escaped but is one character worth complicating this? */
514 /* Note: We assume no packet header. */
515 if (nb && (PBUF_POOL_BUFSIZE - nb->len) < 2) {
516 tb = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
522 lwip_stats.link.memerr++;
524 #endif /* LINK_STATS */
528 if (outACCM && ESCAPE_P(*outACCM, c)) {
529 *((u_char*)nb->payload + nb->len++) = PPP_ESCAPE;
530 *((u_char*)nb->payload + nb->len++) = c ^ PPP_TRANS;
533 *((u_char*)nb->payload + nb->len++) = c;
539 /* Send a packet on the given connection. */
540 static err_t pppifOutput(struct netif *netif, struct pbuf *pb, struct ip_addr *ipaddr)
542 int pd = (int)netif->state;
543 u_short protocol = PPP_IP;
544 PPPControl *pc = &pppControl[pd];
545 u_int fcsOut = PPP_INITFCS;
546 struct pbuf *headMB = NULL, *tailMB = NULL, *p;
551 /* Validate parameters. */
552 /* We let any protocol value go through - it can't hurt us
553 * and the peer will just drop it if it's not accepting it. */
554 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag || !pb) {
555 PPPDEBUG((LOG_WARNING, "pppifOutput[%d]: bad parms prot=%d pb=%p\n",
558 lwip_stats.link.opterr++;
559 lwip_stats.link.drop++;
564 /* Check that the link is up. */
565 if (lcp_phase[pd] == PHASE_DEAD) {
566 PPPDEBUG((LOG_ERR, "pppifOutput[%d]: link not up\n", pd));
568 lwip_stats.link.rterr++;
569 lwip_stats.link.drop++;
574 /* Grab an output buffer. */
575 headMB = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
576 if (headMB == NULL) {
577 PPPDEBUG((LOG_WARNING, "pppifOutput[%d]: first alloc fail\n", pd));
579 lwip_stats.link.memerr++;
580 lwip_stats.link.drop++;
581 #endif /* LINK_STATS */
587 * Attempt Van Jacobson header compression if VJ is configured and
588 * this is an IP packet.
590 if (protocol == PPP_IP && pc->vjEnabled) {
591 switch (vj_compress_tcp(&pc->vjComp, pb)) {
594 protocol = PPP_IP_PROTOCOL;
597 case TYPE_COMPRESSED_TCP:
598 protocol = PPP_VJC_COMP;
600 case TYPE_UNCOMPRESSED_TCP:
601 protocol = PPP_VJC_UNCOMP;
604 PPPDEBUG((LOG_WARNING, "pppifOutput[%d]: bad IP packet\n", pd));
606 lwip_stats.link.proterr++;
607 lwip_stats.link.drop++;
617 /* Build the PPP header. */
618 if ((sys_jiffies() - pc->lastXMit) >= PPP_MAXIDLEFLAG)
619 tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
620 pc->lastXMit = sys_jiffies();
622 fcsOut = PPP_FCS(fcsOut, PPP_ALLSTATIONS);
623 tailMB = pppAppend(PPP_ALLSTATIONS, tailMB, &pc->outACCM);
624 fcsOut = PPP_FCS(fcsOut, PPP_UI);
625 tailMB = pppAppend(PPP_UI, tailMB, &pc->outACCM);
627 if (!pc->pcomp || protocol > 0xFF) {
628 c = (protocol >> 8) & 0xFF;
629 fcsOut = PPP_FCS(fcsOut, c);
630 tailMB = pppAppend(c, tailMB, &pc->outACCM);
633 fcsOut = PPP_FCS(fcsOut, c);
634 tailMB = pppAppend(c, tailMB, &pc->outACCM);
637 for(p = pb; p; p = p->next) {
641 sPtr = (u_char*)p->payload;
646 /* Update FCS before checking for special characters. */
647 fcsOut = PPP_FCS(fcsOut, c);
649 /* Copy to output buffer escaping special characters. */
650 tailMB = pppAppend(c, tailMB, &pc->outACCM);
654 /* Add FCS and trailing flag. */
656 tailMB = pppAppend(c, tailMB, &pc->outACCM);
657 c = (~fcsOut >> 8) & 0xFF;
658 tailMB = pppAppend(c, tailMB, &pc->outACCM);
659 tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
661 /* If we failed to complete the packet, throw it away. */
663 PPPDEBUG((LOG_WARNING,
664 "pppifOutput[%d]: Alloc err - dropping proto=%d\n",
668 lwip_stats.link.memerr++;
669 lwip_stats.link.drop++;
675 PPPDEBUG((LOG_INFO, "pppifOutput[%d]: proto=0x%04X\n", pd, protocol));
682 /* Get and set parameters for the given connection.
683 * Return 0 on success, an error code on failure. */
684 int pppIOCtl(int pd, int cmd, void *arg)
686 PPPControl *pc = &pppControl[pd];
689 if (pd < 0 || pd >= NUM_PPP)
693 case PPPCTLG_UPSTATUS: /* Get the PPP up status. */
695 *(int *)arg = (int)(pc->if_up);
699 case PPPCTLS_ERRCODE: /* Set the PPP error code. */
701 pc->errCode = *(int *)arg;
705 case PPPCTLG_ERRCODE: /* Get the PPP error code. */
707 *(int *)arg = (int)(pc->errCode);
713 *(sio_fd_t *)arg = pc->fd;
727 * Return the Maximum Transmission Unit for the given PPP connection.
731 PPPControl *pc = &pppControl[pd];
734 /* Validate parameters. */
735 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag)
744 * Write n characters to a ppp link.
745 * RETURN: >= 0 Number of characters written
746 * -1 Failed to write to device
748 int pppWrite(int pd, const u_char *s, int n)
750 PPPControl *pc = &pppControl[pd];
752 u_int fcsOut = PPP_INITFCS;
753 struct pbuf *headMB = NULL, *tailMB;
754 headMB = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
755 if (headMB == NULL) {
757 lwip_stats.link.memerr++;
758 lwip_stats.link.proterr++;
759 #endif /* LINK_STATS */
765 /* If the link has been idle, we'll send a fresh flag character to
766 * flush any noise. */
767 if ((sys_jiffies() - pc->lastXMit) >= PPP_MAXIDLEFLAG)
768 tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
769 pc->lastXMit = sys_jiffies();
771 /* Load output buffer. */
775 /* Update FCS before checking for special characters. */
776 fcsOut = PPP_FCS(fcsOut, c);
778 /* Copy to output buffer escaping special characters. */
779 tailMB = pppAppend(c, tailMB, &pc->outACCM);
782 /* Add FCS and trailing flag. */
784 tailMB = pppAppend(c, tailMB, &pc->outACCM);
785 c = (~fcsOut >> 8) & 0xFF;
786 tailMB = pppAppend(c, tailMB, &pc->outACCM);
787 tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
789 /* If we failed to complete the packet, throw it away.
790 * Otherwise send it. */
792 PPPDEBUG((LOG_WARNING,
793 "pppWrite[%d]: Alloc err - dropping pbuf len=%d\n", pd, headMB->len));
794 /* "pppWrite[%d]: Alloc err - dropping %d:%.*H", pd, headMB->len, LWIP_MIN(headMB->len * 2, 40), headMB->payload)); */
797 lwip_stats.link.memerr++;
798 lwip_stats.link.proterr++;
799 #endif /* LINK_STATS */
803 PPPDEBUG((LOG_INFO, "pppWrite[%d]: len=%d\n", pd, headMB->len));
804 /* "pppWrite[%d]: %d:%.*H", pd, headMB->len, LWIP_MIN(headMB->len * 2, 40), headMB->payload)); */
811 * ppp_send_config - configure the transmit characteristics of
814 void ppp_send_config(
822 PPPControl *pc = &pppControl[unit];
829 /* Load the ACCM bits for the 32 control codes. */
830 for (i = 0; i < 32/8; i++)
831 pc->outACCM[i] = (u_char)((asyncmap >> (8 * i)) & 0xFF);
832 PPPDEBUG((LOG_INFO, "ppp_send_config[%d]: outACCM=%X %X %X %X\n",
834 pc->outACCM[0], pc->outACCM[1], pc->outACCM[2], pc->outACCM[3]));
839 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
841 void ppp_set_xaccm(int unit, ext_accm *accm)
843 memcpy(pppControl[unit].outACCM, accm, sizeof(ext_accm));
844 PPPDEBUG((LOG_INFO, "ppp_set_xaccm[%d]: outACCM=%X %X %X %X\n",
846 pppControl[unit].outACCM[0],
847 pppControl[unit].outACCM[1],
848 pppControl[unit].outACCM[2],
849 pppControl[unit].outACCM[3]));
854 * ppp_recv_config - configure the receive-side characteristics of
857 void ppp_recv_config(
865 PPPControl *pc = &pppControl[unit];
872 /* Load the ACCM bits for the 32 control codes. */
873 for (i = 0; i < 32 / 8; i++)
874 pc->inACCM[i] = (u_char)(asyncmap >> (i * 8));
875 PPPDEBUG((LOG_INFO, "ppp_recv_config[%d]: inACCM=%X %X %X %X\n",
877 pc->inACCM[0], pc->inACCM[1], pc->inACCM[2], pc->inACCM[3]));
882 * ccp_test - ask kernel whether a given compression method
883 * is acceptable for use. Returns 1 if the method and parameters
884 * are OK, 0 if the method is known but the parameters are not OK
885 * (e.g. code size should be reduced), or -1 if the method is unknown.
894 return 0; /* XXX Currently no compression. */
898 * ccp_flags_set - inform kernel about the current state of CCP.
900 void ccp_flags_set(int unit, int isopen, int isup)
906 * ccp_fatal_error - returns 1 if decompression was disabled as a
907 * result of an error detected after decompression of a packet,
908 * 0 otherwise. This is necessary because of patent nonsense.
910 int ccp_fatal_error(int unit)
918 * get_idle_time - return how long the link has been idle.
920 int get_idle_time(int u, struct ppp_idle *ip)
931 * Return user specified netmask, modified by any mask we might determine
932 * for address `addr' (in network byte order).
933 * Here we scan through the system's list of interfaces, looking for
934 * any non-point-to-point interfaces which might appear to be on the same
935 * network as `addr'. If we find any, we OR in their netmask to the
936 * user-specified netmask.
938 u32_t GetMask(u32_t addr)
943 if (IN_CLASSA(addr)) /* determine network mask for address class */
944 nmask = IN_CLASSA_NET;
945 else if (IN_CLASSB(addr))
946 nmask = IN_CLASSB_NET;
948 nmask = IN_CLASSC_NET;
949 /* class D nets are disallowed by bad_ip_adrs */
950 mask = subnetMask | htonl(nmask);
953 * Scan through the system's network interfaces.
954 * Get each netmask and OR them into our mask.
961 * sifvjcomp - config tcp header compression
971 PPPControl *pc = &pppControl[pd];
973 pc->vjEnabled = vjcomp;
974 pc->vjComp.compressSlot = cidcomp;
975 pc->vjComp.maxSlotIndex = maxcid;
976 PPPDEBUG((LOG_INFO, "sifvjcomp: VJ compress enable=%d slot=%d max slot=%d\n",
977 vjcomp, cidcomp, maxcid));
984 * pppifNetifInit - netif init callback
986 static err_t pppifNetifInit(struct netif *netif)
988 netif->name[0] = 'p';
989 netif->name[1] = 'p';
990 netif->output = pppifOutput;
991 netif->mtu = pppMTU((int)netif->state);
997 * sifup - Config the interface up and enable IP packets to pass.
1001 PPPControl *pc = &pppControl[pd];
1004 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1006 PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parms\n", pd));
1008 netif_remove(&pc->netif);
1009 if (netif_add(&pc->netif, &pc->addrs.our_ipaddr, &pc->addrs.netmask, &pc->addrs.his_ipaddr, (void *)pd, pppifNetifInit, ip_input)) {
1011 pc->errCode = PPPERR_NONE;
1013 PPPDEBUG((LOG_DEBUG, "sifup: unit %d: linkStatusCB=%lx errCode=%d\n", pd, pc->linkStatusCB, pc->errCode));
1014 if(pc->linkStatusCB)
1015 pc->linkStatusCB(pc->linkStatusCtx, pc->errCode, &pc->addrs);
1018 PPPDEBUG((LOG_ERR, "sifup[%d]: netif_add failed\n", pd));
1026 * sifnpmode - Set the mode for handling packets for a given NP.
1028 int sifnpmode(int u, int proto, enum NPmode mode)
1037 * sifdown - Config the interface down and disable IP.
1041 PPPControl *pc = &pppControl[pd];
1044 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1046 PPPDEBUG((LOG_WARNING, "sifdown[%d]: bad parms\n", pd));
1049 netif_remove(&pc->netif);
1050 PPPDEBUG((LOG_DEBUG, "sifdown: unit %d: linkStatusCB=%lx errCode=%d\n", pd, pc->linkStatusCB, pc->errCode));
1051 if(pc->linkStatusCB)
1052 pc->linkStatusCB(pc->linkStatusCtx, PPPERR_CONNECT, NULL);
1058 * sifaddr - Config the interface IP addresses and netmask.
1061 int pd, /* Interface unit ??? */
1062 u32_t o, /* Our IP address ??? */
1063 u32_t h, /* His IP address ??? */
1064 u32_t m, /* IP subnet mask ??? */
1065 u32_t ns1, /* Primary DNS */
1066 u32_t ns2 /* Secondary DNS */
1069 PPPControl *pc = &pppControl[pd];
1072 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1074 PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parms\n", pd));
1076 memcpy(&pc->addrs.our_ipaddr, &o, sizeof(o));
1077 memcpy(&pc->addrs.his_ipaddr, &h, sizeof(h));
1078 memcpy(&pc->addrs.netmask, &m, sizeof(m));
1079 memcpy(&pc->addrs.dns1, &ns1, sizeof(ns1));
1080 memcpy(&pc->addrs.dns2, &ns2, sizeof(ns2));
1086 * cifaddr - Clear the interface IP addresses, and delete routes
1087 * through the interface if possible.
1090 int pd, /* Interface unit ??? */
1091 u32_t o, /* Our IP address ??? */
1092 u32_t h /* IP broadcast address ??? */
1095 PPPControl *pc = &pppControl[pd];
1100 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1102 PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parms\n", pd));
1104 IP4_ADDR(&pc->addrs.our_ipaddr, 0,0,0,0);
1105 IP4_ADDR(&pc->addrs.his_ipaddr, 0,0,0,0);
1106 IP4_ADDR(&pc->addrs.netmask, 255,255,255,0);
1107 IP4_ADDR(&pc->addrs.dns1, 0,0,0,0);
1108 IP4_ADDR(&pc->addrs.dns2, 0,0,0,0);
1114 * sifdefaultroute - assign a default route through the address given.
1116 int sifdefaultroute(int pd, u32_t l, u32_t g)
1118 PPPControl *pc = &pppControl[pd];
1123 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1125 PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parms\n", pd));
1127 netif_set_default(&pc->netif);
1130 /* TODO: check how PPP handled the netMask, previously not set by ipSetDefault */
1136 * cifdefaultroute - delete a default route through the address given.
1138 int cifdefaultroute(int pd, u32_t l, u32_t g)
1140 PPPControl *pc = &pppControl[pd];
1145 if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
1147 PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parms\n", pd));
1149 netif_set_default(NULL);
1156 pppMainWakeup(int pd)
1158 PPPDEBUG((LOG_DEBUG, "pppMainWakeup: unit %d\n", pd));
1159 sio_read_abort(pppControl[pd].fd);
1162 /* these callbacks are necessary because lcp_* functions
1163 must be called in the same context as pppInput(),
1164 namely the tcpip_thread(), essentially because
1165 they manipulate timeouts which are thread-private
1169 pppStartCB(void *arg)
1173 PPPDEBUG((LOG_DEBUG, "pppStartCB: unit %d\n", pd));
1175 lcp_open(pd); /* Start protocol */
1179 pppStopCB(void *arg)
1183 PPPDEBUG((LOG_DEBUG, "pppStopCB: unit %d\n", pd));
1184 lcp_close(pd, "User request");
1192 PPPDEBUG((LOG_DEBUG, "pppHupCB: unit %d\n", pd));
1194 link_terminated(pd);
1196 /**********************************/
1197 /*** LOCAL FUNCTION DEFINITIONS ***/
1198 /**********************************/
1199 /* The main PPP process function. This implements the state machine according
1200 * to section 4 of RFC 1661: The Point-To-Point Protocol. */
1201 static void pppMain(void *arg)
1207 pc = &pppControl[pd];
1209 p = pbuf_alloc(PBUF_RAW, PPP_MRU+PPP_HDRLEN, PBUF_RAM);
1211 LWIP_ASSERT("p != NULL", p);
1212 pc->errCode = PPPERR_ALLOC;
1217 * Start the connection and handle incoming events (packet or timeout).
1219 PPPDEBUG((LOG_INFO, "pppMain: unit %d: Connecting\n", pd));
1220 tcpip_callback(pppStartCB, arg);
1221 while (lcp_phase[pd] != PHASE_DEAD) {
1222 if (pc->kill_link) {
1223 PPPDEBUG((LOG_DEBUG, "pppMainWakeup: unit %d kill_link -> pppStopCB\n", pd));
1224 pc->errCode = PPPERR_USER;
1225 /* This will leave us at PHASE_DEAD. */
1226 tcpip_callback(pppStopCB, arg);
1229 else if (pc->sig_hup) {
1230 PPPDEBUG((LOG_DEBUG, "pppMainWakeup: unit %d sig_hup -> pppHupCB\n", pd));
1232 tcpip_callback(pppHupCB, arg);
1234 int c = sio_read(pc->fd, p->payload, p->len);
1236 pppInProc(pd, p->payload, c);
1238 PPPDEBUG((LOG_DEBUG, "pppMainWakeup: unit %d sio_read len=%d returned %d\n", pd, p->len, c));
1239 sys_msleep(1); /* give other tasks a chance to run */
1243 PPPDEBUG((LOG_INFO, "pppMain: unit %d: PHASE_DEAD\n", pd));
1247 PPPDEBUG((LOG_DEBUG, "pppMain: unit %d: linkStatusCB=%lx errCode=%d\n", pd, pc->linkStatusCB, pc->errCode));
1248 if(pc->linkStatusCB)
1249 pc->linkStatusCB(pc->linkStatusCtx, pc->errCode ? pc->errCode : PPPERR_PROTOCOL, NULL);
1254 static struct pbuf *pppSingleBuf(struct pbuf *p)
1259 if(p->tot_len == p->len)
1262 q = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);
1265 "pppSingleBuf: unable to alloc new buf (%d)\n", p->tot_len));
1266 return p; /* live dangerously */
1269 for(b = p, pl = q->payload; b != NULL; b = b->next) {
1270 memcpy(pl, b->payload, b->len);
1279 struct pppInputHeader {
1285 * Pass the processed input packet to the appropriate handler.
1286 * This function and all handlers run in the context of the tcpip_thread
1288 static void pppInput(void *arg)
1290 struct pbuf *nb = (struct pbuf *)arg;
1294 pd = ((struct pppInputHeader *)nb->payload)->unit;
1295 protocol = ((struct pppInputHeader *)nb->payload)->proto;
1297 pbuf_header(nb, -(int)sizeof(struct pppInputHeader));
1300 lwip_stats.link.recv++;
1301 #endif /* LINK_STATS */
1304 * Toss all non-LCP packets unless LCP is OPEN.
1305 * Until we get past the authentication phase, toss all packets
1306 * except LCP, LQR and authentication packets.
1308 if((lcp_phase[pd] <= PHASE_AUTHENTICATE) && (protocol != PPP_LCP)) {
1309 if(!((protocol == PPP_LQR) || (protocol == PPP_PAP) || (protocol == PPP_CHAP)) ||
1310 (lcp_phase[pd] != PHASE_AUTHENTICATE)) {
1311 PPPDEBUG((LOG_INFO, "pppInput: discarding proto 0x%04X in phase %d\n", protocol, lcp_phase[pd]));
1317 case PPP_VJC_COMP: /* VJ compressed TCP */
1319 PPPDEBUG((LOG_INFO, "pppInput[%d]: vj_comp in pbuf len=%d\n", pd, nb->len));
1321 * Clip off the VJ header and prepend the rebuilt TCP/IP header and
1322 * pass the result to IP.
1324 if (vj_uncompress_tcp(&nb, &pppControl[pd].vjComp) >= 0) {
1325 pppControl[pd].netif.input(nb, &pppControl[pd].netif);
1328 /* Something's wrong so drop it. */
1329 PPPDEBUG((LOG_WARNING, "pppInput[%d]: Dropping VJ compressed\n", pd));
1331 /* No handler for this protocol so drop the packet. */
1332 PPPDEBUG((LOG_INFO, "pppInput[%d]: drop VJ Comp in %d:%s\n", pd, nb->len, nb->payload));
1333 #endif /* VJ_SUPPORT > 0 */
1335 case PPP_VJC_UNCOMP: /* VJ uncompressed TCP */
1337 PPPDEBUG((LOG_INFO, "pppInput[%d]: vj_un in pbuf len=%d\n", pd, nb->len));
1339 * Process the TCP/IP header for VJ header compression and then pass
1342 if (vj_uncompress_uncomp(nb, &pppControl[pd].vjComp) >= 0) {
1343 pppControl[pd].netif.input(nb, &pppControl[pd].netif);
1346 /* Something's wrong so drop it. */
1347 PPPDEBUG((LOG_WARNING, "pppInput[%d]: Dropping VJ uncompressed\n", pd));
1349 /* No handler for this protocol so drop the packet. */
1351 "pppInput[%d]: drop VJ UnComp in %d:.*H\n",
1352 pd, nb->len, LWIP_MIN(nb->len * 2, 40), nb->payload));
1353 #endif /* VJ_SUPPORT > 0 */
1355 case PPP_IP: /* Internet Protocol */
1356 PPPDEBUG((LOG_INFO, "pppInput[%d]: ip in pbuf len=%d\n", pd, nb->len));
1357 pppControl[pd].netif.input(nb, &pppControl[pd].netif);
1361 struct protent *protp;
1365 * Upcall the proper protocol input routine.
1367 for (i = 0; (protp = ppp_protocols[i]) != NULL; ++i) {
1368 if (protp->protocol == protocol && protp->enabled_flag) {
1369 PPPDEBUG((LOG_INFO, "pppInput[%d]: %s len=%d\n", pd, protp->name, nb->len));
1370 nb = pppSingleBuf(nb);
1371 (*protp->input)(pd, nb->payload, nb->len);
1376 /* No handler for this protocol so reject the packet. */
1377 PPPDEBUG((LOG_INFO, "pppInput[%d]: rejecting unsupported proto 0x%04X len=%d\n", pd, protocol, nb->len));
1378 pbuf_header(nb, sizeof(protocol));
1379 #if BYTE_ORDER == LITTLE_ENDIAN
1380 protocol = htons(protocol);
1381 memcpy(nb->payload, &protocol, sizeof(protocol));
1383 lcp_sprotrej(pd, nb->payload, nb->len);
1390 lwip_stats.link.drop++;
1400 * Drop the input packet.
1402 static void pppDrop(PPPControl *pc)
1404 if (pc->inHead != NULL) {
1406 PPPDEBUG((LOG_INFO, "pppDrop: %d:%.*H\n", pc->inHead->len, min(60, pc->inHead->len * 2), pc->inHead->payload));
1408 PPPDEBUG((LOG_INFO, "pppDrop: pbuf len=%d\n", pc->inHead->len));
1409 if (pc->inTail && (pc->inTail != pc->inHead))
1410 pbuf_free(pc->inTail);
1411 pbuf_free(pc->inHead);
1416 vj_uncompress_err(&pc->vjComp);
1420 lwip_stats.link.drop++;
1421 #endif /* LINK_STATS */
1426 * Process a received octet string.
1428 static void pppInProc(int pd, u_char *s, int l)
1430 PPPControl *pc = &pppControl[pd];
1431 struct pbuf *nextNBuf;
1434 PPPDEBUG((LOG_DEBUG, "pppInProc[%d]: got %d bytes\n", pd, l));
1438 /* Handle special characters. */
1439 if (ESCAPE_P(pc->inACCM, curChar)) {
1440 /* Check for escape sequences. */
1441 /* XXX Note that this does not handle an escaped 0x5d character which
1442 * would appear as an escape character. Since this is an ASCII ']'
1443 * and there is no reason that I know of to escape it, I won't complicate
1444 * the code to handle this case. GLL */
1445 if (curChar == PPP_ESCAPE)
1447 /* Check for the flag character. */
1448 else if (curChar == PPP_FLAG) {
1449 /* If this is just an extra flag character, ignore it. */
1450 if (pc->inState <= PDADDRESS)
1452 /* If we haven't received the packet header, drop what has come in. */
1453 else if (pc->inState < PDDATA) {
1454 PPPDEBUG((LOG_WARNING,
1455 "pppInProc[%d]: Dropping incomplete packet %d\n",
1458 lwip_stats.link.lenerr++;
1462 /* If the fcs is invalid, drop the packet. */
1463 else if (pc->inFCS != PPP_GOODFCS) {
1465 "pppInProc[%d]: Dropping bad fcs 0x%04X proto=0x%04X\n",
1466 pd, pc->inFCS, pc->inProtocol));
1468 lwip_stats.link.chkerr++;
1472 /* Otherwise it's a good packet so pass it on. */
1475 /* Trim off the checksum. */
1476 if(pc->inTail->len >= 2) {
1477 pc->inTail->len -= 2;
1479 pc->inTail->tot_len = pc->inTail->len;
1480 if (pc->inTail != pc->inHead) {
1481 pbuf_cat(pc->inHead, pc->inTail);
1484 pc->inTail->tot_len = pc->inTail->len;
1485 if (pc->inTail != pc->inHead) {
1486 pbuf_cat(pc->inHead, pc->inTail);
1489 pbuf_realloc(pc->inHead, pc->inHead->tot_len - 2);
1492 /* Dispatch the packet thereby consuming it. */
1493 if(tcpip_callback(pppInput, pc->inHead) != ERR_OK) {
1495 "pppInProc[%d]: tcpip_callback() failed, dropping packet\n", pd));
1496 pbuf_free(pc->inHead);
1498 lwip_stats.link.drop++;
1505 /* Prepare for a new packet. */
1506 pc->inFCS = PPP_INITFCS;
1507 pc->inState = PDADDRESS;
1510 /* Other characters are usually control characters that may have
1511 * been inserted by the physical layer so here we just drop them. */
1513 PPPDEBUG((LOG_WARNING,
1514 "pppInProc[%d]: Dropping ACCM char <%d>\n", pd, curChar));
1517 /* Process other characters. */
1519 /* Unencode escaped characters. */
1520 if (pc->inEscaped) {
1522 curChar ^= PPP_TRANS;
1525 /* Process character relative to current state. */
1526 switch(pc->inState) {
1527 case PDIDLE: /* Idle state - waiting. */
1528 /* Drop the character if it's not 0xff
1529 * we would have processed a flag character above. */
1530 if (curChar != PPP_ALLSTATIONS) {
1535 case PDSTART: /* Process start flag. */
1536 /* Prepare for a new packet. */
1537 pc->inFCS = PPP_INITFCS;
1540 case PDADDRESS: /* Process address field. */
1541 if (curChar == PPP_ALLSTATIONS) {
1542 pc->inState = PDCONTROL;
1545 /* Else assume compressed address and control fields so
1546 * fall through to get the protocol... */
1547 case PDCONTROL: /* Process control field. */
1548 /* If we don't get a valid control code, restart. */
1549 if (curChar == PPP_UI) {
1550 pc->inState = PDPROTOCOL1;
1555 PPPDEBUG((LOG_WARNING,
1556 "pppInProc[%d]: Invalid control <%d>\n", pd, curChar));
1557 pc->inState = PDSTART;
1560 case PDPROTOCOL1: /* Process protocol field 1. */
1561 /* If the lower bit is set, this is the end of the protocol
1564 pc->inProtocol = curChar;
1565 pc->inState = PDDATA;
1568 pc->inProtocol = (u_int)curChar << 8;
1569 pc->inState = PDPROTOCOL2;
1572 case PDPROTOCOL2: /* Process protocol field 2. */
1573 pc->inProtocol |= curChar;
1574 pc->inState = PDDATA;
1576 case PDDATA: /* Process data byte. */
1577 /* Make space to receive processed data. */
1578 if (pc->inTail == NULL || pc->inTail->len == PBUF_POOL_BUFSIZE) {
1580 pc->inTail->tot_len = pc->inTail->len;
1581 if (pc->inTail != pc->inHead) {
1582 pbuf_cat(pc->inHead, pc->inTail);
1585 /* If we haven't started a packet, we need a packet header. */
1586 nextNBuf = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
1587 if (nextNBuf == NULL) {
1588 /* No free buffers. Drop the input packet and let the
1589 * higher layers deal with it. Continue processing
1590 * the received pbuf chain in case a new packet starts. */
1591 PPPDEBUG((LOG_ERR, "pppInProc[%d]: NO FREE MBUFS!\n", pd));
1593 lwip_stats.link.memerr++;
1594 #endif /* LINK_STATS */
1596 pc->inState = PDSTART; /* Wait for flag sequence. */
1599 if (pc->inHead == NULL) {
1600 struct pppInputHeader *pih = nextNBuf->payload;
1603 pih->proto = pc->inProtocol;
1605 nextNBuf->len += sizeof(*pih);
1607 pc->inHead = nextNBuf;
1609 pc->inTail = nextNBuf;
1611 /* Load character into buffer. */
1612 ((u_char*)pc->inTail->payload)[pc->inTail->len++] = curChar;
1616 /* update the frame check sequence number. */
1617 pc->inFCS = PPP_FCS(pc->inFCS, curChar);
1623 #endif /* PPP_SUPPORT */