| /***************************************************************************** |
| * fsm.c - Network Control Protocol Finite State Machine program file. |
| * |
| * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. |
| * portions Copyright (c) 1997 by Global Election Systems Inc. |
| * |
| * The authors hereby grant permission to use, copy, modify, distribute, |
| * and license this software and its documentation for any purpose, provided |
| * that existing copyright notices are retained in all copies and that this |
| * notice and the following disclaimer are included verbatim in any |
| * distributions. No written agreement, license, or royalty fee is required |
| * for any of the authorized uses. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| ****************************************************************************** |
| * REVISION HISTORY |
| * |
| * 03-01-01 Marc Boucher <marc@mbsi.ca> |
| * Ported to lwIP. |
| * 97-12-01 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc. |
| * Original based on BSD fsm.c. |
| *****************************************************************************/ |
| /* |
| * fsm.c - {Link, IP} Control Protocol Finite State Machine. |
| * |
| * Copyright (c) 1989 Carnegie Mellon University. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms are permitted |
| * provided that the above copyright notice and this paragraph are |
| * duplicated in all such forms and that any documentation, |
| * advertising materials, and other materials related to such |
| * distribution and use acknowledge that the software was developed |
| * by Carnegie Mellon University. The name of the |
| * University may not be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED |
| * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
| */ |
| |
| |
| /* |
| * TODO: |
| * Randomize fsm id on link/init. |
| * Deal with variable outgoing MTU. |
| */ |
| |
| #include "ppp.h" |
| #if PPP_SUPPORT > 0 |
| #include "fsm.h" |
| #include "pppdebug.h" |
| |
| |
| /*************************/ |
| /*** LOCAL DEFINITIONS ***/ |
| /*************************/ |
| |
| |
| /************************/ |
| /*** LOCAL DATA TYPES ***/ |
| /************************/ |
| |
| |
| /***********************************/ |
| /*** LOCAL FUNCTION DECLARATIONS ***/ |
| /***********************************/ |
| static void fsm_timeout (void *); |
| static void fsm_rconfreq (fsm *, u_char, u_char *, int); |
| static void fsm_rconfack (fsm *, int, u_char *, int); |
| static void fsm_rconfnakrej (fsm *, int, int, u_char *, int); |
| static void fsm_rtermreq (fsm *, int, u_char *, int); |
| static void fsm_rtermack (fsm *); |
| static void fsm_rcoderej (fsm *, u_char *, int); |
| static void fsm_sconfreq (fsm *, int); |
| |
| #define PROTO_NAME(f) ((f)->callbacks->proto_name) |
| |
| |
| /******************************/ |
| /*** PUBLIC DATA STRUCTURES ***/ |
| /******************************/ |
| |
| |
| /*****************************/ |
| /*** LOCAL DATA STRUCTURES ***/ |
| /*****************************/ |
| int peer_mru[NUM_PPP]; |
| |
| |
| /***********************************/ |
| /*** PUBLIC FUNCTION DEFINITIONS ***/ |
| /***********************************/ |
| |
| /* |
| * fsm_init - Initialize fsm. |
| * |
| * Initialize fsm state. |
| */ |
| void fsm_init(fsm *f) |
| { |
| f->state = INITIAL; |
| f->flags = 0; |
| f->id = 0; /* XXX Start with random id? */ |
| f->timeouttime = FSM_DEFTIMEOUT; |
| f->maxconfreqtransmits = FSM_DEFMAXCONFREQS; |
| f->maxtermtransmits = FSM_DEFMAXTERMREQS; |
| f->maxnakloops = FSM_DEFMAXNAKLOOPS; |
| f->term_reason_len = 0; |
| } |
| |
| |
| /* |
| * fsm_lowerup - The lower layer is up. |
| */ |
| void fsm_lowerup(fsm *f) |
| { |
| int oldState = f->state; |
| |
| switch( f->state ){ |
| case INITIAL: |
| f->state = CLOSED; |
| break; |
| |
| case STARTING: |
| if( f->flags & OPT_SILENT ) |
| f->state = STOPPED; |
| else { |
| /* Send an initial configure-request */ |
| fsm_sconfreq(f, 0); |
| f->state = REQSENT; |
| } |
| break; |
| |
| default: |
| FSMDEBUG((LOG_INFO, "%s: Up event in state %d!\n", |
| PROTO_NAME(f), f->state)); |
| } |
| |
| FSMDEBUG((LOG_INFO, "%s: lowerup state %d -> %d\n", |
| PROTO_NAME(f), oldState, f->state)); |
| } |
| |
| |
| /* |
| * fsm_lowerdown - The lower layer is down. |
| * |
| * Cancel all timeouts and inform upper layers. |
| */ |
| void fsm_lowerdown(fsm *f) |
| { |
| int oldState = f->state; |
| |
| switch( f->state ){ |
| case CLOSED: |
| f->state = INITIAL; |
| break; |
| |
| case STOPPED: |
| f->state = STARTING; |
| if( f->callbacks->starting ) |
| (*f->callbacks->starting)(f); |
| break; |
| |
| case CLOSING: |
| f->state = INITIAL; |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| break; |
| |
| case STOPPING: |
| case REQSENT: |
| case ACKRCVD: |
| case ACKSENT: |
| f->state = STARTING; |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| break; |
| |
| case OPENED: |
| if( f->callbacks->down ) |
| (*f->callbacks->down)(f); |
| f->state = STARTING; |
| break; |
| |
| default: |
| FSMDEBUG((LOG_INFO, "%s: Down event in state %d!\n", |
| PROTO_NAME(f), f->state)); |
| } |
| |
| FSMDEBUG((LOG_INFO, "%s: lowerdown state %d -> %d\n", |
| PROTO_NAME(f), oldState, f->state)); |
| } |
| |
| |
| /* |
| * fsm_open - Link is allowed to come up. |
| */ |
| void fsm_open(fsm *f) |
| { |
| int oldState = f->state; |
| |
| switch( f->state ){ |
| case INITIAL: |
| f->state = STARTING; |
| if( f->callbacks->starting ) |
| (*f->callbacks->starting)(f); |
| break; |
| |
| case CLOSED: |
| if( f->flags & OPT_SILENT ) |
| f->state = STOPPED; |
| else { |
| /* Send an initial configure-request */ |
| fsm_sconfreq(f, 0); |
| f->state = REQSENT; |
| } |
| break; |
| |
| case CLOSING: |
| f->state = STOPPING; |
| /* fall through */ |
| case STOPPED: |
| case OPENED: |
| if( f->flags & OPT_RESTART ){ |
| fsm_lowerdown(f); |
| fsm_lowerup(f); |
| } |
| break; |
| } |
| |
| FSMDEBUG((LOG_INFO, "%s: open state %d -> %d\n", |
| PROTO_NAME(f), oldState, f->state)); |
| } |
| |
| |
| /* |
| * fsm_close - Start closing connection. |
| * |
| * Cancel timeouts and either initiate close or possibly go directly to |
| * the CLOSED state. |
| */ |
| void fsm_close(fsm *f, char *reason) |
| { |
| int oldState = f->state; |
| |
| f->term_reason = reason; |
| f->term_reason_len = (reason == NULL? 0: strlen(reason)); |
| switch( f->state ){ |
| case STARTING: |
| f->state = INITIAL; |
| break; |
| case STOPPED: |
| f->state = CLOSED; |
| break; |
| case STOPPING: |
| f->state = CLOSING; |
| break; |
| |
| case REQSENT: |
| case ACKRCVD: |
| case ACKSENT: |
| case OPENED: |
| if( f->state != OPENED ) |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| else if( f->callbacks->down ) |
| (*f->callbacks->down)(f); /* Inform upper layers we're down */ |
| |
| /* Init restart counter, send Terminate-Request */ |
| f->retransmits = f->maxtermtransmits; |
| fsm_sdata(f, TERMREQ, f->reqid = ++f->id, |
| (u_char *) f->term_reason, f->term_reason_len); |
| TIMEOUT(fsm_timeout, f, f->timeouttime); |
| --f->retransmits; |
| |
| f->state = CLOSING; |
| break; |
| } |
| |
| FSMDEBUG((LOG_INFO, "%s: close reason=%s state %d -> %d\n", |
| PROTO_NAME(f), reason, oldState, f->state)); |
| } |
| |
| |
| /* |
| * fsm_sdata - Send some data. |
| * |
| * Used for all packets sent to our peer by this module. |
| */ |
| void fsm_sdata( |
| fsm *f, |
| u_char code, |
| u_char id, |
| u_char *data, |
| int datalen |
| ) |
| { |
| u_char *outp; |
| int outlen; |
| |
| /* Adjust length to be smaller than MTU */ |
| outp = outpacket_buf[f->unit]; |
| if (datalen > peer_mru[f->unit] - (int)HEADERLEN) |
| datalen = peer_mru[f->unit] - HEADERLEN; |
| if (datalen && data != outp + PPP_HDRLEN + HEADERLEN) |
| BCOPY(data, outp + PPP_HDRLEN + HEADERLEN, datalen); |
| outlen = datalen + HEADERLEN; |
| MAKEHEADER(outp, f->protocol); |
| PUTCHAR(code, outp); |
| PUTCHAR(id, outp); |
| PUTSHORT(outlen, outp); |
| pppWrite(f->unit, outpacket_buf[f->unit], outlen + PPP_HDRLEN); |
| FSMDEBUG((LOG_INFO, "fsm_sdata(%s): Sent code %d,%d,%d.\n", |
| PROTO_NAME(f), code, id, outlen)); |
| } |
| |
| |
| /* |
| * fsm_input - Input packet. |
| */ |
| void fsm_input(fsm *f, u_char *inpacket, int l) |
| { |
| u_char *inp = inpacket; |
| u_char code, id; |
| int len; |
| |
| /* |
| * Parse header (code, id and length). |
| * If packet too short, drop it. |
| */ |
| if (l < HEADERLEN) { |
| FSMDEBUG((LOG_WARNING, "fsm_input(%x): Rcvd short header.\n", |
| f->protocol)); |
| return; |
| } |
| GETCHAR(code, inp); |
| GETCHAR(id, inp); |
| GETSHORT(len, inp); |
| if (len < HEADERLEN) { |
| FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd illegal length.\n", |
| f->protocol)); |
| return; |
| } |
| if (len > l) { |
| FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd short packet.\n", |
| f->protocol)); |
| return; |
| } |
| len -= HEADERLEN; /* subtract header length */ |
| |
| if( f->state == INITIAL || f->state == STARTING ){ |
| FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd packet in state %d.\n", |
| f->protocol, f->state)); |
| return; |
| } |
| FSMDEBUG((LOG_INFO, "fsm_input(%s):%d,%d,%d\n", PROTO_NAME(f), code, id, l)); |
| /* |
| * Action depends on code. |
| */ |
| switch (code) { |
| case CONFREQ: |
| fsm_rconfreq(f, id, inp, len); |
| break; |
| |
| case CONFACK: |
| fsm_rconfack(f, id, inp, len); |
| break; |
| |
| case CONFNAK: |
| case CONFREJ: |
| fsm_rconfnakrej(f, code, id, inp, len); |
| break; |
| |
| case TERMREQ: |
| fsm_rtermreq(f, id, inp, len); |
| break; |
| |
| case TERMACK: |
| fsm_rtermack(f); |
| break; |
| |
| case CODEREJ: |
| fsm_rcoderej(f, inp, len); |
| break; |
| |
| default: |
| if( !f->callbacks->extcode |
| || !(*f->callbacks->extcode)(f, code, id, inp, len) ) |
| fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN); |
| break; |
| } |
| } |
| |
| |
| /* |
| * fsm_protreject - Peer doesn't speak this protocol. |
| * |
| * Treat this as a catastrophic error (RXJ-). |
| */ |
| void fsm_protreject(fsm *f) |
| { |
| switch( f->state ){ |
| case CLOSING: |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| /* fall through */ |
| case CLOSED: |
| f->state = CLOSED; |
| if( f->callbacks->finished ) |
| (*f->callbacks->finished)(f); |
| break; |
| |
| case STOPPING: |
| case REQSENT: |
| case ACKRCVD: |
| case ACKSENT: |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| /* fall through */ |
| case STOPPED: |
| f->state = STOPPED; |
| if( f->callbacks->finished ) |
| (*f->callbacks->finished)(f); |
| break; |
| |
| case OPENED: |
| if( f->callbacks->down ) |
| (*f->callbacks->down)(f); |
| |
| /* Init restart counter, send Terminate-Request */ |
| f->retransmits = f->maxtermtransmits; |
| fsm_sdata(f, TERMREQ, f->reqid = ++f->id, |
| (u_char *) f->term_reason, f->term_reason_len); |
| TIMEOUT(fsm_timeout, f, f->timeouttime); |
| --f->retransmits; |
| |
| f->state = STOPPING; |
| break; |
| |
| default: |
| FSMDEBUG((LOG_INFO, "%s: Protocol-reject event in state %d!\n", |
| PROTO_NAME(f), f->state)); |
| } |
| } |
| |
| |
| |
| |
| |
| /**********************************/ |
| /*** LOCAL FUNCTION DEFINITIONS ***/ |
| /**********************************/ |
| |
| /* |
| * fsm_timeout - Timeout expired. |
| */ |
| static void fsm_timeout(void *arg) |
| { |
| fsm *f = (fsm *) arg; |
| |
| switch (f->state) { |
| case CLOSING: |
| case STOPPING: |
| if( f->retransmits <= 0 ){ |
| FSMDEBUG((LOG_WARNING, "%s: timeout sending Terminate-Request state=%d\n", |
| PROTO_NAME(f), f->state)); |
| /* |
| * We've waited for an ack long enough. Peer probably heard us. |
| */ |
| f->state = (f->state == CLOSING)? CLOSED: STOPPED; |
| if( f->callbacks->finished ) |
| (*f->callbacks->finished)(f); |
| } else { |
| FSMDEBUG((LOG_WARNING, "%s: timeout resending Terminate-Requests state=%d\n", |
| PROTO_NAME(f), f->state)); |
| /* Send Terminate-Request */ |
| fsm_sdata(f, TERMREQ, f->reqid = ++f->id, |
| (u_char *) f->term_reason, f->term_reason_len); |
| TIMEOUT(fsm_timeout, f, f->timeouttime); |
| --f->retransmits; |
| } |
| break; |
| |
| case REQSENT: |
| case ACKRCVD: |
| case ACKSENT: |
| if (f->retransmits <= 0) { |
| FSMDEBUG((LOG_WARNING, "%s: timeout sending Config-Requests state=%d\n", |
| PROTO_NAME(f), f->state)); |
| f->state = STOPPED; |
| if( (f->flags & OPT_PASSIVE) == 0 && f->callbacks->finished ) |
| (*f->callbacks->finished)(f); |
| |
| } else { |
| FSMDEBUG((LOG_WARNING, "%s: timeout resending Config-Request state=%d\n", |
| PROTO_NAME(f), f->state)); |
| /* Retransmit the configure-request */ |
| if (f->callbacks->retransmit) |
| (*f->callbacks->retransmit)(f); |
| fsm_sconfreq(f, 1); /* Re-send Configure-Request */ |
| if( f->state == ACKRCVD ) |
| f->state = REQSENT; |
| } |
| break; |
| |
| default: |
| FSMDEBUG((LOG_INFO, "%s: Timeout event in state %d!\n", |
| PROTO_NAME(f), f->state)); |
| } |
| } |
| |
| |
| /* |
| * fsm_rconfreq - Receive Configure-Request. |
| */ |
| static void fsm_rconfreq(fsm *f, u_char id, u_char *inp, int len) |
| { |
| int code, reject_if_disagree; |
| |
| FSMDEBUG((LOG_INFO, "fsm_rconfreq(%s): Rcvd id %d state=%d\n", |
| PROTO_NAME(f), id, f->state)); |
| switch( f->state ){ |
| case CLOSED: |
| /* Go away, we're closed */ |
| fsm_sdata(f, TERMACK, id, NULL, 0); |
| return; |
| case CLOSING: |
| case STOPPING: |
| return; |
| |
| case OPENED: |
| /* Go down and restart negotiation */ |
| if( f->callbacks->down ) |
| (*f->callbacks->down)(f); /* Inform upper layers */ |
| fsm_sconfreq(f, 0); /* Send initial Configure-Request */ |
| break; |
| |
| case STOPPED: |
| /* Negotiation started by our peer */ |
| fsm_sconfreq(f, 0); /* Send initial Configure-Request */ |
| f->state = REQSENT; |
| break; |
| } |
| |
| /* |
| * Pass the requested configuration options |
| * to protocol-specific code for checking. |
| */ |
| if (f->callbacks->reqci){ /* Check CI */ |
| reject_if_disagree = (f->nakloops >= f->maxnakloops); |
| code = (*f->callbacks->reqci)(f, inp, &len, reject_if_disagree); |
| } |
| else if (len) |
| code = CONFREJ; /* Reject all CI */ |
| else |
| code = CONFACK; |
| |
| /* send the Ack, Nak or Rej to the peer */ |
| fsm_sdata(f, (u_char)code, id, inp, len); |
| |
| if (code == CONFACK) { |
| if (f->state == ACKRCVD) { |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| f->state = OPENED; |
| if (f->callbacks->up) |
| (*f->callbacks->up)(f); /* Inform upper layers */ |
| } |
| else |
| f->state = ACKSENT; |
| f->nakloops = 0; |
| } |
| else { |
| /* we sent CONFACK or CONFREJ */ |
| if (f->state != ACKRCVD) |
| f->state = REQSENT; |
| if( code == CONFNAK ) |
| ++f->nakloops; |
| } |
| } |
| |
| |
| /* |
| * fsm_rconfack - Receive Configure-Ack. |
| */ |
| static void fsm_rconfack(fsm *f, int id, u_char *inp, int len) |
| { |
| FSMDEBUG((LOG_INFO, "fsm_rconfack(%s): Rcvd id %d state=%d\n", |
| PROTO_NAME(f), id, f->state)); |
| |
| if (id != f->reqid || f->seen_ack) /* Expected id? */ |
| return; /* Nope, toss... */ |
| if( !(f->callbacks->ackci? (*f->callbacks->ackci)(f, inp, len): |
| (len == 0)) ){ |
| /* Ack is bad - ignore it */ |
| FSMDEBUG((LOG_INFO, "%s: received bad Ack (length %d)\n", |
| PROTO_NAME(f), len)); |
| return; |
| } |
| f->seen_ack = 1; |
| |
| switch (f->state) { |
| case CLOSED: |
| case STOPPED: |
| fsm_sdata(f, TERMACK, (u_char)id, NULL, 0); |
| break; |
| |
| case REQSENT: |
| f->state = ACKRCVD; |
| f->retransmits = f->maxconfreqtransmits; |
| break; |
| |
| case ACKRCVD: |
| /* Huh? an extra valid Ack? oh well... */ |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| fsm_sconfreq(f, 0); |
| f->state = REQSENT; |
| break; |
| |
| case ACKSENT: |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| f->state = OPENED; |
| f->retransmits = f->maxconfreqtransmits; |
| if (f->callbacks->up) |
| (*f->callbacks->up)(f); /* Inform upper layers */ |
| break; |
| |
| case OPENED: |
| /* Go down and restart negotiation */ |
| if (f->callbacks->down) |
| (*f->callbacks->down)(f); /* Inform upper layers */ |
| fsm_sconfreq(f, 0); /* Send initial Configure-Request */ |
| f->state = REQSENT; |
| break; |
| } |
| } |
| |
| |
| /* |
| * fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject. |
| */ |
| static void fsm_rconfnakrej(fsm *f, int code, int id, u_char *inp, int len) |
| { |
| int (*proc) (fsm *, u_char *, int); |
| int ret; |
| |
| FSMDEBUG((LOG_INFO, "fsm_rconfnakrej(%s): Rcvd id %d state=%d\n", |
| PROTO_NAME(f), id, f->state)); |
| |
| if (id != f->reqid || f->seen_ack) /* Expected id? */ |
| return; /* Nope, toss... */ |
| proc = (code == CONFNAK)? f->callbacks->nakci: f->callbacks->rejci; |
| if (!proc || !(ret = proc(f, inp, len))) { |
| /* Nak/reject is bad - ignore it */ |
| FSMDEBUG((LOG_INFO, "%s: received bad %s (length %d)\n", |
| PROTO_NAME(f), (code==CONFNAK? "Nak": "reject"), len)); |
| return; |
| } |
| f->seen_ack = 1; |
| |
| switch (f->state) { |
| case CLOSED: |
| case STOPPED: |
| fsm_sdata(f, TERMACK, (u_char)id, NULL, 0); |
| break; |
| |
| case REQSENT: |
| case ACKSENT: |
| /* They didn't agree to what we wanted - try another request */ |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| if (ret < 0) |
| f->state = STOPPED; /* kludge for stopping CCP */ |
| else |
| fsm_sconfreq(f, 0); /* Send Configure-Request */ |
| break; |
| |
| case ACKRCVD: |
| /* Got a Nak/reject when we had already had an Ack?? oh well... */ |
| UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ |
| fsm_sconfreq(f, 0); |
| f->state = REQSENT; |
| break; |
| |
| case OPENED: |
| /* Go down and restart negotiation */ |
| if (f->callbacks->down) |
| (*f->callbacks->down)(f); /* Inform upper layers */ |
| fsm_sconfreq(f, 0); /* Send initial Configure-Request */ |
| f->state = REQSENT; |
| break; |
| } |
| } |
| |
| |
| /* |
| * fsm_rtermreq - Receive Terminate-Req. |
| */ |
| static void fsm_rtermreq(fsm *f, int id, u_char *p, int len) |
| { |
| FSMDEBUG((LOG_INFO, "fsm_rtermreq(%s): Rcvd id %d state=%d\n", |
| PROTO_NAME(f), id, f->state)); |
| |
| switch (f->state) { |
| case ACKRCVD: |
| case ACKSENT: |
| f->state = REQSENT; /* Start over but keep trying */ |
| break; |
| |
| case OPENED: |
| if (len > 0) { |
| FSMDEBUG((LOG_INFO, "%s terminated by peer (%x)\n", PROTO_NAME(f), p)); |
| } else { |
| FSMDEBUG((LOG_INFO, "%s terminated by peer\n", PROTO_NAME(f))); |
| } |
| if (f->callbacks->down) |
| (*f->callbacks->down)(f); /* Inform upper layers */ |
| f->retransmits = 0; |
| f->state = STOPPING; |
| TIMEOUT(fsm_timeout, f, f->timeouttime); |
| break; |
| } |
| |
| fsm_sdata(f, TERMACK, (u_char)id, NULL, 0); |
| } |
| |
| |
| /* |
| * fsm_rtermack - Receive Terminate-Ack. |
| */ |
| static void fsm_rtermack(fsm *f) |
| { |
| FSMDEBUG((LOG_INFO, "fsm_rtermack(%s): state=%d\n", |
| PROTO_NAME(f), f->state)); |
| |
| switch (f->state) { |
| case CLOSING: |
| UNTIMEOUT(fsm_timeout, f); |
| f->state = CLOSED; |
| if( f->callbacks->finished ) |
| (*f->callbacks->finished)(f); |
| break; |
| case STOPPING: |
| UNTIMEOUT(fsm_timeout, f); |
| f->state = STOPPED; |
| if( f->callbacks->finished ) |
| (*f->callbacks->finished)(f); |
| break; |
| |
| case ACKRCVD: |
| f->state = REQSENT; |
| break; |
| |
| case OPENED: |
| if (f->callbacks->down) |
| (*f->callbacks->down)(f); /* Inform upper layers */ |
| fsm_sconfreq(f, 0); |
| break; |
| } |
| } |
| |
| |
| /* |
| * fsm_rcoderej - Receive an Code-Reject. |
| */ |
| static void fsm_rcoderej(fsm *f, u_char *inp, int len) |
| { |
| u_char code, id; |
| |
| FSMDEBUG((LOG_INFO, "fsm_rcoderej(%s): state=%d\n", |
| PROTO_NAME(f), f->state)); |
| |
| if (len < HEADERLEN) { |
| FSMDEBUG((LOG_INFO, "fsm_rcoderej: Rcvd short Code-Reject packet!\n")); |
| return; |
| } |
| GETCHAR(code, inp); |
| GETCHAR(id, inp); |
| FSMDEBUG((LOG_WARNING, "%s: Rcvd Code-Reject for code %d, id %d\n", |
| PROTO_NAME(f), code, id)); |
| |
| if( f->state == ACKRCVD ) |
| f->state = REQSENT; |
| } |
| |
| |
| /* |
| * fsm_sconfreq - Send a Configure-Request. |
| */ |
| static void fsm_sconfreq(fsm *f, int retransmit) |
| { |
| u_char *outp; |
| int cilen; |
| |
| if( f->state != REQSENT && f->state != ACKRCVD && f->state != ACKSENT ){ |
| /* Not currently negotiating - reset options */ |
| if( f->callbacks->resetci ) |
| (*f->callbacks->resetci)(f); |
| f->nakloops = 0; |
| } |
| |
| if( !retransmit ){ |
| /* New request - reset retransmission counter, use new ID */ |
| f->retransmits = f->maxconfreqtransmits; |
| f->reqid = ++f->id; |
| } |
| |
| f->seen_ack = 0; |
| |
| /* |
| * Make up the request packet |
| */ |
| outp = outpacket_buf[f->unit] + PPP_HDRLEN + HEADERLEN; |
| if( f->callbacks->cilen && f->callbacks->addci ){ |
| cilen = (*f->callbacks->cilen)(f); |
| if( cilen > peer_mru[f->unit] - (int)HEADERLEN ) |
| cilen = peer_mru[f->unit] - HEADERLEN; |
| if (f->callbacks->addci) |
| (*f->callbacks->addci)(f, outp, &cilen); |
| } else |
| cilen = 0; |
| |
| /* send the request to our peer */ |
| fsm_sdata(f, CONFREQ, f->reqid, outp, cilen); |
| |
| /* start the retransmit timer */ |
| --f->retransmits; |
| TIMEOUT(fsm_timeout, f, f->timeouttime); |
| |
| FSMDEBUG((LOG_INFO, "%s: sending Configure-Request, id %d\n", |
| PROTO_NAME(f), f->reqid)); |
| } |
| |
| #endif /* PPP_SUPPORT */ |