extend protocol table; supply message on protocol close
[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.10 1995/12/18 03:44:42 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));
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, *outp;
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);
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     u_char *outp;
381     int code, reject_if_disagree;
382
383     FSMDEBUG((LOG_INFO, "fsm_rconfreq(%s): Rcvd id %d.", PROTO_NAME(f), id));
384     switch( f->state ){
385     case CLOSED:
386         /* Go away, we're closed */
387         fsm_sdata(f, TERMACK, id, NULL, 0);
388         return;
389     case CLOSING:
390     case STOPPING:
391         return;
392
393     case OPENED:
394         /* Go down and restart negotiation */
395         if( f->callbacks->down )
396             (*f->callbacks->down)(f);   /* Inform upper layers */
397         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
398         break;
399
400     case STOPPED:
401         /* Negotiation started by our peer */
402         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
403         f->state = REQSENT;
404         break;
405     }
406
407     /*
408      * Pass the requested configuration options
409      * to protocol-specific code for checking.
410      */
411     if (f->callbacks->reqci){           /* Check CI */
412         reject_if_disagree = (f->nakloops >= f->maxnakloops);
413         code = (*f->callbacks->reqci)(f, inp, &len, reject_if_disagree);
414     } else if (len)
415         code = CONFREJ;                 /* Reject all CI */
416     else
417         code = CONFACK;
418
419     /* send the Ack, Nak or Rej to the peer */
420     fsm_sdata(f, code, id, inp, len);
421
422     if (code == CONFACK) {
423         if (f->state == ACKRCVD) {
424             UNTIMEOUT(fsm_timeout, (caddr_t) f);        /* Cancel timeout */
425             f->state = OPENED;
426             if (f->callbacks->up)
427                 (*f->callbacks->up)(f); /* Inform upper layers */
428         } else
429             f->state = ACKSENT;
430         f->nakloops = 0;
431
432     } else {
433         /* we sent CONFACK or CONFREJ */
434         if (f->state != ACKRCVD)
435             f->state = REQSENT;
436         if( code == CONFNAK )
437             ++f->nakloops;
438     }
439 }
440
441
442 /*
443  * fsm_rconfack - Receive Configure-Ack.
444  */
445 static void
446 fsm_rconfack(f, id, inp, len)
447     fsm *f;
448     int id;
449     u_char *inp;
450     int len;
451 {
452     FSMDEBUG((LOG_INFO, "fsm_rconfack(%s): Rcvd id %d.",
453               PROTO_NAME(f), id));
454
455     if (id != f->reqid || f->seen_ack)          /* Expected id? */
456         return;                                 /* Nope, toss... */
457     if( !(f->callbacks->ackci? (*f->callbacks->ackci)(f, inp, len):
458           (len == 0)) ){
459         /* Ack is bad - ignore it */
460         FSMDEBUG((LOG_INFO, "%s: received bad Ack (length %d)",
461                   PROTO_NAME(f), len));
462         return;
463     }
464     f->seen_ack = 1;
465
466     switch (f->state) {
467     case CLOSED:
468     case STOPPED:
469         fsm_sdata(f, TERMACK, id, NULL, 0);
470         break;
471
472     case REQSENT:
473         f->state = ACKRCVD;
474         f->retransmits = f->maxconfreqtransmits;
475         break;
476
477     case ACKRCVD:
478         /* Huh? an extra valid Ack? oh well... */
479         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
480         fsm_sconfreq(f, 0);
481         f->state = REQSENT;
482         break;
483
484     case ACKSENT:
485         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
486         f->state = OPENED;
487         f->retransmits = f->maxconfreqtransmits;
488         if (f->callbacks->up)
489             (*f->callbacks->up)(f);     /* Inform upper layers */
490         break;
491
492     case OPENED:
493         /* Go down and restart negotiation */
494         if (f->callbacks->down)
495             (*f->callbacks->down)(f);   /* Inform upper layers */
496         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
497         f->state = REQSENT;
498         break;
499     }
500 }
501
502
503 /*
504  * fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject.
505  */
506 static void
507 fsm_rconfnakrej(f, code, id, inp, len)
508     fsm *f;
509     int code, id;
510     u_char *inp;
511     int len;
512 {
513     int (*proc)();
514     int ret;
515
516     FSMDEBUG((LOG_INFO, "fsm_rconfnakrej(%s): Rcvd id %d.",
517               PROTO_NAME(f), id));
518
519     if (id != f->reqid || f->seen_ack)  /* Expected id? */
520         return;                         /* Nope, toss... */
521     proc = (code == CONFNAK)? f->callbacks->nakci: f->callbacks->rejci;
522     if (!proc || !(ret = proc(f, inp, len))) {
523         /* Nak/reject is bad - ignore it */
524         FSMDEBUG((LOG_INFO, "%s: received bad %s (length %d)",
525                   PROTO_NAME(f), (code==CONFNAK? "Nak": "reject"), len));
526         return;
527     }
528     f->seen_ack = 1;
529
530     switch (f->state) {
531     case CLOSED:
532     case STOPPED:
533         fsm_sdata(f, TERMACK, id, NULL, 0);
534         break;
535
536     case REQSENT:
537     case ACKSENT:
538         /* They didn't agree to what we wanted - try another request */
539         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
540         if (ret < 0)
541             f->state = STOPPED;         /* kludge for stopping CCP */
542         else
543             fsm_sconfreq(f, 0);         /* Send Configure-Request */
544         break;
545
546     case ACKRCVD:
547         /* Got a Nak/reject when we had already had an Ack?? oh well... */
548         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
549         fsm_sconfreq(f, 0);
550         f->state = REQSENT;
551         break;
552
553     case OPENED:
554         /* Go down and restart negotiation */
555         if (f->callbacks->down)
556             (*f->callbacks->down)(f);   /* Inform upper layers */
557         fsm_sconfreq(f, 0);             /* Send initial Configure-Request */
558         f->state = REQSENT;
559         break;
560     }
561 }
562
563
564 /*
565  * fsm_rtermreq - Receive Terminate-Req.
566  */
567 static void
568 fsm_rtermreq(f, id)
569     fsm *f;
570     int id;
571 {
572     FSMDEBUG((LOG_INFO, "fsm_rtermreq(%s): Rcvd id %d.",
573               PROTO_NAME(f), id));
574
575     switch (f->state) {
576     case ACKRCVD:
577     case ACKSENT:
578         f->state = REQSENT;             /* Start over but keep trying */
579         break;
580
581     case OPENED:
582         syslog(LOG_INFO, "%s terminated at peer's request", PROTO_NAME(f));
583         if (f->callbacks->down)
584             (*f->callbacks->down)(f);   /* Inform upper layers */
585         f->retransmits = 0;
586         f->state = STOPPING;
587         TIMEOUT(fsm_timeout, (caddr_t) f, f->timeouttime);
588         break;
589     }
590
591     fsm_sdata(f, TERMACK, id, NULL, 0);
592 }
593
594
595 /*
596  * fsm_rtermack - Receive Terminate-Ack.
597  */
598 static void
599 fsm_rtermack(f)
600     fsm *f;
601 {
602     FSMDEBUG((LOG_INFO, "fsm_rtermack(%s).", PROTO_NAME(f)));
603
604     switch (f->state) {
605     case CLOSING:
606         UNTIMEOUT(fsm_timeout, (caddr_t) f);
607         f->state = CLOSED;
608         if( f->callbacks->finished )
609             (*f->callbacks->finished)(f);
610         break;
611     case STOPPING:
612         UNTIMEOUT(fsm_timeout, (caddr_t) f);
613         f->state = STOPPED;
614         if( f->callbacks->finished )
615             (*f->callbacks->finished)(f);
616         break;
617
618     case ACKRCVD:
619         f->state = REQSENT;
620         break;
621
622     case OPENED:
623         if (f->callbacks->down)
624             (*f->callbacks->down)(f);   /* Inform upper layers */
625         fsm_sconfreq(f, 0);
626         break;
627     }
628 }
629
630
631 /*
632  * fsm_rcoderej - Receive an Code-Reject.
633  */
634 static void
635 fsm_rcoderej(f, inp, len)
636     fsm *f;
637     u_char *inp;
638     int len;
639 {
640     u_char code, id;
641
642     FSMDEBUG((LOG_INFO, "fsm_rcoderej(%s).", PROTO_NAME(f)));
643
644     if (len < HEADERLEN) {
645         FSMDEBUG((LOG_INFO, "fsm_rcoderej: Rcvd short Code-Reject packet!"));
646         return;
647     }
648     GETCHAR(code, inp);
649     GETCHAR(id, inp);
650     syslog(LOG_WARNING, "%s: Rcvd Code-Reject for code %d, id %d",
651            PROTO_NAME(f), code, id);
652
653     if( f->state == ACKRCVD )
654         f->state = REQSENT;
655 }
656
657
658 /*
659  * fsm_protreject - Peer doesn't speak this protocol.
660  *
661  * Treat this as a catastrophic error (RXJ-).
662  */
663 void
664 fsm_protreject(f)
665     fsm *f;
666 {
667     switch( f->state ){
668     case CLOSING:
669         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
670         /* fall through */
671     case CLOSED:
672         f->state = CLOSED;
673         if( f->callbacks->finished )
674             (*f->callbacks->finished)(f);
675         break;
676
677     case STOPPING:
678     case REQSENT:
679     case ACKRCVD:
680     case ACKSENT:
681         UNTIMEOUT(fsm_timeout, (caddr_t) f);    /* Cancel timeout */
682         /* fall through */
683     case STOPPED:
684         f->state = STOPPED;
685         if( f->callbacks->finished )
686             (*f->callbacks->finished)(f);
687         break;
688
689     case OPENED:
690         if( f->callbacks->down )
691             (*f->callbacks->down)(f);
692
693         /* Init restart counter, send Terminate-Request */
694         f->retransmits = f->maxtermtransmits;
695         fsm_sdata(f, TERMREQ, f->reqid = ++f->id,
696                   (u_char *) f->term_reason, f->term_reason_len);
697         TIMEOUT(fsm_timeout, (caddr_t) f, f->timeouttime);
698         --f->retransmits;
699
700         f->state = STOPPING;
701         break;
702
703     default:
704         FSMDEBUG((LOG_INFO, "%s: Protocol-reject event in state %d!",
705                   PROTO_NAME(f), f->state));
706     }
707 }
708
709
710 /*
711  * fsm_sconfreq - Send a Configure-Request.
712  */
713 static void
714 fsm_sconfreq(f, retransmit)
715     fsm *f;
716     int retransmit;
717 {
718     u_char *outp;
719     int outlen, cilen;
720
721     if( f->state != REQSENT && f->state != ACKRCVD && f->state != ACKSENT ){
722         /* Not currently negotiating - reset options */
723         if( f->callbacks->resetci )
724             (*f->callbacks->resetci)(f);
725         f->nakloops = 0;
726     }
727
728     if( !retransmit ){
729         /* New request - reset retransmission counter, use new ID */
730         f->retransmits = f->maxconfreqtransmits;
731         f->reqid = ++f->id;
732     }
733
734     f->seen_ack = 0;
735
736     /*
737      * Make up the request packet
738      */
739     outp = outpacket_buf + PPP_HDRLEN + HEADERLEN;
740     if( f->callbacks->cilen && f->callbacks->addci ){
741         cilen = (*f->callbacks->cilen)(f);
742         if( cilen > peer_mru[f->unit] - HEADERLEN )
743             cilen = peer_mru[f->unit] - HEADERLEN;
744         if (f->callbacks->addci)
745             (*f->callbacks->addci)(f, outp, &cilen);
746     } else
747         cilen = 0;
748
749     /* send the request to our peer */
750     fsm_sdata(f, CONFREQ, f->reqid, outp, cilen);
751
752     /* start the retransmit timer */
753     --f->retransmits;
754     TIMEOUT(fsm_timeout, (caddr_t) f, f->timeouttime);
755
756     FSMDEBUG((LOG_INFO, "%s: sending Configure-Request, id %d",
757               PROTO_NAME(f), f->reqid));
758 }
759
760
761 /*
762  * fsm_sdata - Send some data.
763  *
764  * Used for all packets sent to our peer by this module.
765  */
766 void
767 fsm_sdata(f, code, id, data, datalen)
768     fsm *f;
769     u_char code, id;
770     u_char *data;
771     int datalen;
772 {
773     u_char *outp;
774     int outlen;
775
776     /* Adjust length to be smaller than MTU */
777     outp = outpacket_buf;
778     if (datalen > peer_mru[f->unit] - HEADERLEN)
779         datalen = peer_mru[f->unit] - HEADERLEN;
780     if (datalen && data != outp + PPP_HDRLEN + HEADERLEN)
781         BCOPY(data, outp + PPP_HDRLEN + HEADERLEN, datalen);
782     outlen = datalen + HEADERLEN;
783     MAKEHEADER(outp, f->protocol);
784     PUTCHAR(code, outp);
785     PUTCHAR(id, outp);
786     PUTSHORT(outlen, outp);
787     output(f->unit, outpacket_buf, outlen + PPP_HDRLEN);
788
789     FSMDEBUG((LOG_INFO, "fsm_sdata(%s): Sent code %d, id %d.",
790               PROTO_NAME(f), code, id));
791 }