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