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

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

嵌入式/单片机编程

开发平台：

C/C++

fsm.c：源码内容
  1. /*****************************************************************************
  2. * fsm.c - Network Control Protocol Finite State Machine 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 based on BSD fsm.c.
  32. *****************************************************************************/
  33. /*
  34.  * fsm.c - {Link, IP} Control Protocol Finite State Machine.
  35.  *
  36.  * Copyright (c) 1989 Carnegie Mellon University.
  37.  * All rights reserved.
  38.  *
  39.  * Redistribution and use in source and binary forms are permitted
  40.  * provided that the above copyright notice and this paragraph are
  41.  * duplicated in all such forms and that any documentation,
  42.  * advertising materials, and other materials related to such
  43.  * distribution and use acknowledge that the software was developed
  44.  * by Carnegie Mellon University.  The name of the
  45.  * University may not be used to endorse or promote products derived
  46.  * from this software without specific prior written permission.
  47.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  48.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  49.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  50.  */
  53. /*
  54.  * TODO:
  55.  * Randomize fsm id on link/init.
  56.  * Deal with variable outgoing MTU.
  57.  */
  59. #include "ppp.h"
  60. #if PPP_SUPPORT > 0
  61. #include "fsm.h"
  62. #include "pppdebug.h"
  65. #include "timer.h"
  66. #include "uart.h"
  68. /*************************/
  69. /*** LOCAL DEFINITIONS ***/
  70. /*************************/
  73. /************************/
  74. /*** LOCAL DATA TYPES ***/
  75. /************************/
  78. /***********************************/
  79. /*** LOCAL FUNCTION DECLARATIONS ***/
  80. /***********************************/
  81. static void fsm_timeout (void *);
  82. static void fsm_rconfreq (fsm *, u_char, u_char *, int);
  83. static void fsm_rconfack (fsm *, int, u_char *, int);
  84. static void fsm_rconfnakrej (fsm *, int, int, u_char *, int);
  85. static void fsm_rtermreq (fsm *, int, u_char *, int);
  86. static void fsm_rtermack (fsm *);
  87. static void fsm_rcoderej (fsm *, u_char *, int);
  88. static void fsm_sconfreq (fsm *, int);
  90. #define PROTO_NAME(f) ((f)->callbacks->proto_name)
  93. /******************************/
  94. /*** PUBLIC DATA STRUCTURES ***/
  95. /******************************/
  98. /*****************************/
  99. /*** LOCAL DATA STRUCTURES ***/
  100. /*****************************/
  101. int peer_mru[NUM_PPP];
  104. /***********************************/
  105. /*** PUBLIC FUNCTION DEFINITIONS ***/
  106. /***********************************/
  108. /*
  109.  * fsm_init - Initialize fsm.
  110.  *
  111.  * Initialize fsm state.
  112.  */
  113. void fsm_init(fsm *f)
  114. {
  115. f->state = INITIAL;
  116. f->flags = 0;
  117. f->id = 0; /* XXX Start with random id? */
  118. f->timeouttime = FSM_DEFTIMEOUT;
  119. f->maxconfreqtransmits = FSM_DEFMAXCONFREQS;
  120. f->maxtermtransmits = FSM_DEFMAXTERMREQS;
  121. f->maxnakloops = FSM_DEFMAXNAKLOOPS;
  122. f->term_reason_len = 0;
  123. }
  126. /*
  127.  * fsm_lowerup - The lower layer is up.
  128.  */
  129. void fsm_lowerup(fsm *f)
  130. {
  131. int oldState = f->state;
  133. switch( f->state ){
  134. case INITIAL:
  135. f->state = CLOSED;
  136. break;
  138. case STARTING:
  139. if( f->flags & OPT_SILENT )
  140. f->state = STOPPED;
  141. else {
  142. /* Send an initial configure-request */
  143. fsm_sconfreq(f, 0);
  144. f->state = REQSENT;
  145. }
  146. break;
  148. default:
  149. FSMDEBUG((LOG_INFO, "%s: Up event in state %d!n",
  150. PROTO_NAME(f), f->state));
  151. }
  153. FSMDEBUG((LOG_INFO, "%s: lowerup state %d -> %dn",
  154. PROTO_NAME(f), oldState, f->state));
  155. }
  158. /*
  159.  * fsm_lowerdown - The lower layer is down.
  160.  *
  161.  * Cancel all timeouts and inform upper layers.
  162.  */
  163. void fsm_lowerdown(fsm *f)
  164. {
  165. int oldState = f->state;
  167. switch( f->state ){
  168. case CLOSED:
  169. f->state = INITIAL;
  170. break;
  172. case STOPPED:
  173. f->state = STARTING;
  174. if( f->callbacks->starting )
  175. (*f->callbacks->starting)(f);
  176. break;
  178. case CLOSING:
  179. f->state = INITIAL;
  180. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  181. break;
  183. case STOPPING:
  184. case REQSENT:
  185. case ACKRCVD:
  186. case ACKSENT:
  187. f->state = STARTING;
  188. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  189. break;
  191. case OPENED:
  192. if( f->callbacks->down )
  193. (*f->callbacks->down)(f);
  194. f->state = STARTING;
  195. break;
  197. default:
  198. FSMDEBUG((LOG_INFO, "%s: Down event in state %d!n",
  199. PROTO_NAME(f), f->state));
  200. }
  202. FSMDEBUG((LOG_INFO, "%s: lowerdown state %d -> %dn",
  203. PROTO_NAME(f), oldState, f->state));
  204. }
  207. /*
  208.  * fsm_open - Link is allowed to come up.
  209.  */
  210. void fsm_open(fsm *f)
  211. {
  212. int oldState = f->state;
  214. switch( f->state ){
  215. case INITIAL:
  216. f->state = STARTING;
  217. if( f->callbacks->starting )
  218. (*f->callbacks->starting)(f);
  219. break;
  221. case CLOSED:
  222. if( f->flags & OPT_SILENT )
  223. f->state = STOPPED;
  224. else {
  225. /* Send an initial configure-request */
  226. fsm_sconfreq(f, 0);
  227. f->state = REQSENT;
  228. }
  229. break;
  231. case CLOSING:
  232. f->state = STOPPING;
  233. /* fall through */
  234. case STOPPED:
  235. case OPENED:
  236. if( f->flags & OPT_RESTART ){
  237. fsm_lowerdown(f);
  238. fsm_lowerup(f);
  239. }
  240. break;
  241. }
  243. FSMDEBUG((LOG_INFO, "%s: open state %d -> %dn",
  244. PROTO_NAME(f), oldState, f->state));
  245. }
  248. /*
  249.  * fsm_close - Start closing connection.
  250.  *
  251.  * Cancel timeouts and either initiate close or possibly go directly to
  252.  * the CLOSED state.
  253.  */
  254. void fsm_close(fsm *f, char *reason)
  255. {
  256. int oldState = f->state;
  258. f->term_reason = reason;
  259. f->term_reason_len = (reason == NULL? 0: strlen(reason));
  260. switch( f->state ){
  261. case STARTING:
  262. f->state = INITIAL;
  263. break;
  264. case STOPPED:
  265. f->state = CLOSED;
  266. break;
  267. case STOPPING:
  268. f->state = CLOSING;
  269. break;
  271. case REQSENT:
  272. case ACKRCVD:
  273. case ACKSENT:
  274. case OPENED:
  275. if( f->state != OPENED )
  276. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  277. else if( f->callbacks->down )
  278. (*f->callbacks->down)(f); /* Inform upper layers we're down */
  280. /* Init restart counter, send Terminate-Request */
  281. f->retransmits = f->maxtermtransmits;
  282. fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
  283. (u_char *) f->term_reason, f->term_reason_len);
  284. TIMEOUT(fsm_timeout, f, f->timeouttime);
  285. --f->retransmits;
  287. f->state = CLOSING;
  288. break;
  289. }
  291. FSMDEBUG((LOG_INFO, "%s: close reason=%s state %d -> %dn",
  292. PROTO_NAME(f), reason, oldState, f->state));
  293. }
  296. /*
  297.  * fsm_sdata - Send some data.
  298.  *
  299.  * Used for all packets sent to our peer by this module.
  300.  */
  301. void fsm_sdata(
  302. fsm *f,
  303. u_char code, 
  304. u_char id,
  305. u_char *data,
  306. int datalen
  307. )
  308. {
  309. u_char *outp;
  310. int outlen;
  312. /* Adjust length to be smaller than MTU */
  313. outp = outpacket_buf[f->unit];
  314. if (datalen > peer_mru[f->unit] - (int)HEADERLEN)
  315. datalen = peer_mru[f->unit] - HEADERLEN;
  316. if (datalen && data != outp + PPP_HDRLEN + HEADERLEN)
  317. BCOPY(data, outp + PPP_HDRLEN + HEADERLEN, datalen);
  318. outlen = datalen + HEADERLEN;
  319. MAKEHEADER(outp, f->protocol);
  320. PUTCHAR(code, outp);
  321. PUTCHAR(id, outp);
  322. PUTSHORT(outlen, outp);
  323. pppWrite(f->unit, outpacket_buf[f->unit], outlen + PPP_HDRLEN);
  324. FSMDEBUG((LOG_INFO, "fsm_sdata(%s): Sent code %d,%d,%d.n",
  325. PROTO_NAME(f), code, id, outlen));
  326. }
  329. /*
  330.  * fsm_input - Input packet.
  331.  */
  332. void fsm_input(fsm *f, u_char *inpacket, int l)
  333. {
  334. u_char *inp = inpacket;
  335. u_char code, id;
  336. int len;
  338. /*
  339. * Parse header (code, id and length).
  340. * If packet too short, drop it.
  341. */
  342. if (l < HEADERLEN) {
  343. FSMDEBUG((LOG_WARNING, "fsm_input(%x): Rcvd short header.n",
  344. f->protocol));
  345. return;
  346. }
  347. GETCHAR(code, inp);
  348. GETCHAR(id, inp);
  349. GETSHORT(len, inp);
  350. if (len < HEADERLEN) {
  351. FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd illegal length.n",
  352. f->protocol));
  353. return;
  354. }
  355. if (len > l) {
  356. FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd short packet.n",
  357. f->protocol));
  358. return;
  359. }
  360. len -= HEADERLEN; /* subtract header length */
  362. if( f->state == INITIAL || f->state == STARTING ){
  363. FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd packet in state %d.n",
  364. f->protocol, f->state));
  365. return;
  366. }
  367. FSMDEBUG((LOG_INFO, "fsm_input(%s):%d,%d,%dn", PROTO_NAME(f), code, id, l));
  368. /*
  369.  * Action depends on code.
  370.  */
  371. switch (code) {
  372. case CONFREQ:
  373. fsm_rconfreq(f, id, inp, len);
  374. break;
  376. case CONFACK:
  377. fsm_rconfack(f, id, inp, len);
  378. break;
  380. case CONFNAK:
  381. case CONFREJ:
  382. fsm_rconfnakrej(f, code, id, inp, len);
  383. break;
  385. case TERMREQ:
  386. fsm_rtermreq(f, id, inp, len);
  387. break;
  389. case TERMACK:
  390. fsm_rtermack(f);
  391. break;
  393. case CODEREJ:
  394. fsm_rcoderej(f, inp, len);
  395. break;
  397. default:
  398. if( !f->callbacks->extcode
  399. || !(*f->callbacks->extcode)(f, code, id, inp, len) )
  400. fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN);
  401. break;
  402. }
  403. }
  406. /*
  407.  * fsm_protreject - Peer doesn't speak this protocol.
  408.  *
  409.  * Treat this as a catastrophic error (RXJ-).
  410.  */
  411. void fsm_protreject(fsm *f)
  412. {
  413. switch( f->state ){
  414. case CLOSING:
  415. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  416. /* fall through */
  417. case CLOSED:
  418. f->state = CLOSED;
  419. if( f->callbacks->finished )
  420. (*f->callbacks->finished)(f);
  421. break;
  423. case STOPPING:
  424. case REQSENT:
  425. case ACKRCVD:
  426. case ACKSENT:
  427. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  428. /* fall through */
  429. case STOPPED:
  430. f->state = STOPPED;
  431. if( f->callbacks->finished )
  432. (*f->callbacks->finished)(f);
  433. break;
  435. case OPENED:
  436. if( f->callbacks->down )
  437. (*f->callbacks->down)(f);
  439. /* Init restart counter, send Terminate-Request */
  440. f->retransmits = f->maxtermtransmits;
  441. fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
  442. (u_char *) f->term_reason, f->term_reason_len);
  443. TIMEOUT(fsm_timeout, f, f->timeouttime);
  444. --f->retransmits;
  446. f->state = STOPPING;
  447. break;
  449. default:
  450. FSMDEBUG((LOG_INFO, "%s: Protocol-reject event in state %d!n",
  451. PROTO_NAME(f), f->state));
  452. }
  453. }
  459. /**********************************/
  460. /*** LOCAL FUNCTION DEFINITIONS ***/
  461. /**********************************/
  463. /*
  464.  * fsm_timeout - Timeout expired.
  465.  */
  466. static void fsm_timeout(void *arg)
  467. {
  468.     fsm *f = (fsm *) arg;
  470.    DEBUG_FUNCTION(" fsm_timeout()")
  471.     switch (f->state) {
  472.     case CLOSING:
  473.     case STOPPING:
  474. if( f->retransmits <= 0 ){
  475.     FSMDEBUG((LOG_WARNING, "%s: timeout sending Terminate-Request state=%dn",
  476.    PROTO_NAME(f), f->state));
  477.     /*
  478.      * We've waited for an ack long enough.  Peer probably heard us.
  479.      */
  480.     f->state = (f->state == CLOSING)? CLOSED: STOPPED;
  481.     if( f->callbacks->finished )
  482. (*f->callbacks->finished)(f);
  484.  /*
  485.          *added by zhouzhigang 2006.01.22 to delete lcp timer
  486.   */
  487.         UNTIMEOUT(fsm_timeout, f);
  488. } else {
  489.     FSMDEBUG((LOG_WARNING, "%s: timeout resending Terminate-Requests state=%dn",
  490.    PROTO_NAME(f), f->state));
  491.     /* Send Terminate-Request */
  492.     fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
  493.       (u_char *) f->term_reason, f->term_reason_len);
  494.     TIMEOUT(fsm_timeout, f, f->timeouttime);
  495.     --f->retransmits;
  496. }
  497. break;
  499.     case REQSENT:
  500.     case ACKRCVD:
  501.     case ACKSENT:
  502. if (f->retransmits <= 0) {
  503.     FSMDEBUG((LOG_WARNING, "%s: timeout sending Config-Requests state=%dn",
  504.    PROTO_NAME(f), f->state));
  505.     f->state = STOPPED;
  506.     if( (f->flags & OPT_PASSIVE) == 0 && f->callbacks->finished )
  507. (*f->callbacks->finished)(f);
  509.  /*
  510.    *added by zhouzhigang 2006.01.22 to delete lcp timer
  511.          */
  512. UNTIMEOUT(fsm_timeout, f);
  514. } else {
  515.     FSMDEBUG((LOG_WARNING, "%s: timeout resending Config-Request state=%dn",
  516.    PROTO_NAME(f), f->state));
  517.     /* Retransmit the configure-request */
  518.     if (f->callbacks->retransmit)
  519. (*f->callbacks->retransmit)(f);
  520.     fsm_sconfreq(f, 1); /* Re-send Configure-Request */
  521.     if( f->state == ACKRCVD )
  522. f->state = REQSENT;
  523. }
  524. break;
  526.     default:
  527. FSMDEBUG((LOG_INFO, "%s: Timeout event in state %d!n",
  528.   PROTO_NAME(f), f->state));
  530.  /*
  531.           *added by zhouzhigang 2006.01.22 to delete lcp timer
  532.  */
  533.         UNTIMEOUT(fsm_timeout, f);
  534.     }
  535. }
  538. /*
  539.  * fsm_rconfreq - Receive Configure-Request.
  540.  */
  541. static void fsm_rconfreq(fsm *f, u_char id, u_char *inp, int len)
  542. {
  543. int code, reject_if_disagree;
  545. FSMDEBUG((LOG_INFO, "fsm_rconfreq(%s): Rcvd id %d state=%dn", 
  546. PROTO_NAME(f), id, f->state));
  547. switch( f->state ){
  548. case CLOSED:
  549. /* Go away, we're closed */
  550. fsm_sdata(f, TERMACK, id, NULL, 0);
  551. return;
  552. case CLOSING:
  553. case STOPPING:
  554. return;
  556. case OPENED:
  557. /* Go down and restart negotiation */
  558. if( f->callbacks->down )
  559. (*f->callbacks->down)(f); /* Inform upper layers */
  560. fsm_sconfreq(f, 0); /* Send initial Configure-Request */
  561. break;
  563. case STOPPED:
  564. /* Negotiation started by our peer */
  565. fsm_sconfreq(f, 0); /* Send initial Configure-Request */
  566. f->state = REQSENT;
  567. break;
  568. }
  570. /*
  571. * Pass the requested configuration options
  572. * to protocol-specific code for checking.
  573. */
  574. if (f->callbacks->reqci){ /* Check CI */
  575. reject_if_disagree = (f->nakloops >= f->maxnakloops);
  576. code = (*f->callbacks->reqci)(f, inp, &len, reject_if_disagree);
  577. } 
  578. else if (len)
  579. code = CONFREJ; /* Reject all CI */
  580. else
  581. code = CONFACK;
  583. /* send the Ack, Nak or Rej to the peer */
  584. fsm_sdata(f, (u_char)code, id, inp, len);
  586. if (code == CONFACK) {
  587. if (f->state == ACKRCVD) {
  588. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  589. f->state = OPENED;
  590. if (f->callbacks->up)
  591. (*f->callbacks->up)(f); /* Inform upper layers */
  592. } 
  593. else
  594. f->state = ACKSENT;
  595. f->nakloops = 0;
  596. } 
  597. else {
  598. /* we sent CONFACK or CONFREJ */
  599. if (f->state != ACKRCVD)
  600. f->state = REQSENT;
  601. if( code == CONFNAK )
  602. ++f->nakloops;
  603. }
  604. }
  607. /*
  608.  * fsm_rconfack - Receive Configure-Ack.
  609.  */
  610. static void fsm_rconfack(fsm *f, int id, u_char *inp, int len)
  611. {
  612. FSMDEBUG((LOG_INFO, "fsm_rconfack(%s): Rcvd id %d state=%dn",
  613. PROTO_NAME(f), id, f->state));
  615. if (id != f->reqid || f->seen_ack) /* Expected id? */
  616. return; /* Nope, toss... */
  617. if( !(f->callbacks->ackci? (*f->callbacks->ackci)(f, inp, len):
  618. (len == 0)) ){
  619. /* Ack is bad - ignore it */
  620. FSMDEBUG((LOG_INFO, "%s: received bad Ack (length %d)n",
  621. PROTO_NAME(f), len));
  622. return;
  623. }
  624. f->seen_ack = 1;
  626. switch (f->state) {
  627. case CLOSED:
  628. case STOPPED:
  629. fsm_sdata(f, TERMACK, (u_char)id, NULL, 0);
  630. break;
  632. case REQSENT:
  633. f->state = ACKRCVD;
  634. f->retransmits = f->maxconfreqtransmits;
  635. break;
  637. case ACKRCVD:
  638. /* Huh? an extra valid Ack? oh well... */
  639. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  640. fsm_sconfreq(f, 0);
  641. f->state = REQSENT;
  642. break;
  644. case ACKSENT:
  645. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  646. f->state = OPENED;
  647. f->retransmits = f->maxconfreqtransmits;
  648. if (f->callbacks->up)
  649. (*f->callbacks->up)(f); /* Inform upper layers */
  650. break;
  652. case OPENED:
  653. /* Go down and restart negotiation */
  654. if (f->callbacks->down)
  655. (*f->callbacks->down)(f); /* Inform upper layers */
  656. fsm_sconfreq(f, 0); /* Send initial Configure-Request */
  657. f->state = REQSENT;
  658. break;
  659. }
  660. }
  663. /*
  664.  * fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject.
  665.  */
  666. static void fsm_rconfnakrej(fsm *f, int code, int id, u_char *inp, int len)
  667. {
  668. int (*proc) (fsm *, u_char *, int);
  669. int ret;
  671. FSMDEBUG((LOG_INFO, "fsm_rconfnakrej(%s): Rcvd id %d state=%dn",
  672. PROTO_NAME(f), id, f->state));
  674. if (id != f->reqid || f->seen_ack) /* Expected id? */
  675. return; /* Nope, toss... */
  676. proc = (code == CONFNAK)? f->callbacks->nakci: f->callbacks->rejci;
  677. if (!proc || !(ret = proc(f, inp, len))) {
  678. /* Nak/reject is bad - ignore it */
  679. FSMDEBUG((LOG_INFO, "%s: received bad %s (length %d)n",
  680. PROTO_NAME(f), (code==CONFNAK? "Nak": "reject"), len));
  681. return;
  682. }
  683. f->seen_ack = 1;
  685. switch (f->state) {
  686. case CLOSED:
  687. case STOPPED:
  688. fsm_sdata(f, TERMACK, (u_char)id, NULL, 0);
  689. break;
  691. case REQSENT:
  692. case ACKSENT:
  693. /* They didn't agree to what we wanted - try another request */
  694. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  695. if (ret < 0)
  696. f->state = STOPPED; /* kludge for stopping CCP */
  697. else
  698. fsm_sconfreq(f, 0); /* Send Configure-Request */
  699. break;
  701. case ACKRCVD:
  702. /* Got a Nak/reject when we had already had an Ack?? oh well... */
  703. UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
  704. fsm_sconfreq(f, 0);
  705. f->state = REQSENT;
  706. break;
  708. case OPENED:
  709. /* Go down and restart negotiation */
  710. if (f->callbacks->down)
  711. (*f->callbacks->down)(f); /* Inform upper layers */
  712. fsm_sconfreq(f, 0); /* Send initial Configure-Request */
  713. f->state = REQSENT;
  714. break;
  715. }
  716. }
  719. /*
  720.  * fsm_rtermreq - Receive Terminate-Req.
  721.  */
  722. static void fsm_rtermreq(fsm *f, int id, u_char *p, int len)
  723. {
  724. FSMDEBUG((LOG_INFO, "fsm_rtermreq(%s): Rcvd id %d state=%dn",
  725. PROTO_NAME(f), id, f->state));
  727. switch (f->state) {
  728. case ACKRCVD:
  729. case ACKSENT:
  730. f->state = REQSENT; /* Start over but keep trying */
  731. break;
  733. case OPENED:
  734. if (len > 0) {
  735. FSMDEBUG((LOG_INFO, "%s terminated by peer (%x)n", PROTO_NAME(f), p));
  736. } else {
  737. FSMDEBUG((LOG_INFO, "%s terminated by peern", PROTO_NAME(f)));
  738. }
  739. if (f->callbacks->down)
  740. (*f->callbacks->down)(f); /* Inform upper layers */
  741. f->retransmits = 0;
  742. f->state = STOPPING;
  743. TIMEOUT(fsm_timeout, f, f->timeouttime);
  744. break;
  745. }
  747. fsm_sdata(f, TERMACK, (u_char)id, NULL, 0);
  748. }
  751. /*
  752.  * fsm_rtermack - Receive Terminate-Ack.
  753.  */
  754. static void fsm_rtermack(fsm *f)
  755. {
  756. FSMDEBUG((LOG_INFO, "fsm_rtermack(%s): state=%dn", 
  757. PROTO_NAME(f), f->state));
  759. switch (f->state) {
  760. case CLOSING:
  761. UNTIMEOUT(fsm_timeout, f);
  762. f->state = CLOSED;
  763. if( f->callbacks->finished )
  764. (*f->callbacks->finished)(f);
  765. break;
  766. case STOPPING:
  767. UNTIMEOUT(fsm_timeout, f);
  768. f->state = STOPPED;
  769. if( f->callbacks->finished )
  770. (*f->callbacks->finished)(f);
  771. break;
  773. case ACKRCVD:
  774. f->state = REQSENT;
  775. break;
  777. case OPENED:
  778. if (f->callbacks->down)
  779. (*f->callbacks->down)(f); /* Inform upper layers */
  780. fsm_sconfreq(f, 0);
  781. break;
  782. }
  783. }
  786. /*
  787.  * fsm_rcoderej - Receive an Code-Reject.
  788.  */
  789. static void fsm_rcoderej(fsm *f, u_char *inp, int len)
  790. {
  791. u_char code, id;
  793. FSMDEBUG((LOG_INFO, "fsm_rcoderej(%s): state=%dn", 
  794. PROTO_NAME(f), f->state));
  796. if (len < HEADERLEN) {
  797. FSMDEBUG((LOG_INFO, "fsm_rcoderej: Rcvd short Code-Reject packet!n"));
  798. return;
  799. }
  800. GETCHAR(code, inp);
  801. GETCHAR(id, inp);
  802. FSMDEBUG((LOG_WARNING, "%s: Rcvd Code-Reject for code %d, id %dn",
  803. PROTO_NAME(f), code, id));
  805. if( f->state == ACKRCVD )
  806. f->state = REQSENT;
  807. }
  810. /*
  811.  * fsm_sconfreq - Send a Configure-Request.
  812.  */
  813. static void fsm_sconfreq(fsm *f, int retransmit)
  814. {
  815. u_char *outp;
  816. int cilen;
  818. if( f->state != REQSENT && f->state != ACKRCVD && f->state != ACKSENT ){
  819. /* Not currently negotiating - reset options */
  820. if( f->callbacks->resetci )
  821. (*f->callbacks->resetci)(f);/* void lcp_resetci(fsm *f)  */
  823. f->nakloops = 0;
  824. }
  826. if( !retransmit ){
  827. /* New request - reset retransmission counter, use new ID */
  828. f->retransmits = f->maxconfreqtransmits;
  829. f->reqid = ++f->id;
  830. }
  832. f->seen_ack = 0;
  834. /*
  835.  * Make up the request packet
  836.  */
  837. outp = outpacket_buf[f->unit] + PPP_HDRLEN + HEADERLEN;
  838. if( f->callbacks->cilen && f->callbacks->addci ){
  839. cilen = (*f->callbacks->cilen)(f);                              /*lcp_cilen()*/
  840. if( cilen > peer_mru[f->unit] - (int)HEADERLEN )
  841. cilen = peer_mru[f->unit] - HEADERLEN;
  842. if (f->callbacks->addci)
  843. (*f->callbacks->addci)(f, outp, &cilen);
  844. } else
  845. cilen = 0;
  847. /* send the request to our peer */
  848. fsm_sdata(f, CONFREQ, f->reqid, outp, cilen);
  850. /* start the retransmit timer */
  851. --f->retransmits;
  852. TIMEOUT(fsm_timeout, f, f->timeouttime);
  854. FSMDEBUG((LOG_INFO, "%s: sending Configure-Request, id %dn",
  855. PROTO_NAME(f), f->reqid));
  856. }
  858. #endif /* PPP_SUPPORT */