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