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