开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
ppp.c
资源名称：LWIP+GTM900+LPC2104.rar　[点击查看]
上传用户：yyhongfa
上传日期：2013-01-18
资源大小：267k
文件大小：48k
源码类别：

嵌入式/单片机编程

开发平台：

C/C++

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. *****************************************************************************/
  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.  */
  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 <string.h>
  83.  
  84. #include "ppp.h"
  85. #if PPP_SUPPORT > 0
  86. #include "randm.h"
  87. #include "fsm.h"
  88. #if PAP_SUPPORT > 0
  89. #include "pap.h"
  90. #endif
  91. #if CHAP_SUPPORT > 0
  92. #include "chap.h"
  93. #endif
  94. #include "ipcp.h"
  95. #include "lcp.h"
  96. #include "magic.h"
  97. #include "auth.h"
  98. #if VJ_SUPPORT > 0
  99. #include "vj.h"
  100. #endif
  102. #include "pppdebug.h"
  104. /*************************/
  105. /*** LOCAL DEFINITIONS ***/
  106. /*************************/
  108. /*
  109.  * The basic PPP frame.
  110.  */
  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
  116.  * completed. */
  117. typedef enum {
  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. */
  125. } PPPDevStates;
  127. #define ESCAPE_P(accm, c) ((accm)[(c) >> 3] & pppACCMMask[c & 0x07])
  129. /************************/
  130. /*** LOCAL DATA TYPES ***/
  131. /************************/
  132. /*
  133.  * PPP interface control block.
  134.  */
  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. */
  154. #if VJ_SUPPORT > 0
  155.     int  vjEnabled;                     /* Flag indicating VJ compression enabled. */
  156.     struct vjcompress vjComp;           /* Van Jabobsen compression header. */
  157. #endif
  159.     struct netif netif;
  161.     struct ppp_addrs addrs;
  163.     void (*linkStatusCB)(void *ctx, int errCode, void *arg);
  164.     void *linkStatusCtx;
  166. } PPPControl;
  169. /*
  170.  * Ioctl definitions.
  171.  */
  173. struct npioctl {
  174.     int     protocol;           /* PPP procotol, e.g. PPP_IP */
  175.     enum NPmode mode;
  176. };
  180. /***********************************/
  181. /*** LOCAL FUNCTION DECLARATIONS ***/
  182. /***********************************/
  183. static void pppMain(void *pd);
  184. static void pppDrop(PPPControl *pc);
  185. void pppInProc(int pd, u_char *s, int l);
  187. extern err_t ip_input(struct pbuf *p, struct netif *inp);
  189. /******************************/
  190. /*** PUBLIC DATA STRUCTURES ***/
  191. /******************************/
  192. u_long subnetMask;
  194. static PPPControl pppControl[NUM_PPP]; /* The PPP interface control blocks. */
  196. /*
  197.  * PPP Data Link Layer "protocol" table.
  198.  * One entry per supported protocol.
  199.  * The last entry must be NULL.
  200.  */
  201. struct protent *ppp_protocols[] = {
  202.     &lcp_protent,
  203. #if PAP_SUPPORT > 0
  204.     &pap_protent,
  205. #endif
  206. #if CHAP_SUPPORT > 0
  207.     &chap_protent,
  208. #endif
  209. #if CBCP_SUPPORT > 0
  210.     &cbcp_protent,
  211. #endif
  212.     &ipcp_protent,
  213. #if CCP_SUPPORT > 0
  214.     &ccp_protent,
  215. #endif
  216.     NULL
  217. };
  220. /*
  221.  * Buffers for outgoing packets.  This must be accessed only from the appropriate
  222.  * PPP task so that it doesn't need to be protected to avoid collisions.
  223.  */
  224. u_char outpacket_buf[NUM_PPP][PPP_MRU+PPP_HDRLEN];  
  227. /*****************************/
  228. /*** LOCAL DATA STRUCTURES ***/
  229. /*****************************/
  231. /*
  232.  * FCS lookup table as calculated by genfcstab.
  233.  */
  234. static const u_short fcstab[256] = {
  235.     0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  236.     0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  237.     0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  238.     0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  239.     0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  240.     0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  241.     0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  242.     0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  243.     0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  244.     0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  245.     0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  246.     0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  247.     0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  248.     0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  249.     0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  250.     0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  251.     0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  252.     0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  253.     0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  254.     0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  255.     0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  256.     0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  257.     0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  258.     0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  259.     0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  260.     0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  261.     0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  262.     0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  263.     0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  264.     0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  265.     0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  266.     0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  267. };
  269. /* PPP's Asynchronous-Control-Character-Map.  The mask array is used
  270.  * to select the specific bit for a character. */
  271. static u_char pppACCMMask[] = {
  272.     0x01,
  273.     0x02,
  274.     0x04,
  275.     0x08,
  276.     0x10,
  277.     0x20,
  278.     0x40,
  279.     0x80
  280. };
  283. /***********************************/
  284. /*** PUBLIC FUNCTION DEFINITIONS ***/
  285. /***********************************/
  286. /* Initialize the PPP subsystem. */
  288. struct ppp_settings ppp_settings;
  290. void pppInit(void)
  291. {
  292.     struct protent *protp;
  293.     int i, j;
  294.     
  295. memset(&ppp_settings, 0, sizeof(ppp_settings));
  296. ppp_settings.usepeerdns = 1;
  298. /*
  299. *skier:Parameters should be changed
  300. *modified by skier 2006.01.30
  301. *because we could supprot both  CHAP & PAP
  302. */
  303. //pppSetAuth(PPPAUTHTYPE_NONE, NULL, NULL);
  304. if (CHAP_SUPPORT && PAP_SUPPORT)
  305. {
  306.      pppSetAuth(PPPAUTHTYPE_ANY, USER, PASSWORD);
  307. }
  308. else
  309. {
  310.     pppSetAuth(PPPAUTHTYPE_NONE, NULL, NULL); 
  311. }
  312.      /*skier:end 2006.01.30*/
  313.  
  314. magicInit();
  316.     for (i = 0; i < NUM_PPP; i++) {
  317.         pppControl[i].openFlag = 0;
  319. subnetMask = htonl(0xffffff00);
  320.     
  321.         /*
  322.          * Initialize to the standard option set.
  323.          */
  324.         for (j = 0; (protp = ppp_protocols[j]) != NULL; ++j)
  325.             (*protp->init)(i);
  326.     }
  328. #if LINK_STATS
  329.     /* Clear the statistics. */
  330.     memset(&lwip_stats.link, 0, sizeof(lwip_stats.link));
  331. #endif
  332. }
  334. void pppSetAuth(enum pppAuthType authType, const char *user, const char *passwd)
  335. {
  336.     switch(authType) {
  337. case PPPAUTHTYPE_NONE:
  338. default:
  339. #ifdef LWIP_PPP_STRICT_PAP_REJECT
  340.     ppp_settings.refuse_pap = 1;
  341. #else
  342.     /* some providers request pap and accept an empty login/pw */
  343.     ppp_settings.refuse_pap = 0;
  344. #endif
  345.     ppp_settings.refuse_chap = 1;
  346.     break;
  347. case PPPAUTHTYPE_ANY:
  348. /* Warning: Using PPPAUTHTYPE_ANY might have security consequences.
  349.  * RFC 1994 says:
  350.  *
  351.  * In practice, within or associated with each PPP server, there is a
  352.  * database which associates "user" names with authentication
  353.  * information ("secrets").  It is not anticipated that a particular
  354.  * named user would be authenticated by multiple methods.  This would
  355.  * make the user vulnerable to attacks which negotiate the least secure
  356.  * method from among a set (such as PAP rather than CHAP).  If the same
  357.  * secret was used, PAP would reveal the secret to be used later with
  358.  * CHAP.
  359.  *
  360.  * Instead, for each user name there should be an indication of exactly
  361.  * one method used to authenticate that user name.  If a user needs to
  362.  * make use of different authentication methods under different
  363.  * circumstances, then distinct user names SHOULD be employed, each of
  364.  * which identifies exactly one authentication method.
  365.  *
  366.  */
  367.     ppp_settings.refuse_pap = 0;
  368.     ppp_settings.refuse_chap = 0;
  369.     break;
  370. case PPPAUTHTYPE_PAP:
  371.     ppp_settings.refuse_pap = 0;
  372.     ppp_settings.refuse_chap = 1;
  373.     break;
  374. case PPPAUTHTYPE_CHAP:
  375.     ppp_settings.refuse_pap = 1;
  376.     ppp_settings.refuse_chap = 0;
  377.     break;
  378.     }
  380.     if(user) {
  381. strncpy(ppp_settings.user, user, sizeof(ppp_settings.user)-1);
  382. ppp_settings.user[sizeof(ppp_settings.user)-1] = '';
  383.     } else
  384. ppp_settings.user[0] = '';
  386.     if(passwd) {
  387. strncpy(ppp_settings.passwd, passwd, sizeof(ppp_settings.passwd)-1);
  388. ppp_settings.passwd[sizeof(ppp_settings.passwd)-1] = '';
  389.     } else
  390. ppp_settings.passwd[0] = '';
  391. }
  393. /* Open a new PPP connection using the given I/O device.
  394.  * This initializes the PPP control block but does not
  395.  * attempt to negotiate the LCP session.  If this port
  396.  * connects to a modem, the modem connection must be
  397.  * established before calling this.
  398.  * Return a new PPP connection descriptor on success or
  399.  * an error code (negative) on failure. */
  400. int pppOpen(sio_fd_t fd, void (*linkStatusCB)(void *ctx, int errCode, void *arg), void *linkStatusCtx)
  401. {
  402.     PPPControl *pc;
  403.     int pd;
  405.     /* Find a free PPP session descriptor. Critical region? */
  406.     for (pd = 0; pd < NUM_PPP && pppControl[pd].openFlag != 0; pd++);
  407.     if (pd >= NUM_PPP)
  408.         pd = PPPERR_OPEN;
  409.     else
  410.         pppControl[pd].openFlag = !0;
  412.     /* Launch a deamon thread. */
  413.     if (pd >= 0) {
  415.         pppControl[pd].openFlag = 1;
  417.         lcp_init(pd);
  418.         pc = &pppControl[pd];
  419.         pc->fd = fd;
  420.         pc->kill_link = 0;
  421.         pc->sig_hup = 0;
  422.         pc->if_up = 0;
  423.         pc->errCode = 0;
  424.         pc->inState = PDIDLE;
  425.         pc->inHead = NULL;
  426.         pc->inTail = NULL;
  427.         pc->inEscaped = 0;
  428.         pc->lastXMit = 0;
  430. #if VJ_SUPPORT > 0
  431.         pc->vjEnabled = 0;
  432.         vj_compress_init(&pc->vjComp);
  433. #endif
  435.         /* 
  436.          * Default the in and out accm so that escape and flag characters
  437.          * are always escaped. 
  438.          */
  439.         memset(pc->inACCM, 0, sizeof(ext_accm));
  440.         pc->inACCM[15] = 0x60;
  441.         memset(pc->outACCM, 0, sizeof(ext_accm));
  442.         pc->outACCM[15] = 0x60;
  444. pc->linkStatusCB = linkStatusCB;
  445. pc->linkStatusCtx = linkStatusCtx;
  447.         /*Modified by zhouzhigang 2005.01.16 for single thread, start LCP*/
  448. //sys_thread_new(pppMain, (void*)pd, PPP_THREAD_PRIO);
  449.         pppStartCB((void*)pd);
  452. /*Delete by zhouzhigang 2005.01.16 for not useful*/
  453. /*if(!linkStatusCB) {
  454. while(pd >= 0 && !pc->if_up) {
  455. sys_msleep(500);
  456. if (lcp_phase[pd] == PHASE_DEAD) {
  457. pppClose(pd);
  458. if (pc->errCode)
  459. pd = pc->errCode;
  460. else
  461. pd = PPPERR_CONNECT;
  462. }
  463. }
  464. }*/
  465.     }
  466.     return pd;
  467. }
  469. /* Close a PPP connection and release the descriptor. 
  470.  * Any outstanding packets in the queues are dropped.
  471.  * Return 0 on success, an error code on failure. */
  472. int pppClose(int pd)
  473. {
  474.     PPPControl *pc = &pppControl[pd];
  475.     int st = 0;
  477.     /* Disconnect */
  478.     pc->kill_link = !0;
  479.     pppMainWakeup(pd);
  480.     
  481.     if(!pc->linkStatusCB) {
  482.     while(st >= 0 && lcp_phase[pd] != PHASE_DEAD) {
  483.    // sys_msleep(500);
  484.     break;
  485.     }
  486.     }
  487.     return st;
  488. }
  490. /* This function is called when carrier is lost on the PPP channel. */
  491. void pppSigHUP(int pd)
  492. {
  493.     PPPControl *pc = &pppControl[pd];
  495.     pc->sig_hup = 1;
  496.     pppMainWakeup(pd);
  497. }
  499. static void nPut(PPPControl *pc, struct pbuf *nb)
  500. {
  501. struct pbuf *b;
  502. int c;
  503.  
  504.        DEBUG_EVENT(" Send some data to Modem:");
  505.    
  506. for(b = nb; b != NULL; b = b->next) {
  507.     if((c = sio_write(pc->fd, b->payload, b->len)) != b->len) {
  508. PPPDEBUG((LOG_WARNING,
  509.     "PPP nPut: incomplete sio_write(%d,, %u) = %dn", pc->fd, b->len, c));
  510. #if LINK_STATS
  511. lwip_stats.link.err++;
  512. #endif /* LINK_STATS */
  513. pc->lastXMit = 0; /* prepend PPP_FLAG to next packet */
  514. break;
  515.     }
  516. }
  517. pbuf_free(nb);
  519. #if LINK_STATS
  520. lwip_stats.link.xmit++;
  521. #endif /* LINK_STATS */
  522. }
  524. /* 
  525.  * pppAppend - append given character to end of given pbuf.  If outACCM
  526.  * is not NULL and the character needs to be escaped, do so.
  527.  * If pbuf is full, append another.
  528.  * Return the current pbuf.
  529.  */
  530. static struct pbuf *pppAppend(u_char c, struct pbuf *nb, ext_accm *outACCM)
  531. {
  532.     struct pbuf *tb = nb;
  533.     
  534.     /* Make sure there is room for the character and an escape code.
  535.      * Sure we don't quite fill the buffer if the character doesn't
  536.      * get escaped but is one character worth complicating this? */
  537.     /* Note: We assume no packet header. */
  538.     if (nb && (PBUF_POOL_BUFSIZE - nb->len) < 2) {
  539. tb = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
  540. if (tb) {
  541.     nb->next = tb;
  542.         }
  543. #if LINK_STATS
  544. else {
  545.     lwip_stats.link.memerr++;
  546. }
  547. #endif /* LINK_STATS */
  548. nb = tb;
  549.     }
  550.     if (nb) {
  551. if (outACCM && ESCAPE_P(*outACCM, c)) {
  552.             *((u_char*)nb->payload + nb->len++) = PPP_ESCAPE;
  553.             *((u_char*)nb->payload + nb->len++) = c ^ PPP_TRANS;
  554.         }
  555.         else
  556.             *((u_char*)nb->payload + nb->len++) = c;
  557.     }
  558.         
  559.     return tb;
  560. }
  562. /* Send a packet on the given connection. */
  563. static err_t pppifOutput(struct netif *netif, struct pbuf *pb, struct ip_addr *ipaddr)
  564. {
  565.     int pd = (int)netif->state;
  566.     u_short protocol = PPP_IP;
  567.     PPPControl *pc = &pppControl[pd];
  568.     u_int fcsOut = PPP_INITFCS;
  569.     struct pbuf *headMB = NULL, *tailMB = NULL, *p;
  570.     u_char c;
  572.     (void)ipaddr;
  574.     /* Validate parameters. */
  575.     /* We let any protocol value go through - it can't hurt us
  576.      * and the peer will just drop it if it's not accepting it. */
  577. if (pd < 0 || pd >= NUM_PPP || !pc->openFlag || !pb) {
  578.         PPPDEBUG((LOG_WARNING, "pppifOutput[%d]: bad parms prot=%d pb=%pn",
  579.                     pd, protocol, pb));
  580. #if LINK_STATS
  581. lwip_stats.link.opterr++;
  582. lwip_stats.link.drop++;
  583. #endif
  584. return ERR_ARG;
  585. }
  587.     /* Check that the link is up. */
  588. if (lcp_phase[pd] == PHASE_DEAD) {
  589.         PPPDEBUG((LOG_ERR, "pppifOutput[%d]: link not upn", pd));
  590. #if LINK_STATS
  591. lwip_stats.link.rterr++;
  592. lwip_stats.link.drop++;
  593. #endif
  594. return ERR_RTE;
  595. }
  597.     /* Grab an output buffer. */
  598. headMB = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
  599.     if (headMB == NULL) {
  600.         PPPDEBUG((LOG_WARNING, "pppifOutput[%d]: first alloc failn", pd));
  601. #if LINK_STATS
  602. lwip_stats.link.memerr++;
  603. lwip_stats.link.drop++;
  604. #endif /* LINK_STATS */
  605.         return ERR_MEM;
  606.     }
  607.         
  608. #if VJ_SUPPORT > 0
  609.     /* 
  610.      * Attempt Van Jacobson header compression if VJ is configured and
  611.      * this is an IP packet. 
  612.      */
  613.     if (protocol == PPP_IP && pc->vjEnabled) {
  614.         switch (vj_compress_tcp(&pc->vjComp, pb)) {
  615.         case TYPE_IP:
  616.             /* No change...
  617.             protocol = PPP_IP_PROTOCOL;
  618.              */
  619.             break;
  620.         case TYPE_COMPRESSED_TCP:
  621.             protocol = PPP_VJC_COMP;
  622.             break;
  623.         case TYPE_UNCOMPRESSED_TCP:
  624.             protocol = PPP_VJC_UNCOMP;
  625.             break;
  626.         default:
  627.             PPPDEBUG((LOG_WARNING, "pppifOutput[%d]: bad IP packetn", pd));
  628. #if LINK_STATS
  629. lwip_stats.link.proterr++;
  630. lwip_stats.link.drop++;
  631. #endif
  632.          pbuf_free(headMB);
  633.             return ERR_VAL;
  634.         }
  635.     }
  636. #endif
  637.         
  638.     tailMB = headMB;
  639.         
  640.     /* Build the PPP header. */
  641.     if ((sys_jiffies() - pc->lastXMit) >= PPP_MAXIDLEFLAG)
  642.         tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
  643.     pc->lastXMit = sys_jiffies();
  644.     if (!pc->accomp) {
  645.         fcsOut = PPP_FCS(fcsOut, PPP_ALLSTATIONS);
  646.         tailMB = pppAppend(PPP_ALLSTATIONS, tailMB, &pc->outACCM);
  647.         fcsOut = PPP_FCS(fcsOut, PPP_UI);
  648.         tailMB = pppAppend(PPP_UI, tailMB, &pc->outACCM);
  649.     }
  650.     if (!pc->pcomp || protocol > 0xFF) {
  651.         c = (protocol >> 8) & 0xFF;
  652.         fcsOut = PPP_FCS(fcsOut, c);
  653.         tailMB = pppAppend(c, tailMB, &pc->outACCM);
  654.     }
  655.     c = protocol & 0xFF;
  656.     fcsOut = PPP_FCS(fcsOut, c);
  657.     tailMB = pppAppend(c, tailMB, &pc->outACCM);
  658.     
  659.     /* Load packet. */
  660. for(p = pb; p; p = p->next) {
  661.      int n;
  662.      u_char *sPtr;
  664.         sPtr = (u_char*)p->payload;
  665.         n = p->len;
  666.         while (n-- > 0) {
  667.             c = *sPtr++;
  668.             
  669.             /* Update FCS before checking for special characters. */
  670.             fcsOut = PPP_FCS(fcsOut, c);
  671.             
  672.             /* Copy to output buffer escaping special characters. */
  673.             tailMB = pppAppend(c, tailMB, &pc->outACCM);
  674.         }
  675.     }
  677.     /* Add FCS and trailing flag. */
  678.     c = ~fcsOut & 0xFF;
  679.     tailMB = pppAppend(c, tailMB, &pc->outACCM);
  680.     c = (~fcsOut >> 8) & 0xFF;
  681.     tailMB = pppAppend(c, tailMB, &pc->outACCM);
  682.     tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
  683.         
  684.     /* If we failed to complete the packet, throw it away. */
  685.     if (!tailMB) {
  686.         PPPDEBUG((LOG_WARNING,
  687.                     "pppifOutput[%d]: Alloc err - dropping proto=%dn", 
  688.                     pd, protocol));
  689.         pbuf_free(headMB);
  690. #if LINK_STATS
  691. lwip_stats.link.memerr++;
  692. lwip_stats.link.drop++;
  693. #endif
  694.         return ERR_MEM;
  695.     }
  697. /* Send it. */
  698.     PPPDEBUG((LOG_INFO, "pppifOutput[%d]: proto=0x%04Xn", pd, protocol));
  700.     nPut(pc, headMB);
  702.     return ERR_OK;
  703. }
  705. /* Get and set parameters for the given connection.
  706.  * Return 0 on success, an error code on failure. */
  707. int  pppIOCtl(int pd, int cmd, void *arg)
  708. {
  709.     PPPControl *pc = &pppControl[pd];
  710.     int st = 0;
  712.     if (pd < 0 || pd >= NUM_PPP)
  713.         st = PPPERR_PARAM;
  714.     else {
  715.         switch(cmd) {
  716.         case PPPCTLG_UPSTATUS:      /* Get the PPP up status. */
  717.             if (arg) 
  718.                 *(int *)arg = (int)(pc->if_up);
  719.             else
  720.                 st = PPPERR_PARAM;
  721.             break;
  722.         case PPPCTLS_ERRCODE:       /* Set the PPP error code. */
  723.             if (arg) 
  724.                 pc->errCode = *(int *)arg;
  725.             else
  726.                 st = PPPERR_PARAM;
  727.             break;
  728.         case PPPCTLG_ERRCODE:       /* Get the PPP error code. */
  729.             if (arg) 
  730.                 *(int *)arg = (int)(pc->errCode);
  731.             else
  732.                 st = PPPERR_PARAM;
  733.             break;
  734.         case PPPCTLG_FD:
  735.             if (arg) 
  736.                 *(sio_fd_t *)arg = pc->fd;
  737.             else
  738.                 st = PPPERR_PARAM;
  739.             break;
  740.         default:
  741.             st = PPPERR_PARAM;
  742.             break;
  743.         }
  744.     }
  745.     
  746.     return st;
  747. }
  749. /*
  750.  * Return the Maximum Transmission Unit for the given PPP connection.
  751.  */
  752. u_int pppMTU(int pd)
  753. {
  754.     PPPControl *pc = &pppControl[pd];
  755.     u_int st;
  756.     
  757.     /* Validate parameters. */
  758.     if (pd < 0 || pd >= NUM_PPP || !pc->openFlag)
  759.         st = 0;
  760.     else
  761.         st = pc->mtu;
  762.         
  763.     return st;
  764. }
  766. /*
  767.  * Write n characters to a ppp link.
  768.  *  RETURN: >= 0 Number of characters written
  769.  *           -1 Failed to write to device
  770.  */
  771. int pppWrite(int pd, const u_char *s, int n)
  772. {
  773.     PPPControl *pc = &pppControl[pd];
  774.     u_char c;
  775.     u_int fcsOut = PPP_INITFCS;
  776.     struct pbuf *headMB = NULL, *tailMB;
  777. headMB = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
  778.     if (headMB == NULL) {
  779. #if LINK_STATS
  780. lwip_stats.link.memerr++;
  781. lwip_stats.link.proterr++;
  782. #endif /* LINK_STATS */
  783. return PPPERR_ALLOC;
  784.     }
  786.     tailMB = headMB;
  787.         
  788.     /* If the link has been idle, we'll send a fresh flag character to
  789.      * flush any noise. */
  790.     if ((sys_jiffies() - pc->lastXMit) >= PPP_MAXIDLEFLAG)
  791.         tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
  792.     pc->lastXMit = sys_jiffies();
  793.      
  794.     /* Load output buffer. */
  795.     while (n-- > 0) {
  796.         c = *s++;
  797.         
  798.         /* Update FCS before checking for special characters. */
  799.         fcsOut = PPP_FCS(fcsOut, c);
  800.         
  801.         /* Copy to output buffer escaping special characters. */
  802.         tailMB = pppAppend(c, tailMB, &pc->outACCM);
  803.     }
  804.     
  805.     /* Add FCS and trailing flag. */
  806.     c = ~fcsOut & 0xFF;
  807.     tailMB = pppAppend(c, tailMB, &pc->outACCM);
  808.     c = (~fcsOut >> 8) & 0xFF;
  809.     tailMB = pppAppend(c, tailMB, &pc->outACCM);
  810.     tailMB = pppAppend(PPP_FLAG, tailMB, NULL);
  811.         
  812.     /* If we failed to complete the packet, throw it away.
  813.      * Otherwise send it. */
  814.     if (!tailMB) {
  815. PPPDEBUG((LOG_WARNING,
  816.                 "pppWrite[%d]: Alloc err - dropping pbuf len=%dn", pd, headMB->len));
  817. /*                "pppWrite[%d]: Alloc err - dropping %d:%.*H", pd, headMB->len, LWIP_MIN(headMB->len * 2, 40), headMB->payload)); */
  818. pbuf_free(headMB);
  819. #if LINK_STATS
  820. lwip_stats.link.memerr++;
  821. lwip_stats.link.proterr++;
  822. #endif /* LINK_STATS */
  823. return PPPERR_ALLOC;
  824. }
  826.     PPPDEBUG((LOG_INFO, "pppWrite[%d]: len=%dn", pd, headMB->len));
  827. /*     "pppWrite[%d]: %d:%.*H", pd, headMB->len, LWIP_MIN(headMB->len * 2, 40), headMB->payload)); */
  828.     nPut(pc, headMB);
  830.     return PPPERR_NONE;
  831. }
  833. /*
  834.  * ppp_send_config - configure the transmit characteristics of
  835.  * the ppp interface.
  836.  */
  837. void ppp_send_config(
  838.     int unit, 
  839.     int mtu,
  840.     u32_t asyncmap,
  841.     int pcomp, 
  842.     int accomp
  843. )
  844. {
  845.     PPPControl *pc = &pppControl[unit];
  846.     int i;
  847.     
  848.     pc->mtu = mtu;
  849.     pc->pcomp = pcomp;
  850.     pc->accomp = accomp;
  851.     
  852.     /* Load the ACCM bits for the 32 control codes. */
  853.     for (i = 0; i < 32/8; i++)
  854.         pc->outACCM[i] = (u_char)((asyncmap >> (8 * i)) & 0xFF);
  855.     PPPDEBUG((LOG_INFO, "ppp_send_config[%d]: outACCM=%X %X %X %Xn",
  856.                 unit,
  857.                 pc->outACCM[0], pc->outACCM[1], pc->outACCM[2], pc->outACCM[3]));
  858. }
  861. /*
  862.  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
  863.  */
  864. void ppp_set_xaccm(int unit, ext_accm *accm)
  865. {
  866.     memcpy(pppControl[unit].outACCM, accm, sizeof(ext_accm));
  867.     PPPDEBUG((LOG_INFO, "ppp_set_xaccm[%d]: outACCM=%X %X %X %Xn",
  868.                 unit,
  869.                 pppControl[unit].outACCM[0],
  870.                 pppControl[unit].outACCM[1],
  871.                 pppControl[unit].outACCM[2],
  872.                 pppControl[unit].outACCM[3]));
  873. }
  876. /*
  877.  * ppp_recv_config - configure the receive-side characteristics of
  878.  * the ppp interface.
  879.  */
  880. void ppp_recv_config(
  881.     int unit, 
  882.     int mru,
  883.     u32_t asyncmap,
  884.     int pcomp, 
  885.     int accomp
  886. )
  887. {
  888.     PPPControl *pc = &pppControl[unit];
  889.     int i;
  890.     
  891. (void)accomp;
  892. (void)pcomp;
  893. (void)mru;
  895.     /* Load the ACCM bits for the 32 control codes. */
  896.     for (i = 0; i < 32 / 8; i++)
  897.         pc->inACCM[i] = (u_char)(asyncmap >> (i * 8));
  898.     PPPDEBUG((LOG_INFO, "ppp_recv_config[%d]: inACCM=%X %X %X %Xn",
  899.                 unit,
  900.                 pc->inACCM[0], pc->inACCM[1], pc->inACCM[2], pc->inACCM[3]));
  901. }
  903. #if 0
  904. /*
  905.  * ccp_test - ask kernel whether a given compression method
  906.  * is acceptable for use.  Returns 1 if the method and parameters
  907.  * are OK, 0 if the method is known but the parameters are not OK
  908.  * (e.g. code size should be reduced), or -1 if the method is unknown.
  909.  */
  910. int ccp_test(
  911.     int unit, 
  912.     int opt_len, 
  913.     int for_transmit,
  914.     u_char *opt_ptr
  915. )
  916. {
  917.     return 0;   /* XXX Currently no compression. */
  918. }
  920. /*
  921.  * ccp_flags_set - inform kernel about the current state of CCP.
  922.  */
  923. void ccp_flags_set(int unit, int isopen, int isup)
  924. {
  925.     /* XXX */
  926. }
  928. /*
  929.  * ccp_fatal_error - returns 1 if decompression was disabled as a
  930.  * result of an error detected after decompression of a packet,
  931.  * 0 otherwise.  This is necessary because of patent nonsense.
  932.  */
  933. int ccp_fatal_error(int unit)
  934. {
  935.     /* XXX */
  936.     return 0;
  937. }
  938. #endif
  940. /*
  941.  * get_idle_time - return how long the link has been idle.
  942.  */
  943. int get_idle_time(int u, struct ppp_idle *ip)
  944. {   
  945.     /* XXX */
  946. (void)u;
  947. (void)ip;
  949.     return 0;
  950. }
  953. /*
  954.  * Return user specified netmask, modified by any mask we might determine
  955.  * for address `addr' (in network byte order).
  956.  * Here we scan through the system's list of interfaces, looking for
  957.  * any non-point-to-point interfaces which might appear to be on the same
  958.  * network as `addr'.  If we find any, we OR in their netmask to the
  959.  * user-specified netmask.
  960.  */
  961. u32_t GetMask(u32_t addr)
  962. {
  963.     u32_t mask, nmask;
  964.     
  965.     htonl(addr);
  966.     if (IN_CLASSA(addr))    /* determine network mask for address class */
  967.         nmask = IN_CLASSA_NET;
  968.     else if (IN_CLASSB(addr))
  969.         nmask = IN_CLASSB_NET;
  970.     else
  971.         nmask = IN_CLASSC_NET;
  972.     /* class D nets are disallowed by bad_ip_adrs */
  973.     mask = subnetMask | htonl(nmask);
  974.     
  975.     /* XXX
  976.      * Scan through the system's network interfaces.
  977.      * Get each netmask and OR them into our mask.
  978.      */
  979.     
  980.     return mask;
  981. }
  983. /*
  984.  * sifvjcomp - config tcp header compression
  985.  */
  986. int sifvjcomp(
  987.     int pd, 
  988.     int vjcomp, 
  989.     int cidcomp, 
  990.     int maxcid
  991. )
  992. {
  993. #if VJ_SUPPORT > 0
  994.     PPPControl *pc = &pppControl[pd];
  995.     
  996.     pc->vjEnabled = vjcomp;
  997.     pc->vjComp.compressSlot = cidcomp;
  998.     pc->vjComp.maxSlotIndex = maxcid;
  999.     PPPDEBUG((LOG_INFO, "sifvjcomp: VJ compress enable=%d slot=%d max slot=%dn",
  1000.                 vjcomp, cidcomp, maxcid));
  1001. #endif
  1003.     return 0;
  1004. }
  1006. /*
  1007.  * pppifNetifInit - netif init callback
  1008.  */
  1009. static err_t pppifNetifInit(struct netif *netif)
  1010. {
  1011. netif->name[0] = 'p';
  1012. netif->name[1] = 'p';
  1013. netif->output = pppifOutput;
  1014. netif->mtu = pppMTU((int)netif->state);
  1015. return ERR_OK;
  1016. }
  1019. /*
  1020.  * sifup - Config the interface up and enable IP packets to pass.
  1021.  */
  1022. int sifup(int pd)
  1023. {
  1024.     PPPControl *pc = &pppControl[pd];
  1025.     int st = 1;
  1026.     
  1027.     if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
  1028.         st = 0;
  1029.         PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parmsn", pd));
  1030.     } else {
  1031. netif_remove(&pc->netif);
  1032. if (netif_add(&pc->netif, &pc->addrs.our_ipaddr, &pc->addrs.netmask, &pc->addrs.his_ipaddr, (void *)pd, pppifNetifInit, ip_input)) {
  1033.          pc->if_up = 1;
  1034.          pc->errCode = PPPERR_NONE;
  1036. /*
  1037. *new added by skier 2006.01.30
  1038. */
  1039. pc->netif.flags = NETIF_FLAG_UP;
  1040.                      /*skier:end 2006.01.30*/
  1041. PPPDEBUG((LOG_DEBUG, "sifup: unit %d: linkStatusCB=%lx errCode=%dn", pd, pc->linkStatusCB, pc->errCode));
  1042. if(pc->linkStatusCB)
  1043. pc->linkStatusCB(pc->linkStatusCtx, pc->errCode, &pc->addrs);
  1044. } else {
  1045.          st = 0;
  1046.          PPPDEBUG((LOG_ERR, "sifup[%d]: netif_add failedn", pd));
  1047. }
  1048.     }
  1050.     return st;
  1051. }
  1053. /*
  1054.  * sifnpmode - Set the mode for handling packets for a given NP.
  1055.  */
  1056. int sifnpmode(int u, int proto, enum NPmode mode)
  1057. {
  1058. (void)u;
  1059. (void)proto;
  1060. (void)mode;
  1061.     return 0;
  1062. }
  1064. /*
  1065.  * sifdown - Config the interface down and disable IP.
  1066.  */
  1067. int sifdown(int pd)
  1068. {
  1069.     PPPControl *pc = &pppControl[pd];
  1070.     int st = 1;
  1071.     
  1072.     if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
  1073.         st = 0;
  1074.         PPPDEBUG((LOG_WARNING, "sifdown[%d]: bad parmsn", pd));
  1075.     } else {
  1076.         pc->if_up = 0;
  1077. netif_remove(&pc->netif);
  1078. PPPDEBUG((LOG_DEBUG, "sifdown: unit %d: linkStatusCB=%lx errCode=%dn", pd, pc->linkStatusCB, pc->errCode));
  1079. if(pc->linkStatusCB)
  1080. pc->linkStatusCB(pc->linkStatusCtx, PPPERR_CONNECT, NULL);
  1081. }
  1082.     return st;
  1083. }
  1085. /*
  1086.  * sifaddr - Config the interface IP addresses and netmask.
  1087.  */
  1088. int sifaddr(
  1089.     int pd,             /* Interface unit ??? */
  1090.     u32_t o,        /* Our IP address ??? */
  1091.     u32_t h,        /* His IP address ??? */
  1092.     u32_t m,        /* IP subnet mask ??? */
  1093.     u32_t ns1,      /* Primary DNS */
  1094.     u32_t ns2       /* Secondary DNS */
  1095. )
  1096. {
  1097.     PPPControl *pc = &pppControl[pd];
  1098.     int st = 1;
  1099.     
  1100.     if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
  1101.         st = 0;
  1102.         PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parmsn", pd));
  1103.     } else {
  1104. memcpy(&pc->addrs.our_ipaddr, &o, sizeof(o));
  1105. memcpy(&pc->addrs.his_ipaddr, &h, sizeof(h));
  1106. memcpy(&pc->addrs.netmask, &m, sizeof(m));
  1107. memcpy(&pc->addrs.dns1, &ns1, sizeof(ns1));
  1108. memcpy(&pc->addrs.dns2, &ns2, sizeof(ns2));
  1109.     }
  1110.     return st;
  1111. }
  1113. /*
  1114.  * cifaddr - Clear the interface IP addresses, and delete routes
  1115.  * through the interface if possible.
  1116.  */
  1117. int cifaddr(
  1118.     int pd,         /* Interface unit ??? */
  1119.     u32_t o,    /* Our IP address ??? */
  1120.     u32_t h     /* IP broadcast address ??? */
  1121. )
  1122. {
  1123.     PPPControl *pc = &pppControl[pd];
  1124.     int st = 1;
  1125.     
  1126. (void)o;
  1127. (void)h;
  1128.     if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
  1129.         st = 0;
  1130.         PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parmsn", pd));
  1131.     } else {
  1132. IP4_ADDR(&pc->addrs.our_ipaddr, 0,0,0,0);
  1133. IP4_ADDR(&pc->addrs.his_ipaddr, 0,0,0,0);
  1134. IP4_ADDR(&pc->addrs.netmask, 255,255,255,0);
  1135. IP4_ADDR(&pc->addrs.dns1, 0,0,0,0);
  1136. IP4_ADDR(&pc->addrs.dns2, 0,0,0,0);
  1137.     }
  1138.     return st;
  1139. }
  1141. /*
  1142.  * sifdefaultroute - assign a default route through the address given.
  1143.  */
  1144. int sifdefaultroute(int pd, u32_t l, u32_t g)
  1145. {
  1146.     PPPControl *pc = &pppControl[pd];
  1147.     int st = 1;
  1148.     
  1149. (void)l;
  1150. (void)g;
  1151.     if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
  1152.         st = 0;
  1153.         PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parmsn", pd));
  1154.     } else {
  1155. netif_set_default(&pc->netif);
  1156.     }
  1158.     /* TODO: check how PPP handled the netMask, previously not set by ipSetDefault */
  1160.     return st;
  1161. }
  1163. /*
  1164.  * cifdefaultroute - delete a default route through the address given.
  1165.  */
  1166. int cifdefaultroute(int pd, u32_t l, u32_t g)
  1167. {
  1168.     PPPControl *pc = &pppControl[pd];
  1169.     int st = 1;
  1170.     
  1171. (void)l;
  1172. (void)g;
  1173.     if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
  1174.         st = 0;
  1175.         PPPDEBUG((LOG_WARNING, "sifup[%d]: bad parmsn", pd));
  1176.     } else {
  1177. netif_set_default(NULL);
  1178.     }
  1180.     return st;
  1181. }
  1183. void
  1184. pppMainWakeup(int pd)
  1185. {
  1186. PPPDEBUG((LOG_DEBUG, "pppMainWakeup: unit %dn", pd));
  1187. sio_read_abort(pppControl[pd].fd);
  1188. }
  1190. /* these callbacks are necessary because lcp_* functions
  1191.    must be called in the same context as pppInput(),
  1192.    namely the tcpip_thread(), essentially because
  1193.    they manipulate timeouts which are thread-private
  1194. */
  1196. static void
  1197. pppStartCB(void *arg)
  1198. {
  1199.     int pd = (int)arg;
  1201. PPPDEBUG((LOG_DEBUG, "pppStartCB: unit %dn", pd));
  1202.     lcp_lowerup(pd);
  1203.     lcp_open(pd);      /* Start protocol */
  1204. }
  1206. static void
  1207. pppStopCB(void *arg)
  1208. {
  1209.     int pd = (int)arg;
  1211. PPPDEBUG((LOG_DEBUG, "pppStopCB: unit %dn", pd));
  1212.     lcp_close(pd, "User request");
  1213. }
  1215. static void
  1216. pppHupCB(void *arg)
  1217. {
  1218.     int pd = (int)arg;
  1220. PPPDEBUG((LOG_DEBUG, "pppHupCB: unit %dn", pd));
  1221.     lcp_lowerdown(pd);
  1222.     link_terminated(pd);
  1223. }
  1224. /**********************************/
  1225. /*** LOCAL FUNCTION DEFINITIONS ***/
  1226. /**********************************/
  1227. /* The main PPP process function.  This implements the state machine according
  1228.  * to section 4 of RFC 1661: The Point-To-Point Protocol. */
  1229.  #if 0
  1230. static void pppMain(void *arg)
  1231. {
  1232.     int pd = (int)arg;
  1233.     struct pbuf *p;
  1234.     PPPControl* pc;
  1236.     pc = &pppControl[pd];
  1238.     p = pbuf_alloc(PBUF_RAW, PPP_MRU+PPP_HDRLEN, PBUF_RAM);
  1239.     if(!p) {
  1240. LWIP_ASSERT("p != NULL", p);
  1241. pc->errCode = PPPERR_ALLOC;
  1242. goto out;
  1243.     }
  1245.     /*
  1246.      * Start the connection and handle incoming events (packet or timeout).
  1247.      */
  1248. PPPDEBUG((LOG_INFO, "pppMain: unit %d: Connectingn", pd));
  1249.     tcpip_callback(pppStartCB, arg);
  1250.     while (lcp_phase[pd] != PHASE_DEAD) {
  1251.         if (pc->kill_link) {
  1252.      PPPDEBUG((LOG_DEBUG, "pppMainWakeup: unit %d kill_link -> pppStopCBn", pd));
  1253. pc->errCode = PPPERR_USER;
  1254. /* This will leave us at PHASE_DEAD. */
  1255.      tcpip_callback(pppStopCB, arg);
  1256. pc->kill_link = 0;
  1257.         }
  1258.         else if (pc->sig_hup) {
  1259.      PPPDEBUG((LOG_DEBUG, "pppMainWakeup: unit %d sig_hup -> pppHupCBn", pd));
  1260. pc->sig_hup = 0;
  1261.      tcpip_callback(pppHupCB, arg);
  1262.         } else {
  1263.         //delete by zhouzhigang 2006.01.20 for compile
  1264.            #if 0
  1265. int c = sio_read(pc->fd, p->payload, p->len);
  1266. if(c > 0) {
  1267. pppInProc(pd, p->payload, c);
  1268. } else {
  1269.  //   PPPDEBUG((LOG_DEBUG, "pppMainWakeup: unit %d sio_read len=%d returned %dn", pd, p->len, c));
  1270.     sys_msleep(1); /* give other tasks a chance to run */
  1271. }
  1272. #endif
  1273.         }
  1274.     }
  1275. PPPDEBUG((LOG_INFO, "pppMain: unit %d: PHASE_DEADn", pd));
  1276.     pbuf_free(p);
  1278. out:
  1279. PPPDEBUG((LOG_DEBUG, "pppMain: unit %d: linkStatusCB=%lx errCode=%dn", pd, pc->linkStatusCB, pc->errCode));
  1280.     if(pc->linkStatusCB)
  1281.     pc->linkStatusCB(pc->linkStatusCtx, pc->errCode ? pc->errCode : PPPERR_PROTOCOL, NULL);
  1283.     pc->openFlag = 0;
  1284. }
  1285. #endif
  1287. static struct pbuf *pppSingleBuf(struct pbuf *p)
  1288. {
  1289. struct pbuf *q, *b;
  1290. u_char *pl;
  1292. if(p->tot_len == p->len)
  1293. return p;
  1295. q = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);
  1296. if(!q) {
  1297. PPPDEBUG((LOG_ERR,
  1298.                         "pppSingleBuf: unable to alloc new buf (%d)n", p->tot_len));
  1299. return p; /* live dangerously */
  1300. }
  1302. for(b = p, pl = q->payload; b != NULL; b = b->next) {
  1303. memcpy(pl, b->payload, b->len);
  1304. pl += b->len;
  1305. }
  1307. pbuf_free(p);
  1309. return q;
  1310. }
  1312. struct pppInputHeader {
  1313. int unit;
  1314. u16_t proto;
  1315. };
  1317. /*
  1318.  * Pass the processed input packet to the appropriate handler.
  1319.  * This function and all handlers run in the context of the tcpip_thread
  1320.  */
  1321. static void pppInput(void *arg)
  1322. {
  1323. struct pbuf *nb = (struct pbuf *)arg;
  1324.     u16_t protocol;
  1325.     int pd;
  1327. pd = ((struct pppInputHeader *)nb->payload)->unit;
  1328. protocol = ((struct pppInputHeader *)nb->payload)->proto;
  1330.     pbuf_header(nb, -(int)sizeof(struct pppInputHeader));
  1332. #if LINK_STATS
  1333.     lwip_stats.link.recv++;
  1334. #endif /* LINK_STATS */
  1336.     /*
  1337.      * Toss all non-LCP packets unless LCP is OPEN.
  1338.      * Until we get past the authentication phase, toss all packets
  1339.      * except LCP, LQR and authentication packets.
  1340.      */
  1341.     if((lcp_phase[pd] <= PHASE_AUTHENTICATE) && (protocol != PPP_LCP)) {
  1342.     if(!((protocol == PPP_LQR) || (protocol == PPP_PAP) || (protocol == PPP_CHAP)) ||
  1343. (lcp_phase[pd] != PHASE_AUTHENTICATE)) {
  1344. PPPDEBUG((LOG_INFO, "pppInput: discarding proto 0x%04X in phase %dn", protocol, lcp_phase[pd]));
  1345. goto drop;
  1346.     }
  1347.     }
  1349.     switch(protocol) {
  1350.     case PPP_VJC_COMP:      /* VJ compressed TCP */
  1351. #if VJ_SUPPORT > 0
  1352.         PPPDEBUG((LOG_INFO, "pppInput[%d]: vj_comp in pbuf len=%dn", pd, nb->len));
  1353.         /*
  1354.          * Clip off the VJ header and prepend the rebuilt TCP/IP header and
  1355.          * pass the result to IP.
  1356.          */
  1357.         if (vj_uncompress_tcp(&nb, &pppControl[pd].vjComp) >= 0) {
  1358.             pppControl[pd].netif.input(nb, &pppControl[pd].netif);
  1359. return;
  1360.         }
  1361. /* Something's wrong so drop it. */
  1362. PPPDEBUG((LOG_WARNING, "pppInput[%d]: Dropping VJ compressedn", pd));
  1363. #else
  1364.         /* No handler for this protocol so drop the packet. */
  1365.         PPPDEBUG((LOG_INFO, "pppInput[%d]: drop VJ Comp in %d:%sn", pd, nb->len, nb->payload));
  1366. #endif /* VJ_SUPPORT > 0 */
  1367. break;
  1368.     case PPP_VJC_UNCOMP:    /* VJ uncompressed TCP */
  1369. #if VJ_SUPPORT > 0
  1370.         PPPDEBUG((LOG_INFO, "pppInput[%d]: vj_un in pbuf len=%dn", pd, nb->len));
  1371.         /*
  1372.          * Process the TCP/IP header for VJ header compression and then pass
  1373.          * the packet to IP.
  1374.          */
  1375.         if (vj_uncompress_uncomp(nb, &pppControl[pd].vjComp) >= 0) {
  1376.             pppControl[pd].netif.input(nb, &pppControl[pd].netif);
  1377. return;
  1378.         }
  1379. /* Something's wrong so drop it. */
  1380. PPPDEBUG((LOG_WARNING, "pppInput[%d]: Dropping VJ uncompressedn", pd));
  1381. #else
  1382.         /* No handler for this protocol so drop the packet. */
  1383.         PPPDEBUG((LOG_INFO,
  1384.                     "pppInput[%d]: drop VJ UnComp in %d:.*Hn", 
  1385.                     pd, nb->len, LWIP_MIN(nb->len * 2, 40), nb->payload));
  1386. #endif /* VJ_SUPPORT > 0 */
  1387. break;
  1388.     case PPP_IP:            /* Internet Protocol */
  1389.         PPPDEBUG((LOG_INFO, "pppInput[%d]: ip in pbuf len=%dn", pd, nb->len));
  1390.         pppControl[pd].netif.input(nb, &pppControl[pd].netif);
  1391. return;
  1392.     default:
  1393. {
  1394. struct protent *protp;
  1395. int i;
  1397. /*
  1398.  * Upcall the proper protocol input routine.
  1399.  */
  1400. for (i = 0; (protp = ppp_protocols[i]) != NULL; ++i) {
  1401. if (protp->protocol == protocol && protp->enabled_flag) {
  1402. PPPDEBUG((LOG_INFO, "pppInput[%d]: %s len=%dn", pd, protp->name, nb->len));
  1403. nb = pppSingleBuf(nb);
  1404. (*protp->input)(pd, nb->payload, nb->len);
  1405. goto out;
  1406. }
  1407. }
  1409. /* No handler for this protocol so reject the packet. */
  1410. PPPDEBUG((LOG_INFO, "pppInput[%d]: rejecting unsupported proto 0x%04X len=%dn", pd, protocol, nb->len));
  1411. pbuf_header(nb, sizeof(protocol));
  1412. #if BYTE_ORDER == LITTLE_ENDIAN
  1413. protocol = htons(protocol);
  1414. memcpy(nb->payload, &protocol, sizeof(protocol));
  1415. #endif
  1416. lcp_sprotrej(pd, nb->payload, nb->len);
  1417. }
  1418. break;
  1419.     }
  1421. drop:
  1422. #if LINK_STATS
  1423.     lwip_stats.link.drop++;
  1424. #endif
  1426. out:
  1427.     pbuf_free(nb);
  1428.     return;
  1429. }
  1432. /*
  1433.  * Drop the input packet.
  1434.  */
  1435. static void pppDrop(PPPControl *pc)
  1436. {
  1437.     if (pc->inHead != NULL) {
  1438. #if 0     
  1439.         PPPDEBUG((LOG_INFO, "pppDrop: %d:%.*Hn", pc->inHead->len, min(60, pc->inHead->len * 2), pc->inHead->payload));
  1440. #endif
  1441.         PPPDEBUG((LOG_INFO, "pppDrop: pbuf len=%dn", pc->inHead->len));
  1442. if (pc->inTail && (pc->inTail != pc->inHead))
  1443.     pbuf_free(pc->inTail);
  1444.         pbuf_free(pc->inHead);
  1445.         pc->inHead = NULL;
  1446.         pc->inTail = NULL;
  1447.     }
  1448. #if VJ_SUPPORT > 0
  1449.     vj_uncompress_err(&pc->vjComp);
  1450. #endif
  1452. #if LINK_STATS
  1453.     lwip_stats.link.drop++;
  1454. #endif /* LINK_STATS */
  1455. }
  1457. /*
  1458.  * Process a received octet string.
  1459.  */
  1460.  void pppInProc(int pd, u_char *s, int l)
  1461. {
  1462.     PPPControl *pc = &pppControl[pd];
  1463.     struct pbuf *nextNBuf;
  1464.     u_char curChar;
  1466.     PPPDEBUG((LOG_DEBUG, "pppInProc[%d]: got %d bytesn", pd, l));
  1467.     while (l-- > 0) {
  1468.         curChar = *s++;
  1469.         
  1470.         /* Handle special characters. */
  1471.         if (ESCAPE_P(pc->inACCM, curChar)) {
  1472.             /* Check for escape sequences. */
  1473.             /* XXX Note that this does not handle an escaped 0x5d character which
  1474.              * would appear as an escape character.  Since this is an ASCII ']'
  1475.              * and there is no reason that I know of to escape it, I won't complicate
  1476.              * the code to handle this case. GLL */
  1477.             if (curChar == PPP_ESCAPE)
  1478.                 pc->inEscaped = 1;
  1479.             /* Check for the flag character. */
  1480.             else if (curChar == PPP_FLAG) {
  1481.                 /* If this is just an extra flag character, ignore it. */
  1482.                 if (pc->inState <= PDADDRESS)
  1483.                     ;
  1484.                 /* If we haven't received the packet header, drop what has come in. */
  1485.                 else if (pc->inState < PDDATA) {
  1486.                     PPPDEBUG((LOG_WARNING,
  1487.                                 "pppInProc[%d]: Dropping incomplete packet %dn", 
  1488.                                 pd, pc->inState));
  1489. #if LINK_STATS
  1490. lwip_stats.link.lenerr++;
  1491. #endif
  1492.                     pppDrop(pc);
  1493.                 }
  1494.                 /* If the fcs is invalid, drop the packet. */
  1495.                 else if (pc->inFCS != PPP_GOODFCS) {
  1496.                     PPPDEBUG((LOG_INFO,
  1497.                                 "pppInProc[%d]: Dropping bad fcs 0x%04X proto=0x%04Xn", 
  1498.                                 pd, pc->inFCS, pc->inProtocol));
  1499. #if LINK_STATS
  1500. lwip_stats.link.chkerr++;
  1501. #endif
  1502.                     pppDrop(pc);
  1503.                 }
  1504.                 /* Otherwise it's a good packet so pass it on. */
  1505.                 else {
  1506.                     
  1507.                     /* Trim off the checksum. */
  1508.     if(pc->inTail->len >= 2) {
  1509. pc->inTail->len -= 2;
  1511. pc->inTail->tot_len = pc->inTail->len;
  1512. if (pc->inTail != pc->inHead) {
  1513.     pbuf_cat(pc->inHead, pc->inTail);
  1514. }
  1515.     } else {
  1516. pc->inTail->tot_len = pc->inTail->len;
  1517. if (pc->inTail != pc->inHead) {
  1518.     pbuf_cat(pc->inHead, pc->inTail);
  1519. }
  1521. pbuf_realloc(pc->inHead, pc->inHead->tot_len - 2);
  1522.     }
  1524.                     /* Dispatch the packet thereby consuming it. */
  1525. /*Modified by zhouzhigang 2005.01.16 for single thread*/
  1526.     pppInput((void *)(pc->inHead));
  1527.          #if 0
  1528.     if(tcpip_callback(pppInput, pc->inHead) != ERR_OK) {
  1529.                      PPPDEBUG((LOG_ERR,
  1530.     "pppInProc[%d]: tcpip_callback() failed, dropping packetn", pd));
  1531. pbuf_free(pc->inHead);
  1532. #if LINK_STATS
  1533. lwip_stats.link.drop++;
  1534. #endif
  1535.     }
  1536. #endif
  1537.                     pc->inHead = NULL;
  1538.                     pc->inTail = NULL;
  1539.                 }
  1540.                     
  1541.                 /* Prepare for a new packet. */
  1542.                 pc->inFCS = PPP_INITFCS;
  1543.                 pc->inState = PDADDRESS;
  1544.                 pc->inEscaped = 0;
  1545.             }
  1546.             /* Other characters are usually control characters that may have
  1547.              * been inserted by the physical layer so here we just drop them. */
  1548.             else {
  1549.                 PPPDEBUG((LOG_WARNING,
  1550.                             "pppInProc[%d]: Dropping ACCM char <%d>n", pd, curChar));
  1551.             }
  1552.         }
  1553.         /* Process other characters. */
  1554.         else {
  1555.             /* Unencode escaped characters. */
  1556.             if (pc->inEscaped) {
  1557.                 pc->inEscaped = 0;
  1558.                 curChar ^= PPP_TRANS;
  1559.             }
  1560.             
  1561.             /* Process character relative to current state. */
  1562.             switch(pc->inState) {
  1563.             case PDIDLE:                    /* Idle state - waiting. */
  1564.                 /* Drop the character if it's not 0xff
  1565.                  * we would have processed a flag character above. */
  1566.                 if (curChar != PPP_ALLSTATIONS) {
  1567.                  break;
  1568. }
  1570. /* Fall through */
  1571.             case PDSTART:                   /* Process start flag. */
  1572.                 /* Prepare for a new packet. */
  1573.                 pc->inFCS = PPP_INITFCS;
  1575. /* Fall through */
  1576.             case PDADDRESS:                 /* Process address field. */
  1577.                 if (curChar == PPP_ALLSTATIONS) {
  1578.                     pc->inState = PDCONTROL;
  1579.                     break;
  1580.                 }
  1581.                 /* Else assume compressed address and control fields so
  1582.                  * fall through to get the protocol... */
  1583.             case PDCONTROL:                 /* Process control field. */
  1584.                 /* If we don't get a valid control code, restart. */
  1585.                 if (curChar == PPP_UI) {
  1586.                     pc->inState = PDPROTOCOL1;
  1587.                  break;
  1588.                 }
  1589. #if 0
  1590.                 else {
  1591.                     PPPDEBUG((LOG_WARNING,
  1592.                                 "pppInProc[%d]: Invalid control <%d>n", pd, curChar));
  1593.                     pc->inState = PDSTART;
  1594.                 }
  1595. #endif
  1596.             case PDPROTOCOL1:               /* Process protocol field 1. */
  1597.                 /* If the lower bit is set, this is the end of the protocol
  1598.                  * field. */
  1599.                 if (curChar & 1) {
  1600.                     pc->inProtocol = curChar;
  1601.                     pc->inState = PDDATA;
  1602.                 }
  1603.                 else {
  1604.                     pc->inProtocol = (u_int)curChar << 8;
  1605.                     pc->inState = PDPROTOCOL2;
  1606.                 }
  1607.                 break;
  1608.             case PDPROTOCOL2:               /* Process protocol field 2. */
  1609.                 pc->inProtocol |= curChar;
  1610.                 pc->inState = PDDATA;
  1611.                 break;
  1612.             case PDDATA:                    /* Process data byte. */
  1613.                 /* Make space to receive processed data. */
  1614.                 if (pc->inTail == NULL || pc->inTail->len == PBUF_POOL_BUFSIZE) {
  1615.     if(pc->inTail) {
  1616. pc->inTail->tot_len = pc->inTail->len;
  1617. if (pc->inTail != pc->inHead) {
  1618.     pbuf_cat(pc->inHead, pc->inTail);
  1619. }
  1620.     }
  1621.                     /* If we haven't started a packet, we need a packet header. */
  1622.                     nextNBuf = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL);
  1623.                     if (nextNBuf == NULL) {
  1624.                         /* No free buffers.  Drop the input packet and let the
  1625.                          * higher layers deal with it.  Continue processing
  1626.                          * the received pbuf chain in case a new packet starts. */
  1627.                         PPPDEBUG((LOG_ERR, "pppInProc[%d]: NO FREE MBUFS!n", pd));
  1628. #if LINK_STATS
  1629. lwip_stats.link.memerr++;
  1630. #endif /* LINK_STATS */
  1631.                         pppDrop(pc);
  1632.                         pc->inState = PDSTART;  /* Wait for flag sequence. */
  1633. break;
  1634.                     }
  1635.     if (pc->inHead == NULL) {
  1636. struct pppInputHeader *pih = nextNBuf->payload;
  1638. pih->unit = pd;
  1639. pih->proto = pc->inProtocol;
  1641. nextNBuf->len += sizeof(*pih);
  1643. pc->inHead = nextNBuf;
  1644.     }
  1645.     pc->inTail = nextNBuf;
  1646.                 }
  1647.                 /* Load character into buffer. */
  1648.                 ((u_char*)pc->inTail->payload)[pc->inTail->len++] = curChar;
  1649.                 break;
  1650.             }
  1652.             /* update the frame check sequence number. */
  1653.             pc->inFCS = PPP_FCS(pc->inFCS, curChar);
  1654.         }
  1655.     }
  1656. avRandomize();
  1657. }
  1659. #if( PPP_DEBUG == DBG_ON)
  1660. char debug_buf[1024];
  1661. void ppp_trace(int level, const char *format,...)
  1662. {
  1663.      
  1665.      sprintf(debug_buf, format);
  1666.      DEBUG_EVENT(debug_buf);
  1667. }
  1668. #endif
  1669. #endif /* PPP_SUPPORT */