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

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

嵌入式/单片机编程

开发平台：

C/C++

lcp.c：源码内容
  1. /*****************************************************************************
  2. * lcp.c - Network Link Control 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-12-01 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
  31. * Original.
  32. *****************************************************************************/
  34. /*
  35.  * lcp.c - PPP Link Control Protocol.
  36.  *
  37.  * Copyright (c) 1989 Carnegie Mellon University.
  38.  * All rights reserved.
  39.  *
  40.  * Redistribution and use in source and binary forms are permitted
  41.  * provided that the above copyright notice and this paragraph are
  42.  * duplicated in all such forms and that any documentation,
  43.  * advertising materials, and other materials related to such
  44.  * distribution and use acknowledge that the software was developed
  45.  * by Carnegie Mellon University.  The name of the
  46.  * University may not be used to endorse or promote products derived
  47.  * from this software without specific prior written permission.
  48.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  49.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  50.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  51.  */
  52.  
  53. #include <string.h>
  54.  
  55. #include "ppp.h"
  56. #if PPP_SUPPORT > 0
  57. #include "fsm.h"
  58. #include "chap.h"
  59. #include "magic.h"
  60. #include "auth.h"
  61. #include "lcp.h"
  62. #include "pppdebug.h"
  63. #include "timer.h"
  65. #include "uart.h"
  67. /*************************/
  68. /*** LOCAL DEFINITIONS ***/
  69. /*************************/
  70. /*
  71.  * Length of each type of configuration option (in octets)
  72.  */
  73. #define CILEN_VOID 2
  74. #define CILEN_CHAR 3
  75. #define CILEN_SHORT 4 /* CILEN_VOID + sizeof(short) */
  76. #define CILEN_CHAP 5 /* CILEN_VOID + sizeof(short) + 1 */
  77. #define CILEN_LONG 6 /* CILEN_VOID + sizeof(long) */
  78. #define CILEN_LQR 8 /* CILEN_VOID + sizeof(short) + sizeof(long) */
  79. #define CILEN_CBCP 3
  82. /***********************************/
  83. /*** LOCAL FUNCTION DECLARATIONS ***/
  84. /***********************************/
  85. /*
  86.  * Callbacks for fsm code.  (CI = Configuration Information)
  87.  */
  88. static void lcp_resetci (fsm*);         /* Reset our CI */
  89. static int  lcp_cilen (fsm*);         /* Return length of our CI */
  90. static void lcp_addci (fsm*, u_char*, int*);       /* Add our CI to pkt */
  91. static int  lcp_ackci (fsm*, u_char*, int);/* Peer ack'd our CI */
  92. static int  lcp_nakci (fsm*, u_char*, int);/* Peer nak'd our CI */
  93. static int  lcp_rejci (fsm*, u_char*, int);/* Peer rej'd our CI */
  94. static int  lcp_reqci (fsm*, u_char*, int*, int);  /* Rcv peer CI */
  95. static void lcp_up (fsm*);             /* We're UP */
  96. static void lcp_down (fsm*);          /* We're DOWN */
  97. static void lcp_starting (fsm*);        /* We need lower layer up */
  98. static void lcp_finished (fsm*);         /* We need lower layer down */
  99. static int  lcp_extcode (fsm*, int, u_char, u_char*, int);
  101. static void lcp_rprotrej (fsm*, u_char*, int);
  103. /*
  104.  * routines to send LCP echos to peer
  105.  */
  106. static void lcp_echo_lowerup (int);
  107. static void lcp_echo_lowerdown (int);
  108. static void LcpEchoTimeout (void*);
  109. static void lcp_received_echo_reply (fsm*, int, u_char*, int);
  110. static void LcpSendEchoRequest (fsm*);
  111. static void LcpLinkFailure (fsm*);
  112. static void LcpEchoCheck (fsm*);
  114. /*
  115.  * Protocol entry points.
  116.  * Some of these are called directly.
  117.  */
  118. static void lcp_input (int, u_char *, int);
  119. static void lcp_protrej (int);
  121. #define CODENAME(x) ((x) == CONFACK ? "ACK" : 
  122.  (x) == CONFNAK ? "NAK" : "REJ")
  125. /******************************/
  126. /*** PUBLIC DATA STRUCTURES ***/
  127. /******************************/
  128. /* global vars */
  129. LinkPhase lcp_phase[NUM_PPP]; /* Phase of link session (RFC 1661) */
  130. lcp_options lcp_wantoptions[NUM_PPP]; /* Options that we want to request */
  131. lcp_options lcp_gotoptions[NUM_PPP]; /* Options that peer ack'd */
  132. lcp_options lcp_allowoptions[NUM_PPP]; /* Options we allow peer to request */
  133. lcp_options lcp_hisoptions[NUM_PPP]; /* Options that we ack'd */
  134. ext_accm xmit_accm[NUM_PPP]; /* extended transmit ACCM */
  138. /*****************************/
  139. /*** LOCAL DATA STRUCTURES ***/
  140. /*****************************/
  141. static fsm lcp_fsm[NUM_PPP]; /* LCP fsm structure (global)*/
  142. static u_int  lcp_echo_interval = LCP_ECHOINTERVAL; /* Interval between LCP echo-requests */
  143. static u_int  lcp_echo_fails = LCP_MAXECHOFAILS; /* Tolerance to unanswered echo-requests */
  144. static u32_t lcp_echos_pending = 0; /* Number of outstanding echo msgs */
  145. static u32_t lcp_echo_number   = 0; /* ID number of next echo frame */
  146. static u32_t lcp_echo_timer_running = 0;  /* TRUE if a timer is running */
  148. static u_char nak_buffer[PPP_MRU]; /* where we construct a nak packet */
  150. static fsm_callbacks lcp_callbacks = { /* LCP callback routines */
  151.     lcp_resetci, /* Reset our Configuration Information */
  152.     lcp_cilen, /* Length of our Configuration Information */
  153.     lcp_addci, /* Add our Configuration Information */
  154.     lcp_ackci, /* ACK our Configuration Information */
  155.     lcp_nakci, /* NAK our Configuration Information */
  156.     lcp_rejci, /* Reject our Configuration Information */
  157.     lcp_reqci, /* Request peer's Configuration Information */
  158.     lcp_up, /* Called when fsm reaches OPENED state */
  159.     lcp_down, /* Called when fsm leaves OPENED state */
  160.     lcp_starting, /* Called when we want the lower layer up */
  161.     lcp_finished, /* Called when we want the lower layer down */
  162.     NULL, /* Called when Protocol-Reject received */
  163.     NULL, /* Retransmission is necessary */
  164.     lcp_extcode, /* Called to handle LCP-specific codes */
  165.     "LCP" /* String name of protocol */
  166. };
  168. struct protent lcp_protent = {
  169.     PPP_LCP,
  170.     lcp_init,
  171.     lcp_input,
  172.     lcp_protrej,
  173.     lcp_lowerup,
  174.     lcp_lowerdown,
  175.     lcp_open,
  176.     lcp_close,
  177. #if 0
  178.     lcp_printpkt,
  179.     NULL,
  180. #endif
  181.     1,
  182.     "LCP",
  183. #if 0
  184.     NULL,
  185.     NULL,
  186.     NULL
  187. #endif
  188. };
  190. int lcp_loopbackfail = DEFLOOPBACKFAIL;
  192. /*
  193. *return the state of ppp connect
  194. */
  195. BOOL  ppp_dead(int pd)
  196. {
  197.     if( lcp_phase[pd] == PHASE_DEAD)
  198. return TRUE;
  199.     else 
  200. return FALSE;
  201. }
  204. /***********************************/
  205. /*** PUBLIC FUNCTION DEFINITIONS ***/
  206. /***********************************/
  207. /*
  208.  * lcp_init - Initialize LCP.
  209.  */
  210. void lcp_init(int unit)
  211. {
  212. fsm *f = &lcp_fsm[unit];
  213. lcp_options *wo = &lcp_wantoptions[unit];
  214. lcp_options *ao = &lcp_allowoptions[unit];
  216. f->unit = unit;
  217. f->protocol = PPP_LCP;
  218. f->callbacks = &lcp_callbacks;
  220. fsm_init(f);
  222. wo->passive = 0;
  223. wo->silent = 0;
  224. wo->restart = 0; /* Set to 1 in kernels or multi-line
  225.  * implementations */
  226. wo->neg_mru = 1;
  227. wo->mru = PPP_DEFMRU;
  228. wo->neg_asyncmap = 1;
  229. wo->asyncmap = 0x00000000l; /* Assume don't need to escape any ctl chars. */
  230. wo->neg_chap = 0; /* Set to 1 on server */
  231. wo->neg_upap = 0; /* Set to 1 on server */
  232. wo->chap_mdtype = CHAP_DIGEST_MD5;
  233. wo->neg_magicnumber = 1;
  234. wo->neg_pcompression = 1;
  235. wo->neg_accompression = 1;
  236. wo->neg_lqr = 0; /* no LQR implementation yet */
  237. wo->neg_cbcp = 0;
  239. ao->neg_mru = 1;
  240. ao->mru = PPP_MAXMRU;
  241. ao->neg_asyncmap = 1;
  242. ao->asyncmap = 0x00000000l; /* Assume don't need to escape any ctl chars. */
  243. ao->neg_chap = (CHAP_SUPPORT != 0);
  244. ao->chap_mdtype = CHAP_DIGEST_MD5;
  245. ao->neg_upap = (PAP_SUPPORT != 0);
  246. ao->neg_magicnumber = 1;
  247. ao->neg_pcompression = 1;
  248. ao->neg_accompression = 1;
  249. ao->neg_lqr = 0; /* no LQR implementation yet */
  250. ao->neg_cbcp = (CBCP_SUPPORT != 0);
  252. /* 
  253.  * Set transmit escape for the flag and escape characters plus anything
  254.  * set for the allowable options.
  255.  */
  256. memset(xmit_accm[unit], 0, sizeof(xmit_accm[0]));
  257. xmit_accm[unit][15] = 0x60;
  258. xmit_accm[unit][0] = (u_char)(ao->asyncmap & 0xFF);
  259. xmit_accm[unit][1] = (u_char)((ao->asyncmap >> 8) & 0xFF);
  260. xmit_accm[unit][2] = (u_char)((ao->asyncmap >> 16) & 0xFF);
  261. xmit_accm[unit][3] = (u_char)((ao->asyncmap >> 24) & 0xFF);
  262. LCPDEBUG((LOG_INFO, "lcp_init: xmit_accm=%X %X %X %Xn",
  263. xmit_accm[unit][0],
  264. xmit_accm[unit][1],
  265. xmit_accm[unit][2],
  266. xmit_accm[unit][3]));
  268. lcp_phase[unit] = PHASE_INITIALIZE;
  269. }
  272. /*
  273.  * lcp_open - LCP is allowed to come up.
  274.  */
  275. void lcp_open(int unit)
  276. {
  277. fsm *f = &lcp_fsm[unit];
  278. lcp_options *wo = &lcp_wantoptions[unit];
  280. f->flags = 0;
  281. if (wo->passive)
  282. f->flags |= OPT_PASSIVE;
  283. if (wo->silent)
  284. f->flags |= OPT_SILENT;
  285. fsm_open(f);
  287. lcp_phase[unit] = PHASE_ESTABLISH; 
  288. }
  291. /*
  292.  * lcp_close - Take LCP down.
  293.  */
  294. void lcp_close(int unit, char *reason)
  295. {
  296. fsm *f = &lcp_fsm[unit];
  298. if (lcp_phase[unit] != PHASE_DEAD)
  299. lcp_phase[unit] = PHASE_TERMINATE;
  300. if (f->state == STOPPED && f->flags & (OPT_PASSIVE|OPT_SILENT)) {
  301. /*
  302.  * This action is not strictly according to the FSM in RFC1548,
  303.  * but it does mean that the program terminates if you do an
  304.  * lcp_close() in passive/silent mode when a connection hasn't
  305.  * been established.
  306.  */
  307. f->state = CLOSED;
  308. lcp_finished(f);
  309. }
  310. else
  311. fsm_close(&lcp_fsm[unit], reason);
  312. }
  315. /*
  316.  * lcp_lowerup - The lower layer is up.
  317.  */
  318. void lcp_lowerup(int unit)
  319. {
  320. lcp_options *wo = &lcp_wantoptions[unit];
  322. /*
  323. * Don't use A/C or protocol compression on transmission,
  324. * but accept A/C and protocol compressed packets
  325. * if we are going to ask for A/C and protocol compression.
  326. */
  327. ppp_set_xaccm(unit, &xmit_accm[unit]);
  328. ppp_send_config(unit, PPP_MRU, 0xffffffffl, 0, 0);
  329. ppp_recv_config(unit, PPP_MRU, 0x00000000l,
  330. wo->neg_pcompression, wo->neg_accompression);
  331. peer_mru[unit] = PPP_MRU;
  332. lcp_allowoptions[unit].asyncmap 
  333. = (u_long)xmit_accm[unit][0]
  334. | ((u_long)xmit_accm[unit][1] << 8)
  335. | ((u_long)xmit_accm[unit][2] << 16)
  336. | ((u_long)xmit_accm[unit][3] << 24);
  337. LCPDEBUG((LOG_INFO, "lcp_lowerup: asyncmap=%X %X %X %Xn",
  338. xmit_accm[unit][3],
  339. xmit_accm[unit][2],
  340. xmit_accm[unit][1],
  341. xmit_accm[unit][0]));
  343. fsm_lowerup(&lcp_fsm[unit]);
  344. }
  347. /*
  348.  * lcp_lowerdown - The lower layer is down.
  349.  */
  350. void lcp_lowerdown(int unit)
  351. {
  352. fsm_lowerdown(&lcp_fsm[unit]);
  353. }
  355. /*
  356.  * lcp_sprotrej - Send a Protocol-Reject for some protocol.
  357.  */
  358. void lcp_sprotrej(int unit, u_char *p, int len)
  359. {
  360. /*
  361. * Send back the protocol and the information field of the
  362. * rejected packet.  We only get here if LCP is in the OPENED state.
  363. */
  365. fsm_sdata(&lcp_fsm[unit], PROTREJ, ++lcp_fsm[unit].id,
  366. p, len);
  367. }
  371. /**********************************/
  372. /*** LOCAL FUNCTION DEFINITIONS ***/
  373. /**********************************/
  374. /*
  375.  * lcp_input - Input LCP packet.
  376.  */
  377. static void lcp_input(int unit, u_char *p, int len)
  378. {
  379. fsm *f = &lcp_fsm[unit];
  381. fsm_input(f, p, len);
  382. }
  385. /*
  386.  * lcp_extcode - Handle a LCP-specific code.
  387.  */
  388. static int lcp_extcode(fsm *f, int code, u_char id, u_char *inp, int len)
  389. {
  390. u_char *magp;
  392. switch( code ){
  393. case PROTREJ:
  394. lcp_rprotrej(f, inp, len);
  395. break;
  397. case ECHOREQ:
  398. if (f->state != OPENED)
  399. break;
  400. LCPDEBUG((LOG_INFO, "lcp: Echo-Request, Rcvd id %dn", id));
  401. magp = inp;
  402. PUTLONG(lcp_gotoptions[f->unit].magicnumber, magp);
  403. fsm_sdata(f, ECHOREP, id, inp, len);
  404. break;
  406. case ECHOREP:
  407. lcp_received_echo_reply(f, id, inp, len);
  408. break;
  410. case DISCREQ:
  411. break;
  413. default:
  414. return 0;
  415. }
  416. return 1;
  417. }
  419.     
  420. /*
  421.  * lcp_rprotrej - Receive an Protocol-Reject.
  422.  *
  423.  * Figure out which protocol is rejected and inform it.
  424.  */
  425. static void lcp_rprotrej(fsm *f, u_char *inp, int len)
  426. {
  427. int i;
  428. struct protent *protp;
  429. u_short prot;
  431. if (len < sizeof (u_short)) {
  432. LCPDEBUG((LOG_INFO,
  433. "lcp_rprotrej: Rcvd short Protocol-Reject packet!n"));
  434. return;
  435. }
  437. GETSHORT(prot, inp);
  439. LCPDEBUG((LOG_INFO,
  440. "lcp_rprotrej: Rcvd Protocol-Reject packet for %x!n",
  441. prot));
  443. /*
  444. * Protocol-Reject packets received in any state other than the LCP
  445. * OPENED state SHOULD be silently discarded.
  446. */
  447. if( f->state != OPENED ){
  448. LCPDEBUG((LOG_INFO, "Protocol-Reject discarded: LCP in state %dn",
  449. f->state));
  450. return;
  451. }
  453. /*
  454. * Upcall the proper Protocol-Reject routine.
  455. */
  456. for (i = 0; (protp = ppp_protocols[i]) != NULL; ++i)
  457. if (protp->protocol == prot && protp->enabled_flag) {
  458. (*protp->protrej)(f->unit);
  459. return;
  460. }
  462. LCPDEBUG((LOG_WARNING, "Protocol-Reject for unsupported protocol 0x%xn",
  463. prot));
  464. }
  467. /*
  468.  * lcp_protrej - A Protocol-Reject was received.
  469.  */
  470. static void lcp_protrej(int unit)
  471. {
  472. (void)unit;
  473. /*
  474. * Can't reject LCP!
  475. */
  476. LCPDEBUG((LOG_WARNING,
  477. "lcp_protrej: Received Protocol-Reject for LCP!n"));
  478. fsm_protreject(&lcp_fsm[unit]);
  479. }
  482. /*
  483.  * lcp_resetci - Reset our CI.
  484.  */
  485. static void lcp_resetci(fsm *f)
  486. {
  487. lcp_wantoptions[f->unit].magicnumber = magic();
  488. lcp_wantoptions[f->unit].numloops = 0;
  489. lcp_gotoptions[f->unit] = lcp_wantoptions[f->unit];
  490. peer_mru[f->unit] = PPP_MRU;
  491. auth_reset(f->unit);
  492. }
  495. /*
  496.  * lcp_cilen - Return length of our CI.
  497.  */
  498. static int lcp_cilen(fsm *f)
  499. {
  500. lcp_options *go = &lcp_gotoptions[f->unit];
  502. #define LENCIVOID(neg) ((neg) ? CILEN_VOID : 0)
  503. #define LENCICHAP(neg) ((neg) ? CILEN_CHAP : 0)
  504. #define LENCISHORT(neg) ((neg) ? CILEN_SHORT : 0)
  505. #define LENCILONG(neg) ((neg) ? CILEN_LONG : 0)
  506. #define LENCILQR(neg) ((neg) ? CILEN_LQR: 0)
  507. #define LENCICBCP(neg) ((neg) ? CILEN_CBCP: 0)
  508. /*
  509. * NB: we only ask for one of CHAP and UPAP, even if we will
  510. * accept either.
  511. */
  512. return (LENCISHORT(go->neg_mru && go->mru != PPP_DEFMRU) +
  513.        //(LENCISHORT(go->neg_mru && go->mru == PPP_DEFMRU) +
  514. LENCILONG(go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl) +
  515. LENCICHAP(go->neg_chap) +
  516. LENCISHORT(!go->neg_chap && go->neg_upap) +
  517. LENCILQR(go->neg_lqr) +
  518. LENCICBCP(go->neg_cbcp) +
  519. LENCILONG(go->neg_magicnumber) +
  520. LENCIVOID(go->neg_pcompression) +
  521. LENCIVOID(go->neg_accompression));
  522. }
  525. /*
  526.  * lcp_addci - Add our desired CIs to a packet.
  527.  */
  528. static void lcp_addci(fsm *f, u_char *ucp, int *lenp)
  529. {
  530. lcp_options *go = &lcp_gotoptions[f->unit];
  531. u_char *start_ucp = ucp;
  533. #define ADDCIVOID(opt, neg) 
  534. if (neg) { 
  535.     LCPDEBUG((LOG_INFO, "lcp_addci: opt=%dn", opt)); 
  536. PUTCHAR(opt, ucp); 
  537. PUTCHAR(CILEN_VOID, ucp); 
  538. }
  539. #define ADDCISHORT(opt, neg, val) 
  540. if (neg) { 
  541.     LCPDEBUG((LOG_INFO, "lcp_addci: INT opt=%d %Xn", opt, val)); 
  542. PUTCHAR(opt, ucp); 
  543. PUTCHAR(CILEN_SHORT, ucp); 
  544. PUTSHORT(val, ucp); 
  545. }
  546. #define ADDCICHAP(opt, neg, val, digest) 
  547. if (neg) { 
  548.     LCPDEBUG((LOG_INFO, "lcp_addci: CHAP opt=%d %Xn", opt, val)); 
  549. PUTCHAR(opt, ucp); 
  550. PUTCHAR(CILEN_CHAP, ucp); 
  551. PUTSHORT(val, ucp); 
  552. PUTCHAR(digest, ucp); 
  553. }
  554. #define ADDCILONG(opt, neg, val) 
  555. if (neg) { 
  556.     LCPDEBUG((LOG_INFO, "lcp_addci: L opt=%d %lXn", opt, val)); 
  557. PUTCHAR(opt, ucp); 
  558. PUTCHAR(CILEN_LONG, ucp); 
  559. PUTLONG(val, ucp); 
  560. }
  561. #define ADDCILQR(opt, neg, val) 
  562. if (neg) { 
  563.     LCPDEBUG((LOG_INFO, "lcp_addci: LQR opt=%d %lXn", opt, val)); 
  564. PUTCHAR(opt, ucp); 
  565. PUTCHAR(CILEN_LQR, ucp); 
  566. PUTSHORT(PPP_LQR, ucp); 
  567. PUTLONG(val, ucp); 
  568. }
  569. #define ADDCICHAR(opt, neg, val) 
  570. if (neg) { 
  571.     LCPDEBUG((LOG_INFO, "lcp_addci: CHAR opt=%d %X '%z'n", opt, val, val)); 
  572. PUTCHAR(opt, ucp); 
  573. PUTCHAR(CILEN_CHAR, ucp); 
  574. PUTCHAR(val, ucp); 
  575. }
  577. ADDCISHORT(CI_MRU, go->neg_mru && go->mru != PPP_DEFMRU, go->mru);
  578. //ADDCISHORT(CI_MRU, go->neg_mru && go->mru == PPP_DEFMRU, go->mru);
  579. ADDCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl,
  580. go->asyncmap);
  581. ADDCICHAP(CI_AUTHTYPE, go->neg_chap, PPP_CHAP, go->chap_mdtype);
  582. ADDCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP);
  583. ADDCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period);
  584. ADDCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT);
  585. ADDCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber);
  586. ADDCIVOID(CI_PCOMPRESSION, go->neg_pcompression);
  587. ADDCIVOID(CI_ACCOMPRESSION, go->neg_accompression);
  589. if (ucp - start_ucp != *lenp) {
  590. /* this should never happen, because peer_mtu should be 1500 */
  591. LCPDEBUG((LOG_ERR, "Bug in lcp_addci: wrong lengthn"));
  592. }
  593. }
  596. /*
  597.  * lcp_ackci - Ack our CIs.
  598.  * This should not modify any state if the Ack is bad.
  599.  *
  600.  * Returns:
  601.  * 0 - Ack was bad.
  602.  * 1 - Ack was good.
  603.  */
  604. static int lcp_ackci(fsm *f, u_char *p, int len)
  605. {
  606. lcp_options *go = &lcp_gotoptions[f->unit];
  607. u_char cilen, citype, cichar;
  608. u_short cishort;
  609. u32_t cilong;
  611. /*
  612. * CIs must be in exactly the same order that we sent.
  613. * Check packet length and CI length at each step.
  614. * If we find any deviations, then this packet is bad.
  615. */
  616. #define ACKCIVOID(opt, neg) 
  617. if (neg) { 
  618. if ((len -= CILEN_VOID) < 0) 
  619. goto bad; 
  620. GETCHAR(citype, p); 
  621. GETCHAR(cilen, p); 
  622. if (cilen != CILEN_VOID || 
  623. citype != opt) 
  624. goto bad; 
  625. }
  626. #define ACKCISHORT(opt, neg, val) 
  627. if (neg) { 
  628. if ((len -= CILEN_SHORT) < 0) 
  629. goto bad; 
  630. GETCHAR(citype, p); 
  631. GETCHAR(cilen, p); 
  632. if (cilen != CILEN_SHORT || 
  633. citype != opt) 
  634. goto bad; 
  635. GETSHORT(cishort, p); 
  636. if (cishort != val) 
  637. goto bad; 
  638. }
  639. #define ACKCICHAR(opt, neg, val) 
  640. if (neg) { 
  641. if ((len -= CILEN_CHAR) < 0) 
  642. goto bad; 
  643. GETCHAR(citype, p); 
  644. GETCHAR(cilen, p); 
  645. if (cilen != CILEN_CHAR || 
  646. citype != opt) 
  647. goto bad; 
  648. GETCHAR(cichar, p); 
  649. if (cichar != val) 
  650. goto bad; 
  651. }
  652. #define ACKCICHAP(opt, neg, val, digest) 
  653. if (neg) { 
  654. if ((len -= CILEN_CHAP) < 0) 
  655. goto bad; 
  656. GETCHAR(citype, p); 
  657. GETCHAR(cilen, p); 
  658. if (cilen != CILEN_CHAP || 
  659. citype != opt) 
  660. goto bad; 
  661. GETSHORT(cishort, p); 
  662. if (cishort != val) 
  663. goto bad; 
  664. GETCHAR(cichar, p); 
  665. if (cichar != digest) 
  666. goto bad; 
  667. }
  668. #define ACKCILONG(opt, neg, val) 
  669. if (neg) { 
  670. if ((len -= CILEN_LONG) < 0) 
  671. goto bad; 
  672. GETCHAR(citype, p); 
  673. GETCHAR(cilen, p); 
  674. if (cilen != CILEN_LONG || 
  675. citype != opt) 
  676. goto bad; 
  677. GETLONG(cilong, p); 
  678. if (cilong != val) 
  679. goto bad; 
  680. }
  681. #define ACKCILQR(opt, neg, val) 
  682. if (neg) { 
  683. if ((len -= CILEN_LQR) < 0) 
  684. goto bad; 
  685. GETCHAR(citype, p); 
  686. GETCHAR(cilen, p); 
  687. if (cilen != CILEN_LQR || 
  688. citype != opt) 
  689. goto bad; 
  690. GETSHORT(cishort, p); 
  691. if (cishort != PPP_LQR) 
  692. goto bad; 
  693. GETLONG(cilong, p); 
  694. if (cilong != val) 
  695. goto bad; 
  696. }
  698. ACKCISHORT(CI_MRU, go->neg_mru && go->mru != PPP_DEFMRU, go->mru);
  699. ACKCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl,
  700. go->asyncmap);
  701. ACKCICHAP(CI_AUTHTYPE, go->neg_chap, PPP_CHAP, go->chap_mdtype);
  702. ACKCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP);
  703. ACKCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period);
  704. ACKCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT);
  705. ACKCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber);
  706. ACKCIVOID(CI_PCOMPRESSION, go->neg_pcompression);
  707. ACKCIVOID(CI_ACCOMPRESSION, go->neg_accompression);
  709. /*
  710.  * If there are any remaining CIs, then this packet is bad.
  711.  */
  712. if (len != 0)
  713. goto bad;
  714. LCPDEBUG((LOG_INFO, "lcp_acki: Ackn"));
  715. return (1);
  716. bad:
  717. LCPDEBUG((LOG_WARNING, "lcp_acki: received bad Ack!n"));
  718. return (0);
  719. }
  722. /*
  723.  * lcp_nakci - Peer has sent a NAK for some of our CIs.
  724.  * This should not modify any state if the Nak is bad
  725.  * or if LCP is in the OPENED state.
  726.  *
  727.  * Returns:
  728.  * 0 - Nak was bad.
  729.  * 1 - Nak was good.
  730.  */
  731. static int lcp_nakci(fsm *f, u_char *p, int len)
  732. {
  733. lcp_options *go = &lcp_gotoptions[f->unit];
  734. lcp_options *wo = &lcp_wantoptions[f->unit];
  735. u_char citype, cichar, *next;
  736. u_short cishort;
  737. u32_t cilong;
  738. lcp_options no; /* options we've seen Naks for */
  739. lcp_options try; /* options to request next time */
  740. int looped_back = 0;
  741. int cilen;
  743. BZERO(&no, sizeof(no));
  744. try = *go;
  746. /*
  747. * Any Nak'd CIs must be in exactly the same order that we sent.
  748. * Check packet length and CI length at each step.
  749. * If we find any deviations, then this packet is bad.
  750. */
  751. #define NAKCIVOID(opt, neg, code) 
  752. if (go->neg && 
  753. len >= CILEN_VOID && 
  754. p[1] == CILEN_VOID && 
  755. p[0] == opt) { 
  756. len -= CILEN_VOID; 
  757. INCPTR(CILEN_VOID, p); 
  758. no.neg = 1; 
  759. code 
  760. }
  761. #define NAKCICHAP(opt, neg, code) 
  762. if (go->neg && 
  763. len >= CILEN_CHAP && 
  764. p[1] == CILEN_CHAP && 
  765. p[0] == opt) { 
  766. len -= CILEN_CHAP; 
  767. INCPTR(2, p); 
  768. GETSHORT(cishort, p); 
  769. GETCHAR(cichar, p); 
  770. no.neg = 1; 
  771. code 
  772. }
  773. #define NAKCICHAR(opt, neg, code) 
  774. if (go->neg && 
  775. len >= CILEN_CHAR && 
  776. p[1] == CILEN_CHAR && 
  777. p[0] == opt) { 
  778. len -= CILEN_CHAR; 
  779. INCPTR(2, p); 
  780. GETCHAR(cichar, p); 
  781. no.neg = 1; 
  782. code 
  783. }
  784. #define NAKCISHORT(opt, neg, code) 
  785. if (go->neg && 
  786. len >= CILEN_SHORT && 
  787. p[1] == CILEN_SHORT && 
  788. p[0] == opt) { 
  789. len -= CILEN_SHORT; 
  790. INCPTR(2, p); 
  791. GETSHORT(cishort, p); 
  792. no.neg = 1; 
  793. code 
  794. }
  795. #define NAKCILONG(opt, neg, code) 
  796. if (go->neg && 
  797. len >= CILEN_LONG && 
  798. p[1] == CILEN_LONG && 
  799. p[0] == opt) { 
  800. len -= CILEN_LONG; 
  801. INCPTR(2, p); 
  802. GETLONG(cilong, p); 
  803. no.neg = 1; 
  804. code 
  805. }
  806. #define NAKCILQR(opt, neg, code) 
  807. if (go->neg && 
  808. len >= CILEN_LQR && 
  809. p[1] == CILEN_LQR && 
  810. p[0] == opt) { 
  811. len -= CILEN_LQR; 
  812. INCPTR(2, p); 
  813. GETSHORT(cishort, p); 
  814. GETLONG(cilong, p); 
  815. no.neg = 1; 
  816. code 
  817. }
  819. /*
  820. * We don't care if they want to send us smaller packets than
  821. * we want.  Therefore, accept any MRU less than what we asked for,
  822. * but then ignore the new value when setting the MRU in the kernel.
  823. * If they send us a bigger MRU than what we asked, accept it, up to
  824. * the limit of the default MRU we'd get if we didn't negotiate.
  825. */
  826. if (go->neg_mru && go->mru != PPP_DEFMRU) {
  827. NAKCISHORT(CI_MRU, neg_mru,
  828. if (cishort <= wo->mru || cishort < PPP_DEFMRU)
  829. try.mru = cishort;
  830. );
  831. }
  833. /*
  834. * Add any characters they want to our (receive-side) asyncmap.
  835. */
  836. if (go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl) {
  837. NAKCILONG(CI_ASYNCMAP, neg_asyncmap,
  838. try.asyncmap = go->asyncmap | cilong;
  839. );
  840. }
  842. /*
  843. * If they've nak'd our authentication-protocol, check whether
  844. * they are proposing a different protocol, or a different
  845. * hash algorithm for CHAP.
  846. */
  847. if ((go->neg_chap || go->neg_upap)
  848. && len >= CILEN_SHORT
  849. && p[0] == CI_AUTHTYPE && p[1] >= CILEN_SHORT && p[1] <= len) {
  850. cilen = p[1];
  851. len -= cilen;
  852. no.neg_chap = go->neg_chap;
  853. no.neg_upap = go->neg_upap;
  854. INCPTR(2, p);
  855. GETSHORT(cishort, p);
  856. if (cishort == PPP_PAP && cilen == CILEN_SHORT) {
  857. /*
  858.  * If we were asking for CHAP, they obviously don't want to do it.
  859.  * If we weren't asking for CHAP, then we were asking for PAP,
  860.  * in which case this Nak is bad.
  861.  */
  862. if (!go->neg_chap)
  863. goto bad;
  864. try.neg_chap = 0;
  866. } else if (cishort == PPP_CHAP && cilen == CILEN_CHAP) {
  867. GETCHAR(cichar, p);
  868. if (go->neg_chap) {
  869. /*
  870.  * We were asking for CHAP/MD5; they must want a different
  871.  * algorithm.  If they can't do MD5, we'll have to stop
  872.  * asking for CHAP.
  873.  */
  874. if (cichar != go->chap_mdtype)
  875. try.neg_chap = 0;
  876. } else {
  877. /*
  878.  * Stop asking for PAP if we were asking for it.
  879.  */
  880. try.neg_upap = 0;
  881. }
  883. } else {
  884. /*
  885.  * We don't recognize what they're suggesting.
  886.  * Stop asking for what we were asking for.
  887.  */
  888. if (go->neg_chap)
  889. try.neg_chap = 0;
  890. else
  891. try.neg_upap = 0;
  892. p += cilen - CILEN_SHORT;
  893. }
  894. }
  896. /*
  897. * If they can't cope with our link quality protocol, we'll have
  898. * to stop asking for LQR.  We haven't got any other protocol.
  899. * If they Nak the reporting period, take their value XXX ?
  900. */
  901. NAKCILQR(CI_QUALITY, neg_lqr,
  902. if (cishort != PPP_LQR)
  903. try.neg_lqr = 0;
  904. else
  905. try.lqr_period = cilong;
  906. );
  908. /*
  909. * Only implementing CBCP...not the rest of the callback options
  910. */
  911. NAKCICHAR(CI_CALLBACK, neg_cbcp,
  912. try.neg_cbcp = 0;
  913. );
  915. /*
  916. * Check for a looped-back line.
  917. */
  918. NAKCILONG(CI_MAGICNUMBER, neg_magicnumber,
  919. try.magicnumber = magic();
  920. looped_back = 1;
  921. );
  923. /*
  924. * Peer shouldn't send Nak for protocol compression or
  925. * address/control compression requests; they should send
  926. * a Reject instead.  If they send a Nak, treat it as a Reject.
  927. */
  928. NAKCIVOID(CI_PCOMPRESSION, neg_pcompression,
  929. try.neg_pcompression = 0;
  930. );
  931. NAKCIVOID(CI_ACCOMPRESSION, neg_accompression,
  932. try.neg_accompression = 0;
  933. );
  935. /*
  936. * There may be remaining CIs, if the peer is requesting negotiation
  937. * on an option that we didn't include in our request packet.
  938. * If we see an option that we requested, or one we've already seen
  939. * in this packet, then this packet is bad.
  940. * If we wanted to respond by starting to negotiate on the requested
  941. * option(s), we could, but we don't, because except for the
  942. * authentication type and quality protocol, if we are not negotiating
  943. * an option, it is because we were told not to.
  944. * For the authentication type, the Nak from the peer means
  945. * `let me authenticate myself with you' which is a bit pointless.
  946. * For the quality protocol, the Nak means `ask me to send you quality
  947. * reports', but if we didn't ask for them, we don't want them.
  948. * An option we don't recognize represents the peer asking to
  949. * negotiate some option we don't support, so ignore it.
  950. */
  951. while (len > CILEN_VOID) {
  952. GETCHAR(citype, p);
  953. GETCHAR(cilen, p);
  954. if (cilen < CILEN_VOID || (len -= cilen) < 0)
  955. goto bad;
  956. next = p + cilen - 2;
  958. switch (citype) {
  959. case CI_MRU:
  960. if ((go->neg_mru && go->mru != PPP_DEFMRU)
  961. || no.neg_mru || cilen != CILEN_SHORT)
  962. goto bad;
  963. GETSHORT(cishort, p);
  964. if (cishort < PPP_DEFMRU)
  965. try.mru = cishort;
  966. break;
  967. case CI_ASYNCMAP:
  968. if ((go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl)
  969. || no.neg_asyncmap || cilen != CILEN_LONG)
  970. goto bad;
  971. break;
  972. case CI_AUTHTYPE:
  973. if (go->neg_chap || no.neg_chap || go->neg_upap || no.neg_upap)
  974. goto bad;
  975. break;
  976. case CI_MAGICNUMBER:
  977. if (go->neg_magicnumber || no.neg_magicnumber ||
  978. cilen != CILEN_LONG)
  979. goto bad;
  980. break;
  981. case CI_PCOMPRESSION:
  982. if (go->neg_pcompression || no.neg_pcompression
  983. || cilen != CILEN_VOID)
  984. goto bad;
  985. break;
  986. case CI_ACCOMPRESSION:
  987. if (go->neg_accompression || no.neg_accompression
  988. || cilen != CILEN_VOID)
  989. goto bad;
  990. break;
  991. case CI_QUALITY:
  992. if (go->neg_lqr || no.neg_lqr || cilen != CILEN_LQR)
  993. goto bad;
  994. break;
  995. }
  996. p = next;
  997. }
  999. /* If there is still anything left, this packet is bad. */
  1000. if (len != 0)
  1001. goto bad;
  1003. /*
  1004. * OK, the Nak is good.  Now we can update state.
  1005. */
  1006. if (f->state != OPENED) {
  1007. if (looped_back) {
  1008. if (++try.numloops >= lcp_loopbackfail) {
  1009. LCPDEBUG((LOG_NOTICE, "Serial line is looped back.n"));
  1010. lcp_close(f->unit, "Loopback detected");
  1011. }
  1012. } 
  1013. else
  1014. try.numloops = 0;
  1015. *go = try;
  1016. }
  1018. return 1;
  1020. bad:
  1021. LCPDEBUG((LOG_WARNING, "lcp_nakci: received bad Nak!n"));
  1022. return 0;
  1023. }
  1026. /*
  1027.  * lcp_rejci - Peer has Rejected some of our CIs.
  1028.  * This should not modify any state if the Reject is bad
  1029.  * or if LCP is in the OPENED state.
  1030.  *
  1031.  * Returns:
  1032.  * 0 - Reject was bad.
  1033.  * 1 - Reject was good.
  1034.  */
  1035. static int lcp_rejci(fsm *f, u_char *p, int len)
  1036. {
  1037. lcp_options *go = &lcp_gotoptions[f->unit];
  1038. u_char cichar;
  1039. u_short cishort;
  1040. u32_t cilong;
  1041. lcp_options try; /* options to request next time */
  1043. try = *go;
  1045. /*
  1046. * Any Rejected CIs must be in exactly the same order that we sent.
  1047. * Check packet length and CI length at each step.
  1048. * If we find any deviations, then this packet is bad.
  1049. */
  1050. #define REJCIVOID(opt, neg) 
  1051. if (go->neg && 
  1052. len >= CILEN_VOID && 
  1053. p[1] == CILEN_VOID && 
  1054. p[0] == opt) { 
  1055. len -= CILEN_VOID; 
  1056. INCPTR(CILEN_VOID, p); 
  1057. try.neg = 0; 
  1058. LCPDEBUG((LOG_INFO, "lcp_rejci: void opt %d rejectedn", opt)); 
  1059. }
  1060. #define REJCISHORT(opt, neg, val) 
  1061. if (go->neg && 
  1062. len >= CILEN_SHORT && 
  1063. p[1] == CILEN_SHORT && 
  1064. p[0] == opt) { 
  1065. len -= CILEN_SHORT; 
  1066. INCPTR(2, p); 
  1067. GETSHORT(cishort, p); 
  1068. /* Check rejected value. */ 
  1069. if (cishort != val) 
  1070. goto bad; 
  1071. try.neg = 0; 
  1072. LCPDEBUG((LOG_INFO,"lcp_rejci: short opt %d rejectedn", opt)); 
  1073. }
  1074. #define REJCICHAP(opt, neg, val, digest) 
  1075. if (go->neg && 
  1076. len >= CILEN_CHAP && 
  1077. p[1] == CILEN_CHAP && 
  1078. p[0] == opt) { 
  1079. len -= CILEN_CHAP; 
  1080. INCPTR(2, p); 
  1081. GETSHORT(cishort, p); 
  1082. GETCHAR(cichar, p); 
  1083. /* Check rejected value. */ 
  1084. if (cishort != val || cichar != digest) 
  1085. goto bad; 
  1086. try.neg = 0; 
  1087. try.neg_upap = 0; 
  1088. LCPDEBUG((LOG_INFO,"lcp_rejci: chap opt %d rejectedn", opt)); 
  1089. }
  1090. #define REJCILONG(opt, neg, val) 
  1091. if (go->neg && 
  1092. len >= CILEN_LONG && 
  1093. p[1] == CILEN_LONG && 
  1094. p[0] == opt) { 
  1095. len -= CILEN_LONG; 
  1096. INCPTR(2, p); 
  1097. GETLONG(cilong, p); 
  1098. /* Check rejected value. */ 
  1099. if (cilong != val) 
  1100. goto bad; 
  1101. try.neg = 0; 
  1102. LCPDEBUG((LOG_INFO,"lcp_rejci: long opt %d rejectedn", opt)); 
  1103. }
  1104. #define REJCILQR(opt, neg, val) 
  1105. if (go->neg && 
  1106. len >= CILEN_LQR && 
  1107. p[1] == CILEN_LQR && 
  1108. p[0] == opt) { 
  1109. len -= CILEN_LQR; 
  1110. INCPTR(2, p); 
  1111. GETSHORT(cishort, p); 
  1112. GETLONG(cilong, p); 
  1113. /* Check rejected value. */ 
  1114. if (cishort != PPP_LQR || cilong != val) 
  1115. goto bad; 
  1116. try.neg = 0; 
  1117. LCPDEBUG((LOG_INFO,"lcp_rejci: LQR opt %d rejectedn", opt)); 
  1118. }
  1119. #define REJCICBCP(opt, neg, val) 
  1120. if (go->neg && 
  1121. len >= CILEN_CBCP && 
  1122. p[1] == CILEN_CBCP && 
  1123. p[0] == opt) { 
  1124. len -= CILEN_CBCP; 
  1125. INCPTR(2, p); 
  1126. GETCHAR(cichar, p); 
  1127. /* Check rejected value. */ 
  1128. if (cichar != val) 
  1129. goto bad; 
  1130. try.neg = 0; 
  1131. LCPDEBUG((LOG_INFO,"lcp_rejci: Callback opt %d rejectedn", opt)); 
  1132. }
  1134. REJCISHORT(CI_MRU, neg_mru, go->mru);
  1135. REJCILONG(CI_ASYNCMAP, neg_asyncmap, go->asyncmap);
  1136. REJCICHAP(CI_AUTHTYPE, neg_chap, PPP_CHAP, go->chap_mdtype);
  1137. if (!go->neg_chap) {
  1138. REJCISHORT(CI_AUTHTYPE, neg_upap, PPP_PAP);
  1139. }
  1140. REJCILQR(CI_QUALITY, neg_lqr, go->lqr_period);
  1141. REJCICBCP(CI_CALLBACK, neg_cbcp, CBCP_OPT);
  1142. REJCILONG(CI_MAGICNUMBER, neg_magicnumber, go->magicnumber);
  1143. REJCIVOID(CI_PCOMPRESSION, neg_pcompression);
  1144. REJCIVOID(CI_ACCOMPRESSION, neg_accompression);
  1146. /*
  1147. * If there are any remaining CIs, then this packet is bad.
  1148. */
  1149. if (len != 0)
  1150. goto bad;
  1151. /*
  1152. * Now we can update state.
  1153. */
  1154. if (f->state != OPENED)
  1155. *go = try;
  1156. return 1;
  1158. bad:
  1159. LCPDEBUG((LOG_WARNING, "lcp_rejci: received bad Reject!n"));
  1160. return 0;
  1161. }
  1164. /*
  1165.  * lcp_reqci - Check the peer's requested CIs and send appropriate response.
  1166.  *
  1167.  * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
  1168.  * appropriately.  If reject_if_disagree is non-zero, doesn't return
  1169.  * CONFNAK; returns CONFREJ if it can't return CONFACK.
  1170.  */
  1171. static int lcp_reqci(fsm *f, 
  1172. u_char *inp, /* Requested CIs */
  1173. int *lenp, /* Length of requested CIs */
  1174. int reject_if_disagree)
  1175. {
  1176. lcp_options *go = &lcp_gotoptions[f->unit];
  1177. lcp_options *ho = &lcp_hisoptions[f->unit];
  1178. lcp_options *ao = &lcp_allowoptions[f->unit];
  1179. u_char *cip, *next; /* Pointer to current and next CIs */
  1180. int cilen, citype, cichar; /* Parsed len, type, char value */
  1181. u_short cishort; /* Parsed short value */
  1182. u32_t cilong; /* Parse long value */
  1183. int rc = CONFACK; /* Final packet return code */
  1184. int orc; /* Individual option return code */
  1185. u_char *p; /* Pointer to next char to parse */
  1186. u_char *rejp; /* Pointer to next char in reject frame */
  1187. u_char *nakp; /* Pointer to next char in Nak frame */
  1188. int l = *lenp; /* Length left */
  1189. #if TRACELCP > 0
  1190. char traceBuf[80];
  1191. int traceNdx = 0;
  1192. #endif
  1194. /*
  1195.  * Reset all his options.
  1196.  */
  1197. BZERO(ho, sizeof(*ho));
  1199. /*
  1200.  * Process all his options.
  1201.  */
  1202. next = inp;
  1203. nakp = nak_buffer;
  1204. rejp = inp;
  1205. while (l) {
  1206. orc = CONFACK; /* Assume success */
  1207. cip = p = next; /* Remember begining of CI */
  1208. if (l < 2 || /* Not enough data for CI header or */
  1209. p[1] < 2 || /*  CI length too small or */
  1210. p[1] > l) { /*  CI length too big? */
  1211. LCPDEBUG((LOG_WARNING, "lcp_reqci: bad CI length!n"));
  1212. orc = CONFREJ; /* Reject bad CI */
  1213. cilen = l; /* Reject till end of packet */
  1214. l = 0; /* Don't loop again */
  1215. citype = 0;
  1216. goto endswitch;
  1217. }
  1218. GETCHAR(citype, p); /* Parse CI type */
  1219. GETCHAR(cilen, p); /* Parse CI length */
  1220. l -= cilen; /* Adjust remaining length */
  1221. next += cilen; /* Step to next CI */
  1223. switch (citype) { /* Check CI type */
  1224. case CI_MRU:
  1225. if (!ao->neg_mru) { /* Allow option? */
  1226. LCPDEBUG((LOG_INFO, "lcp_reqci: Reject MRU - not allowedn"));
  1227. orc = CONFREJ; /* Reject CI */
  1228. break;
  1229. } else if (cilen != CILEN_SHORT) { /* Check CI length */
  1230. LCPDEBUG((LOG_INFO, "lcp_reqci: Reject MRU - bad lengthn"));
  1231. orc = CONFREJ; /* Reject CI */
  1232. break;
  1233. }
  1234. GETSHORT(cishort, p); /* Parse MRU */
  1236. /*
  1237.  * He must be able to receive at least our minimum.
  1238.  * No need to check a maximum.  If he sends a large number,
  1239.  * we'll just ignore it.
  1240.  */
  1241. if (cishort < PPP_MINMRU) {
  1242. LCPDEBUG((LOG_INFO, "lcp_reqci: Nak - MRU too smalln"));
  1243. orc = CONFNAK; /* Nak CI */
  1244. PUTCHAR(CI_MRU, nakp);
  1245. PUTCHAR(CILEN_SHORT, nakp);
  1246. PUTSHORT(PPP_MINMRU, nakp); /* Give him a hint */
  1247. break;
  1248. }
  1249. ho->neg_mru = 1; /* Remember he sent MRU */
  1250. ho->mru = cishort; /* And remember value */
  1251. #if TRACELCP > 0
  1252. sprintf(&traceBuf[traceNdx], " MRU %d", cishort);
  1253. traceNdx = strlen(traceBuf);
  1254. #endif
  1255. break;
  1257. case CI_ASYNCMAP:
  1258. if (!ao->neg_asyncmap) {
  1259. LCPDEBUG((LOG_INFO, "lcp_reqci: Reject ASYNCMAP not allowedn"));
  1260. orc = CONFREJ;
  1261. break;
  1262. } else if (cilen != CILEN_LONG) {
  1263. LCPDEBUG((LOG_INFO, "lcp_reqci: Reject ASYNCMAP bad lengthn"));
  1264. orc = CONFREJ;
  1265. break;
  1266. }
  1267. GETLONG(cilong, p);
  1269. /*
  1270.  * Asyncmap must have set at least the bits
  1271.  * which are set in lcp_allowoptions[unit].asyncmap.
  1272.  */
  1273. if ((ao->asyncmap & ~cilong) != 0) {
  1274. LCPDEBUG((LOG_INFO, "lcp_reqci: Nak ASYNCMAP %lX missing %lXn", 
  1275. cilong, ao->asyncmap));
  1276. orc = CONFNAK;
  1277. PUTCHAR(CI_ASYNCMAP, nakp);
  1278. PUTCHAR(CILEN_LONG, nakp);
  1279. PUTLONG(ao->asyncmap | cilong, nakp);
  1280. break;
  1281. }
  1282. ho->neg_asyncmap = 1;
  1283. ho->asyncmap = cilong;
  1284. #if TRACELCP > 0
  1285. sprintf(&traceBuf[traceNdx], " ASYNCMAP=%lX", cilong);
  1286. traceNdx = strlen(traceBuf);
  1287. #endif
  1288. break;
  1290. case CI_AUTHTYPE:
  1291. if (cilen < CILEN_SHORT) {
  1292. LCPDEBUG((LOG_INFO, "lcp_reqci: Reject AUTHTYPE missing argn"));
  1293. orc = CONFREJ;
  1294. break;
  1295. } else if (!(ao->neg_upap || ao->neg_chap)) {
  1296. /*
  1297.  * Reject the option if we're not willing to authenticate.
  1298.  */
  1299. LCPDEBUG((LOG_INFO, "lcp_reqci: Reject AUTHTYPE not allowedn"));
  1300. orc = CONFREJ;
  1301. break;
  1302. }
  1303. GETSHORT(cishort, p);
  1305. /*
  1306.  * Authtype must be UPAP or CHAP.
  1307.  *
  1308.  * Note: if both ao->neg_upap and ao->neg_chap are set,
  1309.  * and the peer sends a Configure-Request with two
  1310.  * authenticate-protocol requests, one for CHAP and one
  1311.  * for UPAP, then we will reject the second request.
  1312.  * Whether we end up doing CHAP or UPAP depends then on
  1313.  * the ordering of the CIs in the peer's Configure-Request.
  1314.  */
  1316. if (cishort == PPP_PAP) {
  1317. if (ho->neg_chap) { /* we've already accepted CHAP */
  1318. LCPDEBUG((LOG_WARNING, "lcp_reqci: Reject AUTHTYPE PAP already acceptedn"));
  1319. orc = CONFREJ;
  1320. break;
  1321. } else if (cilen != CILEN_SHORT) {
  1322. LCPDEBUG((LOG_WARNING, "lcp_reqci: Reject AUTHTYPE PAP bad lenn"));
  1323. orc = CONFREJ;
  1324. break;
  1325. }
  1326. if (!ao->neg_upap) { /* we don't want to do PAP */
  1327. LCPDEBUG((LOG_WARNING, "lcp_reqci: Nak AUTHTYPE PAP not allowedn"));
  1328. orc = CONFNAK; /* NAK it and suggest CHAP */
  1329. PUTCHAR(CI_AUTHTYPE, nakp);
  1330. PUTCHAR(CILEN_CHAP, nakp);
  1331. PUTSHORT(PPP_CHAP, nakp);
  1332. PUTCHAR(ao->chap_mdtype, nakp);
  1333. break;
  1334. }
  1335. ho->neg_upap = 1;
  1336. #if TRACELCP > 0
  1337. sprintf(&traceBuf[traceNdx], " PAP (%X)", cishort);
  1338. traceNdx = strlen(traceBuf);
  1339. #endif
  1340. break;
  1341. }
  1342. if (cishort == PPP_CHAP) {
  1343. if (ho->neg_upap) { /* we've already accepted PAP */
  1344. LCPDEBUG((LOG_WARNING, "lcp_reqci: Reject AUTHTYPE CHAP accepted PAPn"));
  1345. orc = CONFREJ;
  1346. break;
  1347. } else if (cilen != CILEN_CHAP) {
  1348. LCPDEBUG((LOG_WARNING, "lcp_reqci: Reject AUTHTYPE CHAP bad lenn"));
  1349. orc = CONFREJ;
  1350. break;
  1351. }
  1352. if (!ao->neg_chap) { /* we don't want to do CHAP */
  1353. LCPDEBUG((LOG_WARNING, "lcp_reqci: Nak AUTHTYPE CHAP not allowedn"));
  1354. orc = CONFNAK; /* NAK it and suggest PAP */
  1355. PUTCHAR(CI_AUTHTYPE, nakp);
  1356. PUTCHAR(CILEN_SHORT, nakp);
  1357. PUTSHORT(PPP_PAP, nakp);
  1358. break;
  1359. }
  1360. GETCHAR(cichar, p); /* get digest type*/
  1361. if (cichar != CHAP_DIGEST_MD5
  1362. #ifdef CHAPMS
  1363. && cichar != CHAP_MICROSOFT
  1364. #endif
  1365. ) {
  1366. LCPDEBUG((LOG_WARNING, "lcp_reqci: Nak AUTHTYPE CHAP digest=%dn", cichar));
  1367. orc = CONFNAK;
  1368. PUTCHAR(CI_AUTHTYPE, nakp);
  1369. PUTCHAR(CILEN_CHAP, nakp);
  1370. PUTSHORT(PPP_CHAP, nakp);
  1371. PUTCHAR(ao->chap_mdtype, nakp);
  1372. break;
  1373. }
  1374. #if TRACELCP > 0
  1375. sprintf(&traceBuf[traceNdx], " CHAP %X,%d", cishort, cichar);
  1376. traceNdx = strlen(traceBuf);
  1377. #endif
  1378. ho->chap_mdtype = cichar; /* save md type */
  1379. ho->neg_chap = 1;
  1380. break;
  1381. }
  1383. /*
  1384.  * We don't recognize the protocol they're asking for.
  1385.  * Nak it with something we're willing to do.
  1386.  * (At this point we know ao->neg_upap || ao->neg_chap.)
  1387.  */
  1388. orc = CONFNAK;
  1389. PUTCHAR(CI_AUTHTYPE, nakp);
  1390. if (ao->neg_chap) {
  1391. LCPDEBUG((LOG_WARNING, "lcp_reqci: Nak AUTHTYPE %d req CHAPn", cishort));
  1392. PUTCHAR(CILEN_CHAP, nakp);
  1393. PUTSHORT(PPP_CHAP, nakp);
  1394. PUTCHAR(ao->chap_mdtype, nakp);
  1395. } 
  1396. else {
  1397. LCPDEBUG((LOG_WARNING, "lcp_reqci: Nak AUTHTYPE %d req PAPn", cishort));
  1398. PUTCHAR(CILEN_SHORT, nakp);
  1399. PUTSHORT(PPP_PAP, nakp);
  1400. }
  1401. break;
  1403. case CI_QUALITY:
  1404. GETSHORT(cishort, p);
  1405. GETLONG(cilong, p);
  1406. #if TRACELCP > 0
  1407. sprintf(&traceBuf[traceNdx], " QUALITY (%x %x)", cishort, (unsigned int) cilong);
  1408. traceNdx = strlen(traceBuf);
  1409. #endif
  1411. if (!ao->neg_lqr ||
  1412. cilen != CILEN_LQR) {
  1413. orc = CONFREJ;
  1414. break;
  1415. }
  1417. /*
  1418.  * Check the protocol and the reporting period.
  1419.  * XXX When should we Nak this, and what with?
  1420.  */
  1421. if (cishort != PPP_LQR) {
  1422. orc = CONFNAK;
  1423. PUTCHAR(CI_QUALITY, nakp);
  1424. PUTCHAR(CILEN_LQR, nakp);
  1425. PUTSHORT(PPP_LQR, nakp);
  1426. PUTLONG(ao->lqr_period, nakp);
  1427. break;
  1428. }
  1429. break;
  1431. case CI_MAGICNUMBER:
  1432. if (!(ao->neg_magicnumber || go->neg_magicnumber) ||
  1433. cilen != CILEN_LONG) {
  1434. orc = CONFREJ;
  1435. break;
  1436. }
  1437. GETLONG(cilong, p);
  1438. #if TRACELCP > 0
  1439. sprintf(&traceBuf[traceNdx], " MAGICNUMBER (%lX)", cilong);
  1440. traceNdx = strlen(traceBuf);
  1441. #endif
  1443. /*
  1444.  * He must have a different magic number.
  1445.  */
  1446. if (go->neg_magicnumber &&
  1447. cilong == go->magicnumber) {
  1448. cilong = magic(); /* Don't put magic() inside macro! */
  1449. orc = CONFNAK;
  1450. PUTCHAR(CI_MAGICNUMBER, nakp);
  1451. PUTCHAR(CILEN_LONG, nakp);
  1452. PUTLONG(cilong, nakp);
  1453. break;
  1454. }
  1455. ho->neg_magicnumber = 1;
  1456. ho->magicnumber = cilong;
  1457. break;
  1460. case CI_PCOMPRESSION:
  1461. #if TRACELCP > 0
  1462. sprintf(&traceBuf[traceNdx], " PCOMPRESSION");
  1463. traceNdx = strlen(traceBuf);
  1464. #endif
  1465. if (!ao->neg_pcompression ||
  1466. cilen != CILEN_VOID) {
  1467. orc = CONFREJ;
  1468. break;
  1469. }
  1470. ho->neg_pcompression = 1;
  1471. break;
  1473. case CI_ACCOMPRESSION:
  1474. #if TRACELCP > 0
  1475. sprintf(&traceBuf[traceNdx], " ACCOMPRESSION");
  1476. traceNdx = strlen(traceBuf);
  1477. #endif
  1478. if (!ao->neg_accompression ||
  1479. cilen != CILEN_VOID) {
  1480. orc = CONFREJ;
  1481. break;
  1482. }
  1483. ho->neg_accompression = 1;
  1484. break;
  1486. case CI_MRRU:
  1487. #if TRACELCP > 0
  1488. sprintf(&traceBuf[traceNdx], " CI_MRRU");
  1489. traceNdx = strlen(traceBuf);
  1490. #endif
  1491. orc = CONFREJ;
  1492. break;
  1494. case CI_SSNHF:
  1495. #if TRACELCP > 0
  1496. sprintf(&traceBuf[traceNdx], " CI_SSNHF");
  1497. traceNdx = strlen(traceBuf);
  1498. #endif
  1499. orc = CONFREJ;
  1500. break;
  1502. case CI_EPDISC:
  1503. #if TRACELCP > 0
  1504. sprintf(&traceBuf[traceNdx], " CI_EPDISC");
  1505. traceNdx = strlen(traceBuf);
  1506. #endif
  1507. orc = CONFREJ;
  1508. break;
  1510. default:
  1511. #if TRACELCP
  1512. sprintf(&traceBuf[traceNdx], " unknown %d", citype);
  1513. traceNdx = strlen(traceBuf);
  1514. #endif
  1515. orc = CONFREJ;
  1516. break;
  1517. }
  1519. endswitch:
  1520. #if TRACELCP
  1521. if (traceNdx >= 80 - 32) {
  1522. LCPDEBUG((LOG_INFO, "lcp_reqci: rcvd%sn", traceBuf));
  1523. traceNdx = 0;
  1524. }
  1525. #endif
  1526. if (orc == CONFACK && /* Good CI */
  1527. rc != CONFACK) /*  but prior CI wasnt? */
  1528. continue; /* Don't send this one */
  1530. if (orc == CONFNAK) { /* Nak this CI? */
  1531. if (reject_if_disagree /* Getting fed up with sending NAKs? */
  1532. && citype != CI_MAGICNUMBER) {
  1533. orc = CONFREJ; /* Get tough if so */
  1534. } 
  1535. else {
  1536. if (rc == CONFREJ) /* Rejecting prior CI? */
  1537. continue; /* Don't send this one */
  1538. rc = CONFNAK;
  1539. }
  1540. }
  1541. if (orc == CONFREJ) { /* Reject this CI */
  1542. rc = CONFREJ;
  1543. if (cip != rejp) /* Need to move rejected CI? */
  1544. BCOPY(cip, rejp, cilen); /* Move it */
  1545. INCPTR(cilen, rejp); /* Update output pointer */
  1546. }
  1547. }
  1549. /*
  1550.  * If we wanted to send additional NAKs (for unsent CIs), the
  1551.  * code would go here.  The extra NAKs would go at *nakp.
  1552.  * At present there are no cases where we want to ask the
  1553.  * peer to negotiate an option.
  1554.  */
  1556. switch (rc) {
  1557. case CONFACK:
  1558. *lenp = (int)(next - inp);
  1559. break;
  1560. case CONFNAK:
  1561. /*
  1562.  * Copy the Nak'd options from the nak_buffer to the caller's buffer.
  1563.  */
  1564. *lenp = (int)(nakp - nak_buffer);
  1565. BCOPY(nak_buffer, inp, *lenp);
  1566. break;
  1567. case CONFREJ:
  1568. *lenp = (int)(rejp - inp);
  1569. break;
  1570. }
  1572. #if TRACELCP > 0
  1573. if (traceNdx > 0) {
  1574. LCPDEBUG((LOG_INFO, "lcp_reqci: %sn", traceBuf));
  1575. }
  1576. #endif
  1577. LCPDEBUG((LOG_INFO, "lcp_reqci: returning CONF%s.n", CODENAME(rc)));
  1578. return (rc); /* Return final code */
  1579. }
  1582. /*
  1583.  * lcp_up - LCP has come UP.
  1584.  */
  1585. static void lcp_up(fsm *f)
  1586. {
  1588. lcp_options *wo = &lcp_wantoptions[f->unit];
  1589. lcp_options *ho = &lcp_hisoptions[f->unit];
  1590. lcp_options *go = &lcp_gotoptions[f->unit];
  1591. lcp_options *ao = &lcp_allowoptions[f->unit];
  1593. DEBUG_FUNCTION("lcp_up()");
  1595. if (!go->neg_magicnumber)
  1596. go->magicnumber = 0;
  1597. if (!ho->neg_magicnumber)
  1598. ho->magicnumber = 0;
  1600. /*
  1601. * Set our MTU to the smaller of the MTU we wanted and
  1602. * the MRU our peer wanted.  If we negotiated an MRU,
  1603. * set our MRU to the larger of value we wanted and
  1604. * the value we got in the negotiation.
  1605. */
  1606. ppp_send_config(f->unit, LWIP_MIN(ao->mru, (ho->neg_mru? ho->mru: PPP_MRU)),
  1607. (ho->neg_asyncmap? ho->asyncmap: 0xffffffffl),
  1608. ho->neg_pcompression, ho->neg_accompression);
  1609. /*
  1610. * If the asyncmap hasn't been negotiated, we really should
  1611. * set the receive asyncmap to ffffffff, but we set it to 0
  1612. * for backwards contemptibility.
  1613. */
  1614. ppp_recv_config(f->unit, (go->neg_mru? LWIP_MAX(wo->mru, go->mru): PPP_MRU),
  1615. (go->neg_asyncmap? go->asyncmap: 0x00000000),
  1616. go->neg_pcompression, go->neg_accompression);
  1618. if (ho->neg_mru)
  1619. peer_mru[f->unit] = ho->mru;
  1621. lcp_echo_lowerup(f->unit);  /* Enable echo messages */
  1623. link_established(f->unit);
  1624. }
  1627. /*
  1628.  * lcp_down - LCP has gone DOWN.
  1629.  *
  1630.  * Alert other protocols.
  1631.  */
  1632. static void lcp_down(fsm *f)
  1633. {
  1634. lcp_options *go = &lcp_gotoptions[f->unit];
  1636. lcp_echo_lowerdown(f->unit);
  1638. link_down(f->unit);
  1640. ppp_send_config(f->unit, PPP_MRU, 0xffffffffl, 0, 0);
  1641. ppp_recv_config(f->unit, PPP_MRU,
  1642. (go->neg_asyncmap? go->asyncmap: 0x00000000),
  1643. go->neg_pcompression, go->neg_accompression);
  1644. peer_mru[f->unit] = PPP_MRU;
  1645. }
  1648. /*
  1649.  * lcp_starting - LCP needs the lower layer up.
  1650.  */
  1651. static void lcp_starting(fsm *f)
  1652. {
  1653. link_required(f->unit);
  1654. }
  1657. /*
  1658.  * lcp_finished - LCP has finished with the lower layer.
  1659.  */
  1660. static void lcp_finished(fsm *f)
  1661. {
  1662. link_terminated(f->unit);
  1663. }
  1666. #if 0
  1667. /*
  1668.  * print_string - print a readable representation of a string using
  1669.  * printer.
  1670.  */
  1671. static void print_string(
  1672.     char *p,
  1673.     int len,
  1674.     void (*printer) (void *, char *, ...),
  1675.     void *arg
  1676. )
  1677. {
  1678.     int c;
  1679.     
  1680.     printer(arg, """);
  1681.     for (; len > 0; --len) {
  1682.         c = *p++;
  1683.         if (' ' <= c && c <= '~') {
  1684.             if (c == '\' || c == '"')
  1685.                 printer(arg, "\");
  1686.             printer(arg, "%c", c);
  1687.         } else {
  1688.             switch (c) {
  1689.             case 'n':
  1690.                 printer(arg, "\n");
  1691.                 break;
  1692.             case 'r':
  1693.                 printer(arg, "\r");
  1694.                 break;
  1695.             case 't':
  1696.                 printer(arg, "\t");
  1697.                 break;
  1698.             default:
  1699.                 printer(arg, "\%.3o", c);
  1700.             }
  1701.         }
  1702.     }
  1703.     printer(arg, """);
  1704. }
  1707. /*
  1708.  * lcp_printpkt - print the contents of an LCP packet.
  1709.  */
  1710. static char *lcp_codenames[] = {
  1711. "ConfReq", "ConfAck", "ConfNak", "ConfRej",
  1712. "TermReq", "TermAck", "CodeRej", "ProtRej",
  1713. "EchoReq", "EchoRep", "DiscReq"
  1714. };
  1716. static int lcp_printpkt(
  1717. u_char *p,
  1718. int plen,
  1719. void (*printer) (void *, char *, ...),
  1720. void *arg
  1721. )
  1722. {
  1723. int code, id, len, olen;
  1724. u_char *pstart, *optend;
  1725. u_short cishort;
  1726. u32_t cilong;
  1728. if (plen < HEADERLEN)
  1729. return 0;
  1730. pstart = p;
  1731. GETCHAR(code, p);
  1732. GETCHAR(id, p);
  1733. GETSHORT(len, p);
  1734. if (len < HEADERLEN || len > plen)
  1735. return 0;
  1737. if (code >= 1 && code <= sizeof(lcp_codenames) / sizeof(char *))
  1738. printer(arg, " %s", lcp_codenames[code-1]);
  1739. else
  1740. printer(arg, " code=0x%x", code);
  1741. printer(arg, " id=0x%x", id);
  1742. len -= HEADERLEN;
  1743. switch (code) {
  1744. case CONFREQ:
  1745. case CONFACK:
  1746. case CONFNAK:
  1747. case CONFREJ:
  1748. /* print option list */
  1749. while (len >= 2) {
  1750. GETCHAR(code, p);
  1751. GETCHAR(olen, p);
  1752. p -= 2;
  1753. if (olen < 2 || olen > len) {
  1754. break;
  1755. }
  1756. printer(arg, " <");
  1757. len -= olen;
  1758. optend = p + olen;
  1759. switch (code) {
  1760. case CI_MRU:
  1761. if (olen == CILEN_SHORT) {
  1762. p += 2;
  1763. GETSHORT(cishort, p);
  1764. printer(arg, "mru %d", cishort);
  1765. }
  1766. break;
  1767. case CI_ASYNCMAP:
  1768. if (olen == CILEN_LONG) {
  1769. p += 2;
  1770. GETLONG(cilong, p);
  1771. printer(arg, "asyncmap 0x%lx", cilong);
  1772. }
  1773. break;
  1774. case CI_AUTHTYPE:
  1775. if (olen >= CILEN_SHORT) {
  1776. p += 2;
  1777. printer(arg, "auth ");
  1778. GETSHORT(cishort, p);
  1779. switch (cishort) {
  1780. case PPP_PAP:
  1781. printer(arg, "pap");
  1782. break;
  1783. case PPP_CHAP:
  1784. printer(arg, "chap");
  1785. break;
  1786. default:
  1787. printer(arg, "0x%x", cishort);
  1788. }
  1789. }
  1790. break;
  1791. case CI_QUALITY:
  1792. if (olen >= CILEN_SHORT) {
  1793. p += 2;
  1794. printer(arg, "quality ");
  1795. GETSHORT(cishort, p);
  1796. switch (cishort) {
  1797. case PPP_LQR:
  1798. printer(arg, "lqr");
  1799. break;
  1800. default:
  1801. printer(arg, "0x%x", cishort);
  1802. }
  1803. }
  1804. break;
  1805. case CI_CALLBACK:
  1806. if (olen >= CILEN_CHAR) {
  1807. p += 2;
  1808. printer(arg, "callback ");
  1809. GETSHORT(cishort, p);
  1810. switch (cishort) {
  1811. case CBCP_OPT:
  1812. printer(arg, "CBCP");
  1813. break;
  1814. default:
  1815. printer(arg, "0x%x", cishort);
  1816. }
  1817. }
  1818. break;
  1819. case CI_MAGICNUMBER:
  1820. if (olen == CILEN_LONG) {
  1821. p += 2;
  1822. GETLONG(cilong, p);
  1823. printer(arg, "magic 0x%x", cilong);
  1824. }
  1825. break;
  1826. case CI_PCOMPRESSION:
  1827. if (olen == CILEN_VOID) {
  1828. p += 2;
  1829. printer(arg, "pcomp");
  1830. }
  1831. break;
  1832. case CI_ACCOMPRESSION:
  1833. if (olen == CILEN_VOID) {
  1834. p += 2;
  1835. printer(arg, "accomp");
  1836. }
  1837. break;
  1838. }
  1839. while (p < optend) {
  1840. GETCHAR(code, p);
  1841. printer(arg, " %.2x", code);
  1842. }
  1843. printer(arg, ">");
  1844. }
  1845. break;
  1847. case TERMACK:
  1848. case TERMREQ:
  1849. if (len > 0 && *p >= ' ' && *p < 0x7f) {
  1850. printer(arg, " ");
  1851. print_string((char*)p, len, printer, arg);
  1852. p += len;
  1853. len = 0;
  1854. }
  1855. break;
  1857. case ECHOREQ:
  1858. case ECHOREP:
  1859. case DISCREQ:
  1860. if (len >= 4) {
  1861. GETLONG(cilong, p);
  1862. printer(arg, " magic=0x%x", cilong);
  1863. p += 4;
  1864. len -= 4;
  1865. }
  1866. break;
  1867. }
  1869. /* print the rest of the bytes in the packet */
  1870. for (; len > 0; --len) {
  1871. GETCHAR(code, p);
  1872. printer(arg, " %.2x", code);
  1873. }
  1875. return (int)(p - pstart);
  1876. }
  1877. #endif
  1879. /*
  1880.  * Time to shut down the link because there is nothing out there.
  1881.  */
  1883. static void LcpLinkFailure (fsm *f)
  1884. {
  1885. if (f->state == OPENED) {
  1886. LCPDEBUG((LOG_INFO, "No response to %d echo-requestsn", lcp_echos_pending));
  1887. LCPDEBUG((LOG_NOTICE, "Serial link appears to be disconnected.n"));
  1888. lcp_close(f->unit, "Peer not responding");
  1889. }
  1890. }
  1892. /*
  1893.  * Timer expired for the LCP echo requests from this process.
  1894.  */
  1896. static void LcpEchoCheck (fsm *f)
  1897. {
  1898. LcpSendEchoRequest (f);
  1900. /*
  1901.  * Start the timer for the next interval.
  1902.  */
  1903. LWIP_ASSERT("lcp_echo_timer_running == 0", lcp_echo_timer_running == 0);
  1905. TIMEOUT (LcpEchoTimeout, f, lcp_echo_interval);
  1906. lcp_echo_timer_running = 1;
  1907. }
  1909. /*
  1910.  * LcpEchoTimeout - Timer expired on the LCP echo
  1911.  */
  1913. static void LcpEchoTimeout (void *arg)
  1914. {
  1915. if (lcp_echo_timer_running != 0) {
  1916. lcp_echo_timer_running = 0;
  1917. LcpEchoCheck ((fsm *) arg);
  1918. }
  1919. }
  1921. /*
  1922.  * LcpEchoReply - LCP has received a reply to the echo
  1923.  */
  1924. static void lcp_received_echo_reply (fsm *f, int id, u_char *inp, int len)
  1925. {
  1926. u32_t magic;
  1928. (void)id;
  1930. /* Check the magic number - don't count replies from ourselves. */
  1931. if (len < 4) {
  1932. LCPDEBUG((LOG_WARNING, "lcp: received short Echo-Reply, length %dn", len));
  1933. return;
  1934. }
  1935. GETLONG(magic, inp);
  1936. if (lcp_gotoptions[f->unit].neg_magicnumber
  1937. && magic == lcp_gotoptions[f->unit].magicnumber) {
  1938. LCPDEBUG((LOG_WARNING, "appear to have received our own echo-reply!n"));
  1939. return;
  1940. }
  1942. /* Reset the number of outstanding echo frames */
  1943. lcp_echos_pending = 0;
  1944. }
  1946. /*
  1947.  * LcpSendEchoRequest - Send an echo request frame to the peer
  1948.  */
  1950. static void LcpSendEchoRequest (fsm *f)
  1951. {
  1952. u32_t lcp_magic;
  1953. u_char pkt[4], *pktp;
  1955. /*
  1956. * Detect the failure of the peer at this point.
  1957. */
  1958. if (lcp_echo_fails != 0) {
  1959. if (lcp_echos_pending++ >= lcp_echo_fails) {
  1960. LcpLinkFailure(f);
  1961. lcp_echos_pending = 0;
  1962. }
  1963. }
  1965. /*
  1966. * Make and send the echo request frame.
  1967. */
  1968. if (f->state == OPENED) {
  1969. lcp_magic = lcp_gotoptions[f->unit].magicnumber;
  1970. pktp = pkt;
  1971. PUTLONG(lcp_magic, pktp);
  1972. fsm_sdata(f, ECHOREQ, (u_char)(lcp_echo_number++ & 0xFF), pkt, (int)(pktp - pkt));
  1973. }
  1974. }
  1976. /*
  1977.  * lcp_echo_lowerup - Start the timer for the LCP frame
  1978.  */
  1980. static void lcp_echo_lowerup (int unit)
  1981. {
  1982. fsm *f = &lcp_fsm[unit];
  1984. /* Clear the parameters for generating echo frames */
  1985. lcp_echos_pending      = 0;
  1986. lcp_echo_number        = 0;
  1987. lcp_echo_timer_running = 0;
  1989. /* If a timeout interval is specified then start the timer */
  1990. if (lcp_echo_interval != 0)
  1991. LcpEchoCheck (f);
  1992. }
  1994. /*
  1995.  * lcp_echo_lowerdown - Stop the timer for the LCP frame
  1996.  */
  1998. static void lcp_echo_lowerdown (int unit)
  1999. {
  2000. fsm *f = &lcp_fsm[unit];
  2002. if (lcp_echo_timer_running != 0) {
  2003. UNTIMEOUT (LcpEchoTimeout, f);
  2004. lcp_echo_timer_running = 0;
  2005. }
  2006. }
  2008. #endif /* PPP_SUPPORT */