1 /*****************************************************************************
\r
2 * fsm.c - Network Control Protocol Finite State Machine program file.
\r
4 * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.
\r
5 * portions Copyright (c) 1997 by Global Election Systems Inc.
\r
7 * The authors hereby grant permission to use, copy, modify, distribute,
\r
8 * and license this software and its documentation for any purpose, provided
\r
9 * that existing copyright notices are retained in all copies and that this
\r
10 * notice and the following disclaimer are included verbatim in any
\r
11 * distributions. No written agreement, license, or royalty fee is required
\r
12 * for any of the authorized uses.
\r
14 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR
\r
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
\r
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
\r
17 * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
\r
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
\r
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
\r
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
\r
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
\r
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
\r
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
25 ******************************************************************************
\r
28 * 03-01-01 Marc Boucher <marc@mbsi.ca>
\r
30 * 97-12-01 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
\r
31 * Original based on BSD fsm.c.
\r
32 *****************************************************************************/
\r
34 * fsm.c - {Link, IP} Control Protocol Finite State Machine.
\r
36 * Copyright (c) 1989 Carnegie Mellon University.
\r
37 * All rights reserved.
\r
39 * Redistribution and use in source and binary forms are permitted
\r
40 * provided that the above copyright notice and this paragraph are
\r
41 * duplicated in all such forms and that any documentation,
\r
42 * advertising materials, and other materials related to such
\r
43 * distribution and use acknowledge that the software was developed
\r
44 * by Carnegie Mellon University. The name of the
\r
45 * University may not be used to endorse or promote products derived
\r
46 * from this software without specific prior written permission.
\r
47 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
\r
48 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
\r
49 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
\r
55 * Randomize fsm id on link/init.
\r
56 * Deal with variable outgoing MTU.
\r
62 #include "pppdebug.h"
\r
65 /*************************/
\r
66 /*** LOCAL DEFINITIONS ***/
\r
67 /*************************/
\r
70 /************************/
\r
71 /*** LOCAL DATA TYPES ***/
\r
72 /************************/
\r
75 /***********************************/
\r
76 /*** LOCAL FUNCTION DECLARATIONS ***/
\r
77 /***********************************/
\r
78 static void fsm_timeout (void *);
\r
79 static void fsm_rconfreq (fsm *, u_char, u_char *, int);
\r
80 static void fsm_rconfack (fsm *, int, u_char *, int);
\r
81 static void fsm_rconfnakrej (fsm *, int, int, u_char *, int);
\r
82 static void fsm_rtermreq (fsm *, int, u_char *, int);
\r
83 static void fsm_rtermack (fsm *);
\r
84 static void fsm_rcoderej (fsm *, u_char *, int);
\r
85 static void fsm_sconfreq (fsm *, int);
\r
87 #define PROTO_NAME(f) ((f)->callbacks->proto_name)
\r
90 /******************************/
\r
91 /*** PUBLIC DATA STRUCTURES ***/
\r
92 /******************************/
\r
95 /*****************************/
\r
96 /*** LOCAL DATA STRUCTURES ***/
\r
97 /*****************************/
\r
98 int peer_mru[NUM_PPP];
\r
101 /***********************************/
\r
102 /*** PUBLIC FUNCTION DEFINITIONS ***/
\r
103 /***********************************/
\r
106 * fsm_init - Initialize fsm.
\r
108 * Initialize fsm state.
\r
110 void fsm_init(fsm *f)
\r
112 f->state = INITIAL;
\r
114 f->id = 0; /* XXX Start with random id? */
\r
115 f->timeouttime = FSM_DEFTIMEOUT;
\r
116 f->maxconfreqtransmits = FSM_DEFMAXCONFREQS;
\r
117 f->maxtermtransmits = FSM_DEFMAXTERMREQS;
\r
118 f->maxnakloops = FSM_DEFMAXNAKLOOPS;
\r
119 f->term_reason_len = 0;
\r
124 * fsm_lowerup - The lower layer is up.
\r
126 void fsm_lowerup(fsm *f)
\r
128 int oldState = f->state;
\r
130 switch( f->state ){
\r
136 if( f->flags & OPT_SILENT )
\r
137 f->state = STOPPED;
\r
139 /* Send an initial configure-request */
\r
140 fsm_sconfreq(f, 0);
\r
141 f->state = REQSENT;
\r
146 FSMDEBUG((LOG_INFO, "%s: Up event in state %d!\n",
\r
147 PROTO_NAME(f), f->state));
\r
150 FSMDEBUG((LOG_INFO, "%s: lowerup state %d -> %d\n",
\r
151 PROTO_NAME(f), oldState, f->state));
\r
156 * fsm_lowerdown - The lower layer is down.
\r
158 * Cancel all timeouts and inform upper layers.
\r
160 void fsm_lowerdown(fsm *f)
\r
162 int oldState = f->state;
\r
164 switch( f->state ){
\r
166 f->state = INITIAL;
\r
170 f->state = STARTING;
\r
171 if( f->callbacks->starting )
\r
172 (*f->callbacks->starting)(f);
\r
176 f->state = INITIAL;
\r
177 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
184 f->state = STARTING;
\r
185 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
189 if( f->callbacks->down )
\r
190 (*f->callbacks->down)(f);
\r
191 f->state = STARTING;
\r
195 FSMDEBUG((LOG_INFO, "%s: Down event in state %d!\n",
\r
196 PROTO_NAME(f), f->state));
\r
199 FSMDEBUG((LOG_INFO, "%s: lowerdown state %d -> %d\n",
\r
200 PROTO_NAME(f), oldState, f->state));
\r
205 * fsm_open - Link is allowed to come up.
\r
207 void fsm_open(fsm *f)
\r
209 int oldState = f->state;
\r
211 switch( f->state ){
\r
213 f->state = STARTING;
\r
214 if( f->callbacks->starting )
\r
215 (*f->callbacks->starting)(f);
\r
219 if( f->flags & OPT_SILENT )
\r
220 f->state = STOPPED;
\r
222 /* Send an initial configure-request */
\r
223 fsm_sconfreq(f, 0);
\r
224 f->state = REQSENT;
\r
229 f->state = STOPPING;
\r
233 if( f->flags & OPT_RESTART ){
\r
240 FSMDEBUG((LOG_INFO, "%s: open state %d -> %d\n",
\r
241 PROTO_NAME(f), oldState, f->state));
\r
246 * fsm_close - Start closing connection.
\r
248 * Cancel timeouts and either initiate close or possibly go directly to
\r
249 * the CLOSED state.
\r
251 void fsm_close(fsm *f, char *reason)
\r
253 int oldState = f->state;
\r
255 f->term_reason = reason;
\r
256 f->term_reason_len = (reason == NULL? 0: strlen(reason));
\r
257 switch( f->state ){
\r
259 f->state = INITIAL;
\r
265 f->state = CLOSING;
\r
272 if( f->state != OPENED )
\r
273 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
274 else if( f->callbacks->down )
\r
275 (*f->callbacks->down)(f); /* Inform upper layers we're down */
\r
277 /* Init restart counter, send Terminate-Request */
\r
278 f->retransmits = f->maxtermtransmits;
\r
279 fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
\r
280 (u_char *) f->term_reason, f->term_reason_len);
\r
281 TIMEOUT(fsm_timeout, f, f->timeouttime);
\r
284 f->state = CLOSING;
\r
288 FSMDEBUG((LOG_INFO, "%s: close reason=%s state %d -> %d\n",
\r
289 PROTO_NAME(f), reason, oldState, f->state));
\r
294 * fsm_sdata - Send some data.
\r
296 * Used for all packets sent to our peer by this module.
\r
309 /* Adjust length to be smaller than MTU */
\r
310 outp = outpacket_buf[f->unit];
\r
311 if (datalen > peer_mru[f->unit] - (int)HEADERLEN)
\r
312 datalen = peer_mru[f->unit] - HEADERLEN;
\r
313 if (datalen && data != outp + PPP_HDRLEN + HEADERLEN)
\r
314 BCOPY(data, outp + PPP_HDRLEN + HEADERLEN, datalen);
\r
315 outlen = datalen + HEADERLEN;
\r
316 MAKEHEADER(outp, f->protocol);
\r
317 PUTCHAR(code, outp);
\r
319 PUTSHORT(outlen, outp);
\r
320 pppWrite(f->unit, outpacket_buf[f->unit], outlen + PPP_HDRLEN);
\r
321 FSMDEBUG((LOG_INFO, "fsm_sdata(%s): Sent code %d,%d,%d.\n",
\r
322 PROTO_NAME(f), code, id, outlen));
\r
327 * fsm_input - Input packet.
\r
329 void fsm_input(fsm *f, u_char *inpacket, int l)
\r
331 u_char *inp = inpacket;
\r
336 * Parse header (code, id and length).
\r
337 * If packet too short, drop it.
\r
339 if (l < HEADERLEN) {
\r
340 FSMDEBUG((LOG_WARNING, "fsm_input(%x): Rcvd short header.\n",
\r
344 GETCHAR(code, inp);
\r
346 GETSHORT(len, inp);
\r
347 if (len < HEADERLEN) {
\r
348 FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd illegal length.\n",
\r
353 FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd short packet.\n",
\r
357 len -= HEADERLEN; /* subtract header length */
\r
359 if( f->state == INITIAL || f->state == STARTING ){
\r
360 FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd packet in state %d.\n",
\r
361 f->protocol, f->state));
\r
364 FSMDEBUG((LOG_INFO, "fsm_input(%s):%d,%d,%d\n", PROTO_NAME(f), code, id, l));
\r
366 * Action depends on code.
\r
370 fsm_rconfreq(f, id, inp, len);
\r
374 fsm_rconfack(f, id, inp, len);
\r
379 fsm_rconfnakrej(f, code, id, inp, len);
\r
383 fsm_rtermreq(f, id, inp, len);
\r
391 fsm_rcoderej(f, inp, len);
\r
395 if( !f->callbacks->extcode
\r
396 || !(*f->callbacks->extcode)(f, code, id, inp, len) )
\r
397 fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN);
\r
404 * fsm_protreject - Peer doesn't speak this protocol.
\r
406 * Treat this as a catastrophic error (RXJ-).
\r
408 void fsm_protreject(fsm *f)
\r
410 switch( f->state ){
\r
412 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
416 if( f->callbacks->finished )
\r
417 (*f->callbacks->finished)(f);
\r
424 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
427 f->state = STOPPED;
\r
428 if( f->callbacks->finished )
\r
429 (*f->callbacks->finished)(f);
\r
433 if( f->callbacks->down )
\r
434 (*f->callbacks->down)(f);
\r
436 /* Init restart counter, send Terminate-Request */
\r
437 f->retransmits = f->maxtermtransmits;
\r
438 fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
\r
439 (u_char *) f->term_reason, f->term_reason_len);
\r
440 TIMEOUT(fsm_timeout, f, f->timeouttime);
\r
443 f->state = STOPPING;
\r
447 FSMDEBUG((LOG_INFO, "%s: Protocol-reject event in state %d!\n",
\r
448 PROTO_NAME(f), f->state));
\r
456 /**********************************/
\r
457 /*** LOCAL FUNCTION DEFINITIONS ***/
\r
458 /**********************************/
\r
461 * fsm_timeout - Timeout expired.
\r
463 static void fsm_timeout(void *arg)
\r
465 fsm *f = (fsm *) arg;
\r
467 switch (f->state) {
\r
470 if( f->retransmits <= 0 ){
\r
471 FSMDEBUG((LOG_WARNING, "%s: timeout sending Terminate-Request state=%d\n",
\r
472 PROTO_NAME(f), f->state));
\r
474 * We've waited for an ack long enough. Peer probably heard us.
\r
476 f->state = (f->state == CLOSING)? CLOSED: STOPPED;
\r
477 if( f->callbacks->finished )
\r
478 (*f->callbacks->finished)(f);
\r
480 FSMDEBUG((LOG_WARNING, "%s: timeout resending Terminate-Requests state=%d\n",
\r
481 PROTO_NAME(f), f->state));
\r
482 /* Send Terminate-Request */
\r
483 fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
\r
484 (u_char *) f->term_reason, f->term_reason_len);
\r
485 TIMEOUT(fsm_timeout, f, f->timeouttime);
\r
493 if (f->retransmits <= 0) {
\r
494 FSMDEBUG((LOG_WARNING, "%s: timeout sending Config-Requests state=%d\n",
\r
495 PROTO_NAME(f), f->state));
\r
496 f->state = STOPPED;
\r
497 if( (f->flags & OPT_PASSIVE) == 0 && f->callbacks->finished )
\r
498 (*f->callbacks->finished)(f);
\r
501 FSMDEBUG((LOG_WARNING, "%s: timeout resending Config-Request state=%d\n",
\r
502 PROTO_NAME(f), f->state));
\r
503 /* Retransmit the configure-request */
\r
504 if (f->callbacks->retransmit)
\r
505 (*f->callbacks->retransmit)(f);
\r
506 fsm_sconfreq(f, 1); /* Re-send Configure-Request */
\r
507 if( f->state == ACKRCVD )
\r
508 f->state = REQSENT;
\r
513 FSMDEBUG((LOG_INFO, "%s: Timeout event in state %d!\n",
\r
514 PROTO_NAME(f), f->state));
\r
520 * fsm_rconfreq - Receive Configure-Request.
\r
522 static void fsm_rconfreq(fsm *f, u_char id, u_char *inp, int len)
\r
524 int code, reject_if_disagree;
\r
526 FSMDEBUG((LOG_INFO, "fsm_rconfreq(%s): Rcvd id %d state=%d\n",
\r
527 PROTO_NAME(f), id, f->state));
\r
528 switch( f->state ){
\r
530 /* Go away, we're closed */
\r
531 fsm_sdata(f, TERMACK, id, NULL, 0);
\r
538 /* Go down and restart negotiation */
\r
539 if( f->callbacks->down )
\r
540 (*f->callbacks->down)(f); /* Inform upper layers */
\r
541 fsm_sconfreq(f, 0); /* Send initial Configure-Request */
\r
545 /* Negotiation started by our peer */
\r
546 fsm_sconfreq(f, 0); /* Send initial Configure-Request */
\r
547 f->state = REQSENT;
\r
552 * Pass the requested configuration options
\r
553 * to protocol-specific code for checking.
\r
555 if (f->callbacks->reqci){ /* Check CI */
\r
556 reject_if_disagree = (f->nakloops >= f->maxnakloops);
\r
557 code = (*f->callbacks->reqci)(f, inp, &len, reject_if_disagree);
\r
560 code = CONFREJ; /* Reject all CI */
\r
564 /* send the Ack, Nak or Rej to the peer */
\r
565 fsm_sdata(f, (u_char)code, id, inp, len);
\r
567 if (code == CONFACK) {
\r
568 if (f->state == ACKRCVD) {
\r
569 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
571 if (f->callbacks->up)
\r
572 (*f->callbacks->up)(f); /* Inform upper layers */
\r
575 f->state = ACKSENT;
\r
579 /* we sent CONFACK or CONFREJ */
\r
580 if (f->state != ACKRCVD)
\r
581 f->state = REQSENT;
\r
582 if( code == CONFNAK )
\r
589 * fsm_rconfack - Receive Configure-Ack.
\r
591 static void fsm_rconfack(fsm *f, int id, u_char *inp, int len)
\r
593 FSMDEBUG((LOG_INFO, "fsm_rconfack(%s): Rcvd id %d state=%d\n",
\r
594 PROTO_NAME(f), id, f->state));
\r
596 if (id != f->reqid || f->seen_ack) /* Expected id? */
\r
597 return; /* Nope, toss... */
\r
598 if( !(f->callbacks->ackci? (*f->callbacks->ackci)(f, inp, len):
\r
600 /* Ack is bad - ignore it */
\r
601 FSMDEBUG((LOG_INFO, "%s: received bad Ack (length %d)\n",
\r
602 PROTO_NAME(f), len));
\r
607 switch (f->state) {
\r
610 fsm_sdata(f, TERMACK, (u_char)id, NULL, 0);
\r
614 f->state = ACKRCVD;
\r
615 f->retransmits = f->maxconfreqtransmits;
\r
619 /* Huh? an extra valid Ack? oh well... */
\r
620 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
621 fsm_sconfreq(f, 0);
\r
622 f->state = REQSENT;
\r
626 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
628 f->retransmits = f->maxconfreqtransmits;
\r
629 if (f->callbacks->up)
\r
630 (*f->callbacks->up)(f); /* Inform upper layers */
\r
634 /* Go down and restart negotiation */
\r
635 if (f->callbacks->down)
\r
636 (*f->callbacks->down)(f); /* Inform upper layers */
\r
637 fsm_sconfreq(f, 0); /* Send initial Configure-Request */
\r
638 f->state = REQSENT;
\r
645 * fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject.
\r
647 static void fsm_rconfnakrej(fsm *f, int code, int id, u_char *inp, int len)
\r
649 int (*proc) (fsm *, u_char *, int);
\r
652 FSMDEBUG((LOG_INFO, "fsm_rconfnakrej(%s): Rcvd id %d state=%d\n",
\r
653 PROTO_NAME(f), id, f->state));
\r
655 if (id != f->reqid || f->seen_ack) /* Expected id? */
\r
656 return; /* Nope, toss... */
\r
657 proc = (code == CONFNAK)? f->callbacks->nakci: f->callbacks->rejci;
\r
658 if (!proc || !(ret = proc(f, inp, len))) {
\r
659 /* Nak/reject is bad - ignore it */
\r
660 FSMDEBUG((LOG_INFO, "%s: received bad %s (length %d)\n",
\r
661 PROTO_NAME(f), (code==CONFNAK? "Nak": "reject"), len));
\r
666 switch (f->state) {
\r
669 fsm_sdata(f, TERMACK, (u_char)id, NULL, 0);
\r
674 /* They didn't agree to what we wanted - try another request */
\r
675 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
677 f->state = STOPPED; /* kludge for stopping CCP */
\r
679 fsm_sconfreq(f, 0); /* Send Configure-Request */
\r
683 /* Got a Nak/reject when we had already had an Ack?? oh well... */
\r
684 UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */
\r
685 fsm_sconfreq(f, 0);
\r
686 f->state = REQSENT;
\r
690 /* Go down and restart negotiation */
\r
691 if (f->callbacks->down)
\r
692 (*f->callbacks->down)(f); /* Inform upper layers */
\r
693 fsm_sconfreq(f, 0); /* Send initial Configure-Request */
\r
694 f->state = REQSENT;
\r
701 * fsm_rtermreq - Receive Terminate-Req.
\r
703 static void fsm_rtermreq(fsm *f, int id, u_char *p, int len)
\r
705 FSMDEBUG((LOG_INFO, "fsm_rtermreq(%s): Rcvd id %d state=%d\n",
\r
706 PROTO_NAME(f), id, f->state));
\r
708 switch (f->state) {
\r
711 f->state = REQSENT; /* Start over but keep trying */
\r
716 FSMDEBUG((LOG_INFO, "%s terminated by peer (%x)\n", PROTO_NAME(f), p));
\r
718 FSMDEBUG((LOG_INFO, "%s terminated by peer\n", PROTO_NAME(f)));
\r
720 if (f->callbacks->down)
\r
721 (*f->callbacks->down)(f); /* Inform upper layers */
\r
722 f->retransmits = 0;
\r
723 f->state = STOPPING;
\r
724 TIMEOUT(fsm_timeout, f, f->timeouttime);
\r
728 fsm_sdata(f, TERMACK, (u_char)id, NULL, 0);
\r
733 * fsm_rtermack - Receive Terminate-Ack.
\r
735 static void fsm_rtermack(fsm *f)
\r
737 FSMDEBUG((LOG_INFO, "fsm_rtermack(%s): state=%d\n",
\r
738 PROTO_NAME(f), f->state));
\r
740 switch (f->state) {
\r
742 UNTIMEOUT(fsm_timeout, f);
\r
744 if( f->callbacks->finished )
\r
745 (*f->callbacks->finished)(f);
\r
748 UNTIMEOUT(fsm_timeout, f);
\r
749 f->state = STOPPED;
\r
750 if( f->callbacks->finished )
\r
751 (*f->callbacks->finished)(f);
\r
755 f->state = REQSENT;
\r
759 if (f->callbacks->down)
\r
760 (*f->callbacks->down)(f); /* Inform upper layers */
\r
761 fsm_sconfreq(f, 0);
\r
768 * fsm_rcoderej - Receive an Code-Reject.
\r
770 static void fsm_rcoderej(fsm *f, u_char *inp, int len)
\r
774 FSMDEBUG((LOG_INFO, "fsm_rcoderej(%s): state=%d\n",
\r
775 PROTO_NAME(f), f->state));
\r
777 if (len < HEADERLEN) {
\r
778 FSMDEBUG((LOG_INFO, "fsm_rcoderej: Rcvd short Code-Reject packet!\n"));
\r
781 GETCHAR(code, inp);
\r
783 FSMDEBUG((LOG_WARNING, "%s: Rcvd Code-Reject for code %d, id %d\n",
\r
784 PROTO_NAME(f), code, id));
\r
786 if( f->state == ACKRCVD )
\r
787 f->state = REQSENT;
\r
792 * fsm_sconfreq - Send a Configure-Request.
\r
794 static void fsm_sconfreq(fsm *f, int retransmit)
\r
799 if( f->state != REQSENT && f->state != ACKRCVD && f->state != ACKSENT ){
\r
800 /* Not currently negotiating - reset options */
\r
801 if( f->callbacks->resetci )
\r
802 (*f->callbacks->resetci)(f);
\r
807 /* New request - reset retransmission counter, use new ID */
\r
808 f->retransmits = f->maxconfreqtransmits;
\r
809 f->reqid = ++f->id;
\r
815 * Make up the request packet
\r
817 outp = outpacket_buf[f->unit] + PPP_HDRLEN + HEADERLEN;
\r
818 if( f->callbacks->cilen && f->callbacks->addci ){
\r
819 cilen = (*f->callbacks->cilen)(f);
\r
820 if( cilen > peer_mru[f->unit] - (int)HEADERLEN )
\r
821 cilen = peer_mru[f->unit] - HEADERLEN;
\r
822 if (f->callbacks->addci)
\r
823 (*f->callbacks->addci)(f, outp, &cilen);
\r
827 /* send the request to our peer */
\r
828 fsm_sdata(f, CONFREQ, f->reqid, outp, cilen);
\r
830 /* start the retransmit timer */
\r
832 TIMEOUT(fsm_timeout, f, f->timeouttime);
\r
834 FSMDEBUG((LOG_INFO, "%s: sending Configure-Request, id %d\n",
\r
835 PROTO_NAME(f), f->reqid));
\r
838 #endif /* PPP_SUPPORT */
\r