moved protos here from ipcp.h; print reason on terminate-request;
[ppp.git] / pppd / fsm.c
1 /*
2  * fsm.c - {Link, IP} Control Protocol Finite State Machine.
3  *
4  * Copyright (c) 1989 Carnegie Mellon University.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms are permitted
8  * provided that the above copyright notice and this paragraph are
9  * duplicated in all such forms and that any documentation,
10  * advertising materials, and other materials related to such
11  * distribution and use acknowledge that the software was developed
12  * by Carnegie Mellon University.  The name of the
13  * University may not be used to endorse or promote products derived
14  * from this software without specific prior written permission.
15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18  */
19
20 #ifndef lint
21 static char rcsid[] = "$Id: fsm.c,v 1.12 1996/07/01 01:13:11 paulus Exp $";
22 #endif
23
24 /*
25  * TODO:
26  * Randomize fsm id on link/init.
27  * Deal with variable outgoing MTU.
28  */
29
30 #include <stdio.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <syslog.h>
34
35 #include "pppd.h"
36 #include "fsm.h"
37
38 extern char *proto_name();
39
40 static void fsm_timeout __P((caddr_t));
41 static void fsm_rconfreq __P((fsm *, int, u_char *, int));
42 static void fsm_rconfack __P((fsm *, int, u_char *, int));
43 static void fsm_rconfnakrej __P((fsm *, int, int, u_char *, int));
44 static void fsm_rtermreq __P((fsm *, int, u_char *, int));
45 static void fsm_rtermack __P((fsm *));
46 static void fsm_rcoderej __P((fsm *, u_char *, int));
47 static void fsm_sconfreq __P((fsm *, int));
48
49 #define PROTO_NAME(f)   ((f)->callbacks->proto_name)
50
51 int peer_mru[NUM_PPP];
52
53
54 /*
55  * fsm_init - Initialize fsm.
56  *
57  * Initialize fsm state.
58  */
59 void
60 fsm_init(f)
61     fsm *f;
62 {
63     f->state = INITIAL;
64     f->flags = 0;
65     f->id = 0;                          /* XXX Start with random id? */
66     f->timeouttime = DEFTIMEOUT;
67     f->maxconfreqtransmits = DEFMAXCONFREQS;
68     f->maxtermtransmits = DEFMAXTERMREQS;
69     f->maxnakloops = DEFMAXNAKLOOPS;
70     f->term_reason_len = 0;
71 }
72
73
74 /*
75  * fsm_lowerup - The lower layer is up.
76  */
77 void
78 fsm_lowerup(f)
79     fsm *f;
80 {
81     switch( f->state ){
82     case INITIAL:
83         f->state = CLOSED;
84         break;
85
86     case STARTING:
87         if( f->flags & OPT_SILENT )
88             f->state = STOPPED;
89         else {
90             /* Send an initial configure-request */
91             fsm_sconfreq(f, 0);
92             f->state = REQSENT;
93         }
94         break;
95
96     default:
97         FSMDEBUG((LOG_INFO, "%s: Up event in state %d!",
98                   PROTO_NAME(f), f->state));
99     }
100 }
101
102
103 /*
104  * fsm_lowerdown - The lower layer is down.
105  *
106  * Cancel all timeouts and inform upper layers.
107  */
108 void
109 fsm_lowerdown(f)
110     fsm *f;
111 {
112     switch( f->state ){
113     case CLOSED:
114         f->state = INITIAL;
115         break;
116
117     case STOPPED:
118         f->state = STARTING;
119         if( f->callbacks->starting )
120             (*f->callbacks->starting)(f);
121         break;
122
123     case CLOSING:
124         f->state = INITIAL;
125         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
126         break;
127
128     case STOPPING:
129     case REQSENT:
130     case ACKRCVD:
131     case ACKSENT:
132         f->state = STARTING;
133         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
134         break;
135
136     case OPENED:
137         if( f->callbacks->down )
138             (*f->callbacks->down)(f);
139         f->state = STARTING;
140         break;
141
142     default:
143         FSMDEBUG((LOG_INFO, "%s: Down event in state %d!",
144                   PROTO_NAME(f), f->state));
145     }
146 }
147
148
149 /*
150  * fsm_open - Link is allowed to come up.
151  */
152 void
153 fsm_open(f)
154     fsm *f;
155 {
156     switch( f->state ){
157     case INITIAL:
158         f->state = STARTING;
159         if( f->callbacks->starting )
160             (*f->callbacks->starting)(f);
161         break;
162
163     case CLOSED:
164         if( f->flags & OPT_SILENT )
165             f->state = STOPPED;
166         else {
167             /* Send an initial configure-request */
168             fsm_sconfreq(f, 0);
169             f->state = REQSENT;
170         }
171         break;
172
173     case CLOSING:
174         f->state = STOPPING;
175         /* fall through */
176     case STOPPED:
177     case OPENED:
178         if( f->flags & OPT_RESTART ){
179             fsm_lowerdown(f);
180             fsm_lowerup(f);
181         }
182         break;
183     }
184 }
185
186
187 /*
188  * fsm_close - Start closing connection.
189  *
190  * Cancel timeouts and either initiate close or possibly go directly to
191  * the CLOSED state.
192  */
193 void
194 fsm_close(f, reason)
195     fsm *f;
196     char *reason;
197 {
198     f->term_reason = reason;
199     f->term_reason_len = (reason == NULL? 0: strlen(reason));
200     switch( f->state ){
201     case STARTING:
202         f->state = INITIAL;
203         break;
204     case STOPPED:
205         f->state = CLOSED;
206         break;
207     case STOPPING:
208         f->state = CLOSING;
209         break;
210
211     case REQSENT:
212     case ACKRCVD:
213     case ACKSENT:
214     case OPENED:
215         if( f->state != OPENED )
216             UNTIMEOUT(fsm_timeout, (caddr_t) f);        /* Cancel timeout */
217         else if( f->callbacks->down )
218             (*f->callbacks->down)(f);   /* Inform upper layers we're down */
219
220         /* Init restart counter, send Terminate-Request */
221         f->retransmits = f->maxtermtransmits;
222         fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
223                   (u_char *) f->term_reason, f->term_reason_len);
224         TIMEOUT(fsm_timeout, (caddr_t) f, f->timeouttime);
225         --f->retransmits;
226
227         f->state = CLOSING;
228         break;
229     }
230 }
231
232
233 /*
234  * fsm_timeout - Timeout expired.
235  */
236 static void
237 fsm_timeout(arg)
238     caddr_t arg;
239 {
240     fsm *f = (fsm *) arg;
241
242     switch (f->state) {
243     case CLOSING:
244     case STOPPING:
245         if( f->retransmits <= 0 ){
246             /*
247              * We've waited for an ack long enough.  Peer probably heard us.
248              */
249             f->state = (f->state == CLOSING)? CLOSED: STOPPED;
250             if( f->callbacks->finished )
251                 (*f->callbacks->finished)(f);
252         } else {
253             /* Send Terminate-Request */
254             fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
255                       (u_char *) f->term_reason, f->term_reason_len);
256             TIMEOUT(fsm_timeout, (caddr_t) f, f->timeouttime);
257             --f->retransmits;
258         }
259         break;
260
261     case REQSENT:
262     case ACKRCVD:
263     case ACKSENT:
264         if (f->retransmits <= 0) {
265             syslog(LOG_WARNING, "%s: timeout sending Config-Requests",
266                    PROTO_NAME(f));
267             f->state = STOPPED;
268             if( (f->flags & OPT_PASSIVE) == 0 && f->callbacks->finished )
269                 (*f->callbacks->finished)(f);
270
271         } else {
272             /* Retransmit the configure-request */
273             if (f->callbacks->retransmit)
274                 (*f->callbacks->retransmit)(f);
275             fsm_sconfreq(f, 1);         /* Re-send Configure-Request */
276             if( f->state == ACKRCVD )
277                 f->state = REQSENT;
278         }
279         break;
280
281     default:
282         FSMDEBUG((LOG_INFO, "%s: Timeout event in state %d!",
283                   PROTO_NAME(f), f->state));
284     }
285 }
286
287
288 /*
289  * fsm_input - Input packet.
290  */
291 void
292 fsm_input(f, inpacket, l)
293     fsm *f;
294     u_char *inpacket;
295     int l;
296 {
297     u_char *inp;
298     u_char code, id;
299     int len;
300
301     /*
302      * Parse header (code, id and length).
303      * If packet too short, drop it.
304      */
305     inp = inpacket;
306     if (l < HEADERLEN) {
307         FSMDEBUG((LOG_WARNING, "fsm_input(%x): Rcvd short header.",
308                   f->protocol));
309         return;
310     }
311     GETCHAR(code, inp);
312     GETCHAR(id, inp);
313     GETSHORT(len, inp);
314     if (len < HEADERLEN) {
315         FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd illegal length.",
316                   f->protocol));
317         return;
318     }
319     if (len > l) {
320         FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd short packet.",
321                   f->protocol));
322         return;
323     }
324     len -= HEADERLEN;           /* subtract header length */
325
326     if( f->state == INITIAL || f->state == STARTING ){
327         FSMDEBUG((LOG_INFO, "fsm_input(%x): Rcvd packet in state %d.",
328                   f->protocol, f->state));
329         return;
330     }
331
332     /*
333      * Action depends on code.
334      */
335     switch (code) {
336     case CONFREQ:
337         fsm_rconfreq(f, id, inp, len);
338         break;
339     
340     case CONFACK:
341         fsm_rconfack(f, id, inp, len);
342         break;
343     
344     case CONFNAK:
345     case CONFREJ:
346         fsm_rconfnakrej(f, code, id, inp, len);
347         break;
348     
349     case TERMREQ:
350         fsm_rtermreq(f, id, inp, len);
351         break;
352     
353     case TERMACK:
354         fsm_rtermack(f);
355         break;
356     
357     case CODEREJ:
358         fsm_rcoderej(f, inp, len);
359         break;
360     
361     default:
362         if( !f->callbacks->extcode
363            || !(*f->callbacks->extcode)(f, code, id, inp, len) )
364             fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN);
365         break;
366     }
367 }
368
369
370 /*
371  * fsm_rconfreq - Receive Configure-Request.
372  */
373 static void
374 fsm_rconfreq(f, id, inp, len)
375     fsm *f;
376     u_char id;
377     u_char *inp;
378     int len;
379 {
380     int code, reject_if_disagree;
381
382     FSMDEBUG((LOG_INFO, "fsm_rconfreq(%s): Rcvd id %d.", PROTO_NAME(f), id));
383     switch( f->state ){
384     case CLOSED:
385         /* Go away, we're closed */
386         fsm_sdata(f, TERMACK, id, NULL, 0);
387         return;
388     case CLOSING:
389     case STOPPING:
390         return;
391
392     case OPENED:
393         /* Go down and restart negotiation */
394         if( f->callbacks->down )
395             (*f->callbacks->down)(f);   /* Inform upper layers */
396         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
397         break;
398
399     case STOPPED:
400         /* Negotiation started by our peer */
401         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
402         f->state = REQSENT;
403         break;
404     }
405
406     /*
407      * Pass the requested configuration options
408      * to protocol-specific code for checking.
409      */
410     if (f->callbacks->reqci){           /* Check CI */
411         reject_if_disagree = (f->nakloops >= f->maxnakloops);
412         code = (*f->callbacks->reqci)(f, inp, &len, reject_if_disagree);
413     } else if (len)
414         code = CONFREJ;                 /* Reject all CI */
415     else
416         code = CONFACK;
417
418     /* send the Ack, Nak or Rej to the peer */
419     fsm_sdata(f, code, id, inp, len);
420
421     if (code == CONFACK) {
422         if (f->state == ACKRCVD) {
423             UNTIMEOUT(fsm_timeout, (caddr_t) f);        /* Cancel timeout */
424             f->state = OPENED;
425             if (f->callbacks->up)
426                 (*f->callbacks->up)(f); /* Inform upper layers */
427         } else
428             f->state = ACKSENT;
429         f->nakloops = 0;
430
431     } else {
432         /* we sent CONFACK or CONFREJ */
433         if (f->state != ACKRCVD)
434             f->state = REQSENT;
435         if( code == CONFNAK )
436             ++f->nakloops;
437     }
438 }
439
440
441 /*
442  * fsm_rconfack - Receive Configure-Ack.
443  */
444 static void
445 fsm_rconfack(f, id, inp, len)
446     fsm *f;
447     int id;
448     u_char *inp;
449     int len;
450 {
451     FSMDEBUG((LOG_INFO, "fsm_rconfack(%s): Rcvd id %d.",
452               PROTO_NAME(f), id));
453
454     if (id != f->reqid || f->seen_ack)          /* Expected id? */
455         return;                                 /* Nope, toss... */
456     if( !(f->callbacks->ackci? (*f->callbacks->ackci)(f, inp, len):
457           (len == 0)) ){
458         /* Ack is bad - ignore it */
459         FSMDEBUG((LOG_INFO, "%s: received bad Ack (length %d)",
460                   PROTO_NAME(f), len));
461         return;
462     }
463     f->seen_ack = 1;
464
465     switch (f->state) {
466     case CLOSED:
467     case STOPPED:
468         fsm_sdata(f, TERMACK, id, NULL, 0);
469         break;
470
471     case REQSENT:
472         f->state = ACKRCVD;
473         f->retransmits = f->maxconfreqtransmits;
474         break;
475
476     case ACKRCVD:
477         /* Huh? an extra valid Ack? oh well... */
478         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
479         fsm_sconfreq(f, 0);
480         f->state = REQSENT;
481         break;
482
483     case ACKSENT:
484         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
485         f->state = OPENED;
486         f->retransmits = f->maxconfreqtransmits;
487         if (f->callbacks->up)
488             (*f->callbacks->up)(f);     /* Inform upper layers */
489         break;
490
491     case OPENED:
492         /* Go down and restart negotiation */
493         if (f->callbacks->down)
494             (*f->callbacks->down)(f);   /* Inform upper layers */
495         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
496         f->state = REQSENT;
497         break;
498     }
499 }
500
501
502 /*
503  * fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject.
504  */
505 static void
506 fsm_rconfnakrej(f, code, id, inp, len)
507     fsm *f;
508     int code, id;
509     u_char *inp;
510     int len;
511 {
512     int (*proc)();
513     int ret;
514
515     FSMDEBUG((LOG_INFO, "fsm_rconfnakrej(%s): Rcvd id %d.",
516               PROTO_NAME(f), id));
517
518     if (id != f->reqid || f->seen_ack)  /* Expected id? */
519         return;                         /* Nope, toss... */
520     proc = (code == CONFNAK)? f->callbacks->nakci: f->callbacks->rejci;
521     if (!proc || !(ret = proc(f, inp, len))) {
522         /* Nak/reject is bad - ignore it */
523         FSMDEBUG((LOG_INFO, "%s: received bad %s (length %d)",
524                   PROTO_NAME(f), (code==CONFNAK? "Nak": "reject"), len));
525         return;
526     }
527     f->seen_ack = 1;
528
529     switch (f->state) {
530     case CLOSED:
531     case STOPPED:
532         fsm_sdata(f, TERMACK, id, NULL, 0);
533         break;
534
535     case REQSENT:
536     case ACKSENT:
537         /* They didn't agree to what we wanted - try another request */
538         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
539         if (ret < 0)
540             f->state = STOPPED;         /* kludge for stopping CCP */
541         else
542             fsm_sconfreq(f, 0);         /* Send Configure-Request */
543         break;
544
545     case ACKRCVD:
546         /* Got a Nak/reject when we had already had an Ack?? oh well... */
547         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
548         fsm_sconfreq(f, 0);
549         f->state = REQSENT;
550         break;
551
552     case OPENED:
553         /* Go down and restart negotiation */
554         if (f->callbacks->down)
555             (*f->callbacks->down)(f);   /* Inform upper layers */
556         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
557         f->state = REQSENT;
558         break;
559     }
560 }
561
562
563 /*
564  * fsm_rtermreq - Receive Terminate-Req.
565  */
566 static void
567 fsm_rtermreq(f, id, p, len)
568     fsm *f;
569     int id;
570     u_char *p;
571     int len;
572 {
573     char str[80];
574
575     FSMDEBUG((LOG_INFO, "fsm_rtermreq(%s): Rcvd id %d.",
576               PROTO_NAME(f), id));
577
578     switch (f->state) {
579     case ACKRCVD:
580     case ACKSENT:
581         f->state = REQSENT;             /* Start over but keep trying */
582         break;
583
584     case OPENED:
585         if (len > 0) {
586             fmtmsg(str, sizeof(str), "%0.*v", len, p);
587             syslog(LOG_INFO, "%s terminated by peer (%s)", PROTO_NAME(f), str);
588         } else
589             syslog(LOG_INFO, "%s terminated by peer", PROTO_NAME(f));
590         if (f->callbacks->down)
591             (*f->callbacks->down)(f);   /* Inform upper layers */
592         f->retransmits = 0;
593         f->state = STOPPING;
594         TIMEOUT(fsm_timeout, (caddr_t) f, f->timeouttime);
595         break;
596     }
597
598     fsm_sdata(f, TERMACK, id, NULL, 0);
599 }
600
601
602 /*
603  * fsm_rtermack - Receive Terminate-Ack.
604  */
605 static void
606 fsm_rtermack(f)
607     fsm *f;
608 {
609     FSMDEBUG((LOG_INFO, "fsm_rtermack(%s).", PROTO_NAME(f)));
610
611     switch (f->state) {
612     case CLOSING:
613         UNTIMEOUT(fsm_timeout, (caddr_t) f);
614         f->state = CLOSED;
615         if( f->callbacks->finished )
616             (*f->callbacks->finished)(f);
617         break;
618     case STOPPING:
619         UNTIMEOUT(fsm_timeout, (caddr_t) f);
620         f->state = STOPPED;
621         if( f->callbacks->finished )
622             (*f->callbacks->finished)(f);
623         break;
624
625     case ACKRCVD:
626         f->state = REQSENT;
627         break;
628
629     case OPENED:
630         if (f->callbacks->down)
631             (*f->callbacks->down)(f);   /* Inform upper layers */
632         fsm_sconfreq(f, 0);
633         break;
634     }
635 }
636
637
638 /*
639  * fsm_rcoderej - Receive an Code-Reject.
640  */
641 static void
642 fsm_rcoderej(f, inp, len)
643     fsm *f;
644     u_char *inp;
645     int len;
646 {
647     u_char code, id;
648
649     FSMDEBUG((LOG_INFO, "fsm_rcoderej(%s).", PROTO_NAME(f)));
650
651     if (len < HEADERLEN) {
652         FSMDEBUG((LOG_INFO, "fsm_rcoderej: Rcvd short Code-Reject packet!"));
653         return;
654     }
655     GETCHAR(code, inp);
656     GETCHAR(id, inp);
657     syslog(LOG_WARNING, "%s: Rcvd Code-Reject for code %d, id %d",
658            PROTO_NAME(f), code, id);
659
660     if( f->state == ACKRCVD )
661         f->state = REQSENT;
662 }
663
664
665 /*
666  * fsm_protreject - Peer doesn't speak this protocol.
667  *
668  * Treat this as a catastrophic error (RXJ-).
669  */
670 void
671 fsm_protreject(f)
672     fsm *f;
673 {
674     switch( f->state ){
675     case CLOSING:
676         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
677         /* fall through */
678     case CLOSED:
679         f->state = CLOSED;
680         if( f->callbacks->finished )
681             (*f->callbacks->finished)(f);
682         break;
683
684     case STOPPING:
685     case REQSENT:
686     case ACKRCVD:
687     case ACKSENT:
688         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
689         /* fall through */
690     case STOPPED:
691         f->state = STOPPED;
692         if( f->callbacks->finished )
693             (*f->callbacks->finished)(f);
694         break;
695
696     case OPENED:
697         if( f->callbacks->down )
698             (*f->callbacks->down)(f);
699
700         /* Init restart counter, send Terminate-Request */
701         f->retransmits = f->maxtermtransmits;
702         fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
703                   (u_char *) f->term_reason, f->term_reason_len);
704         TIMEOUT(fsm_timeout, (caddr_t) f, f->timeouttime);
705         --f->retransmits;
706
707         f->state = STOPPING;
708         break;
709
710     default:
711         FSMDEBUG((LOG_INFO, "%s: Protocol-reject event in state %d!",
712                   PROTO_NAME(f), f->state));
713     }
714 }
715
716
717 /*
718  * fsm_sconfreq - Send a Configure-Request.
719  */
720 static void
721 fsm_sconfreq(f, retransmit)
722     fsm *f;
723     int retransmit;
724 {
725     u_char *outp;
726     int cilen;
727
728     if( f->state != REQSENT && f->state != ACKRCVD && f->state != ACKSENT ){
729         /* Not currently negotiating - reset options */
730         if( f->callbacks->resetci )
731             (*f->callbacks->resetci)(f);
732         f->nakloops = 0;
733     }
734
735     if( !retransmit ){
736         /* New request - reset retransmission counter, use new ID */
737         f->retransmits = f->maxconfreqtransmits;
738         f->reqid = ++f->id;
739     }
740
741     f->seen_ack = 0;
742
743     /*
744      * Make up the request packet
745      */
746     outp = outpacket_buf + PPP_HDRLEN + HEADERLEN;
747     if( f->callbacks->cilen && f->callbacks->addci ){
748         cilen = (*f->callbacks->cilen)(f);
749         if( cilen > peer_mru[f->unit] - HEADERLEN )
750             cilen = peer_mru[f->unit] - HEADERLEN;
751         if (f->callbacks->addci)
752             (*f->callbacks->addci)(f, outp, &cilen);
753     } else
754         cilen = 0;
755
756     /* send the request to our peer */
757     fsm_sdata(f, CONFREQ, f->reqid, outp, cilen);
758
759     /* start the retransmit timer */
760     --f->retransmits;
761     TIMEOUT(fsm_timeout, (caddr_t) f, f->timeouttime);
762
763     FSMDEBUG((LOG_INFO, "%s: sending Configure-Request, id %d",
764               PROTO_NAME(f), f->reqid));
765 }
766
767
768 /*
769  * fsm_sdata - Send some data.
770  *
771  * Used for all packets sent to our peer by this module.
772  */
773 void
774 fsm_sdata(f, code, id, data, datalen)
775     fsm *f;
776     u_char code, id;
777     u_char *data;
778     int datalen;
779 {
780     u_char *outp;
781     int outlen;
782
783     /* Adjust length to be smaller than MTU */
784     outp = outpacket_buf;
785     if (datalen > peer_mru[f->unit] - HEADERLEN)
786         datalen = peer_mru[f->unit] - HEADERLEN;
787     if (datalen && data != outp + PPP_HDRLEN + HEADERLEN)
788         BCOPY(data, outp + PPP_HDRLEN + HEADERLEN, datalen);
789     outlen = datalen + HEADERLEN;
790     MAKEHEADER(outp, f->protocol);
791     PUTCHAR(code, outp);
792     PUTCHAR(id, outp);
793     PUTSHORT(outlen, outp);
794     output(f->unit, outpacket_buf, outlen + PPP_HDRLEN);
795
796     FSMDEBUG((LOG_INFO, "fsm_sdata(%s): Sent code %d, id %d.",
797               PROTO_NAME(f), code, id));
798 }