1:
2: /*
3: * fsm.c
4: *
5: * Written by Toshiharu OHNO <tony-o@iij.ad.jp>
6: * Copyright (c) 1993, Internet Initiative Japan, Inc. All rights reserved.
7: * See ``COPYRIGHT.iij''
8: *
9: * Rewritten by Archie Cobbs <archie@freebsd.org>
10: * Copyright (c) 1995-1999 Whistle Communications, Inc. All rights reserved.
11: * See ``COPYRIGHT.whistle''
12: */
13:
14: #include "ppp.h"
15: #include "fsm.h"
16: #include "ngfunc.h"
17: #include "util.h"
18:
19: /*
20: * DEFINITIONS
21: */
22:
23: #define FSM_MAXCONFIG 10
24: #define FSM_MAXNAK 10
25: #define FSM_MAX_OPTS 100
26: #define FSM_MAXTERMINATE 2
27: #define FSM_MAXFAILURE 5
28:
29: /* FSM restart options */
30:
31: /* #define RESTART_OPENED */
32: /* #define RESTART_CLOSING */
33: /* #define RESTART_STOPPED */
34:
35: struct fsmcodedesc {
36: void (*action)(Fsm fp, FsmHeader hdr, Mbuf bp);
37: const char *name;
38: };
39:
40: /* Size of REQ, ACK, NAK, and REJ buffers */
41:
42: #define REQ_BUFFER_SIZE 256
43: #define REJ_BUFFER_SIZE 256
44: #define ACK_BUFFER_SIZE 256
45: #define NAK_BUFFER_SIZE 256
46:
47: /*
48: * INTERNAL FUNCTIONS
49: */
50:
51: static void FsmNewState(Fsm f, enum fsm_state state);
52:
53: static void FsmSendConfigReq(Fsm fp);
54: static void FsmSendTerminateReq(Fsm fp);
55: static void FsmSendTerminateAck(Fsm fp);
56: static void FsmInitRestartCounter(Fsm fp, int value);
57: static void FsmInitMaxFailure(Fsm fp, int value);
58: static void FsmInitMaxConfig(Fsm fp, int value);
59: static void FsmTimeout(void *arg);
60:
61: static void FsmRecvConfigReq(Fsm fp, FsmHeader lhp, Mbuf bp);
62: static void FsmRecvConfigAck(Fsm fp, FsmHeader lhp, Mbuf bp);
63: static void FsmRecvConfigNak(Fsm fp, FsmHeader lhp, Mbuf bp);
64: static void FsmRecvTermReq(Fsm fp, FsmHeader lhp, Mbuf bp);
65: static void FsmRecvTermAck(Fsm fp, FsmHeader lhp, Mbuf bp);
66: static void FsmRecvConfigRej(Fsm fp, FsmHeader lhp, Mbuf bp);
67: static void FsmRecvCodeRej(Fsm fp, FsmHeader lhp, Mbuf bp);
68: static void FsmRecvProtoRej(Fsm fp, FsmHeader lhp, Mbuf bp);
69: static void FsmRecvEchoReq(Fsm fp, FsmHeader lhp, Mbuf bp);
70: static void FsmRecvEchoRep(Fsm fp, FsmHeader lhp, Mbuf bp);
71: static void FsmRecvDiscReq(Fsm fp, FsmHeader lhp, Mbuf bp);
72: static void FsmRecvIdent(Fsm fp, FsmHeader lhp, Mbuf bp);
73: static void FsmRecvTimeRemain(Fsm fp, FsmHeader lhp, Mbuf bp);
74: static void FsmRecvResetReq(Fsm fp, FsmHeader lhp, Mbuf bp);
75: static void FsmRecvResetAck(Fsm fp, FsmHeader lhp, Mbuf bp);
76: static void FsmRecvVendor(Fsm fp, FsmHeader lhp, Mbuf bp);
77: static void FsmRecvRxjPlus(Fsm fp);
78:
79: static void FsmLayerUp(Fsm fp);
80: static void FsmLayerDown(Fsm fp);
81: static void FsmLayerStart(Fsm fp);
82: static void FsmLayerFinish(Fsm fp);
83:
84: static Mbuf FsmCheckMagic(Fsm fp, Mbuf bp);
85: static void FsmEchoTimeout(void *arg);
86: static void FsmDecodeBuffer(Fsm fp, u_char *buf, int size, int mode);
87: static int FsmExtractOptions(Fsm fp, u_char *data,
88: int dlen, FsmOption opts, int max);
89:
90: /*
91: * GLOBAL VARIABLES
92: */
93:
94: u_int gAckSize, gNakSize, gRejSize;
95:
96: /*
97: * INTERNAL VARIABLES
98: */
99:
100: /*
101: * It's OK for these to be statically allocated, because we always
102: * do our work with them all in one whole step without stopping.
103: */
104:
105: static u_char gRejBuf[REJ_BUFFER_SIZE];
106: static u_char gAckBuf[ACK_BUFFER_SIZE];
107: static u_char gNakBuf[NAK_BUFFER_SIZE];
108:
109: static const struct fsmcodedesc FsmCodes[] = {
110: { FsmRecvVendor, "Vendor Packet" },
111: { FsmRecvConfigReq, "Configure Request" },
112: { FsmRecvConfigAck, "Configure Ack" },
113: { FsmRecvConfigNak, "Configure Nak" },
114: { FsmRecvConfigRej, "Configure Reject" },
115: { FsmRecvTermReq, "Terminate Request" },
116: { FsmRecvTermAck, "Terminate Ack" },
117: { FsmRecvCodeRej, "Code Reject" },
118: { FsmRecvProtoRej, "Protocol Reject" },
119: { FsmRecvEchoReq, "Echo Request" },
120: { FsmRecvEchoRep, "Echo Reply" },
121: { FsmRecvDiscReq, "Discard Request" },
122: { FsmRecvIdent, "Ident" },
123: { FsmRecvTimeRemain, "Time Remain" },
124: { FsmRecvResetReq, "Reset Request" },
125: { FsmRecvResetAck, "Reset Ack" },
126: };
127:
128: #define NUM_FSM_CODES (sizeof(FsmCodes) / sizeof(*FsmCodes))
129:
130: /*
131: * FsmInit()
132: *
133: * Initialize FSM structure and install some default values
134: */
135:
136: void
137: FsmInit(Fsm fp, FsmType type, void *arg)
138: {
139: memset(fp, 0, sizeof(*fp));
140: fp->type = type;
141: fp->arg = arg;
142: fp->log = LG_FSM | type->log;
143: fp->log2 = LG_FSM | type->log2;
144: fp->conf.maxconfig = FSM_MAXCONFIG;
145: fp->conf.maxterminate = FSM_MAXTERMINATE;
146: fp->conf.maxfailure = FSM_MAXFAILURE;
147: fp->conf.check_magic = FALSE;
148: fp->conf.passive = FALSE;
149: fp->state = ST_INITIAL;
150: fp->reqid = 1;
151: fp->rejid = 1;
152: fp->echoid = 1;
153: }
154:
155: /*
156: * FsmInst()
157: *
158: * Instantiate FSM structure from template
159: */
160:
161: void
162: FsmInst(Fsm fp, Fsm fpt, void *arg)
163: {
164: memcpy(fp, fpt, sizeof(*fp));
165: fp->arg = arg;
166: }
167:
168: /*
169: * FsmNewState()
170: *
171: * Change state of a FSM. Also, call the configuration routine
172: * if this is an appropriate time.
173: */
174:
175: void
176: FsmNewState(Fsm fp, enum fsm_state new)
177: {
178: enum fsm_state old;
179:
180: /* Log it */
181: Log(fp->log2, ("[%s] %s: state change %s --> %s",
182: Pref(fp), Fsm(fp), FsmStateName(fp->state), FsmStateName(new)));
183:
184: /* Change state and call protocol's own handler, if any */
185: old = fp->state;
186: if (fp->type->NewState)
187: (*fp->type->NewState)(fp, old, new);
188: fp->state = new;
189: if ((new >= ST_INITIAL && new <= ST_STOPPED) || (new == ST_OPENED))
190: TimerStop(&fp->timer);
191:
192: /* Turn on/off keep-alive echo packets (if so configured) */
193: if (old == ST_OPENED)
194: TimerStop(&fp->echoTimer);
195: if (new == ST_OPENED && fp->conf.echo_int != 0) {
196: fp->quietCount = 0;
197: memset(&fp->idleStats, 0, sizeof(fp->idleStats));
198: TimerInit(&fp->echoTimer, "FsmKeepAlive",
199: fp->conf.echo_int * SECONDS, FsmEchoTimeout, fp);
200: TimerStartRecurring(&fp->echoTimer);
201: }
202: }
203:
204: /*
205: * FsmOutputMbuf()
206: *
207: * Send out a control packet with specified contents. Consumes the mbuf.
208: */
209:
210: void
211: FsmOutputMbuf(Fsm fp, u_int code, u_int id, Mbuf payload)
212: {
213: Bund b;
214: Mbuf bp;
215: struct fsmheader hdr;
216:
217: if (fp->type->link_layer)
218: b = ((Link)fp->arg)->bund;
219: else
220: b = (Bund)fp->arg;
221:
222: /* Build header */
223: hdr.id = id;
224: hdr.code = code;
225: hdr.length = htons(sizeof(hdr) + MBLEN(payload));
226:
227: /* Prepend to payload */
228: bp = mbcopyback(payload, -(int)sizeof(hdr), &hdr, sizeof(hdr));
229:
230: /* Send it out */
231: if (fp->type->link_layer) {
232: NgFuncWritePppFrameLink((Link)fp->arg, fp->type->proto, bp);
233: } else {
234: NgFuncWritePppFrame(b, NG_PPP_BUNDLE_LINKNUM, fp->type->proto, bp);
235: }
236: }
237:
238: /*
239: * FsmOutput()
240: *
241: * Send out a control packet with specified contents
242: */
243:
244: void
245: FsmOutput(Fsm fp, u_int code, u_int id, u_char *ptr, int len)
246: {
247: Mbuf bp;
248:
249: bp = (len > 0) ? mbcopyback(NULL, 0, ptr, len) : NULL;
250: FsmOutputMbuf(fp, code, id, bp);
251: }
252:
253: /*
254: * FsmOpen()
255: *
256: * XXX The use of the restart option should probably be
257: * XXX configured per FSM via the initialization structure.
258: * XXX For now, we just make it mandatory via #ifdef's.
259: */
260:
261: void
262: FsmOpen(Fsm fp)
263: {
264: Log(fp->log2, ("[%s] %s: Open event", Pref(fp), Fsm(fp)));
265: switch (fp->state) {
266: case ST_INITIAL:
267: FsmNewState(fp, ST_STARTING);
268: FsmLayerStart(fp);
269: break;
270: case ST_STARTING:
271: break;
272: case ST_CLOSED:
273: if (fp->type->Configure)
274: (*fp->type->Configure)(fp);
275: FsmNewState(fp, ST_REQSENT);
276: FsmLayerStart(fp); /* Missing in RFC 1661 */
277: FsmInitRestartCounter(fp, fp->conf.maxconfig);
278: FsmInitMaxFailure(fp, fp->conf.maxfailure);
279: FsmInitMaxConfig(fp, fp->conf.maxconfig);
280: FsmSendConfigReq(fp);
281: break;
282: case ST_REQSENT:
283: case ST_ACKRCVD:
284: case ST_ACKSENT:
285: break;
286:
287: case ST_OPENED:
288: #ifdef RESTART_OPENED
289: FsmDown(fp);
290: FsmUp(fp);
291: #endif
292: break;
293:
294: case ST_CLOSING:
295: FsmNewState(fp, ST_STOPPING);
296: case ST_STOPPING:
297: #ifdef RESTART_CLOSING
298: FsmDown(fp);
299: FsmUp(fp);
300: #endif
301: break;
302:
303: case ST_STOPPED:
304: #ifdef RESTART_STOPPED
305: FsmDown(fp);
306: FsmUp(fp);
307: #endif
308: break;
309: }
310: }
311:
312: void
313: FsmUp(Fsm fp)
314: {
315: Log(fp->log2, ("[%s] %s: Up event", Pref(fp), Fsm(fp)));
316: switch (fp->state) {
317: case ST_INITIAL:
318: FsmNewState(fp, ST_CLOSED);
319: break;
320: case ST_STARTING:
321: if (fp->type->Configure)
322: (*fp->type->Configure)(fp);
323: FsmNewState(fp, ST_REQSENT);
324: FsmInitRestartCounter(fp, fp->conf.maxconfig);
325: FsmInitMaxFailure(fp, fp->conf.maxfailure);
326: FsmInitMaxConfig(fp, fp->conf.maxconfig);
327: FsmSendConfigReq(fp);
328: break;
329: default:
330: Log(fp->log2, ("[%s] %s: Oops, UP at %s",
331: Pref(fp), Fsm(fp), FsmStateName(fp->state)));
332: break;
333: }
334: }
335:
336: void
337: FsmDown(Fsm fp)
338: {
339: Log(fp->log2, ("[%s] %s: Down event", Pref(fp), Fsm(fp)));
340: switch (fp->state) {
341: case ST_CLOSING:
342: FsmLayerFinish(fp); /* Missing in RFC 1661 */
343: /* fall through */
344: case ST_CLOSED:
345: FsmNewState(fp, ST_INITIAL);
346: break;
347: case ST_STOPPED:
348: FsmNewState(fp, ST_STARTING);
349: FsmLayerStart(fp);
350: break;
351: case ST_STOPPING:
352: case ST_REQSENT:
353: case ST_ACKRCVD:
354: case ST_ACKSENT:
355: FsmNewState(fp, ST_STARTING);
356: if (fp->type->UnConfigure)
357: (*fp->type->UnConfigure)(fp);
358: break;
359: case ST_OPENED:
360: FsmNewState(fp, ST_STARTING);
361: FsmLayerDown(fp);
362: if (fp->type->UnConfigure)
363: (*fp->type->UnConfigure)(fp);
364: break;
365: default:
366: break;
367: }
368: }
369:
370: void
371: FsmClose(Fsm fp)
372: {
373: Log(fp->log2, ("[%s] %s: Close event", Pref(fp), Fsm(fp)));
374: switch (fp->state) {
375: case ST_STARTING:
376: FsmNewState(fp, ST_INITIAL);
377: FsmLayerFinish(fp);
378: break;
379: case ST_STOPPED:
380: FsmNewState(fp, ST_CLOSED);
381: break;
382: case ST_STOPPING:
383: FsmNewState(fp, ST_CLOSING);
384: break;
385: case ST_OPENED:
386: FsmNewState(fp, ST_CLOSING);
387: FsmInitRestartCounter(fp, fp->conf.maxterminate);
388: FsmSendTerminateReq(fp);
389: FsmLayerDown(fp);
390: if (fp->type->UnConfigure)
391: (*fp->type->UnConfigure)(fp);
392: break;
393: case ST_REQSENT:
394: case ST_ACKRCVD:
395: case ST_ACKSENT:
396: FsmNewState(fp, ST_CLOSING);
397: FsmInitRestartCounter(fp, fp->conf.maxterminate);
398: FsmSendTerminateReq(fp);
399: if (fp->type->UnConfigure)
400: (*fp->type->UnConfigure)(fp);
401: break;
402: default:
403: break;
404: }
405: }
406:
407: /*
408: * Send functions
409: */
410:
411: static void
412: FsmSendConfigReq(Fsm fp)
413: {
414: u_char reqBuf[REQ_BUFFER_SIZE];
415: u_char *cp;
416:
417: /* Build and display config request */
418: Log(fp->log, ("[%s] %s: SendConfigReq #%d", Pref(fp), Fsm(fp), fp->reqid));
419: cp = (*fp->type->BuildConfigReq)(fp, reqBuf);
420: FsmDecodeBuffer(fp, reqBuf, cp - reqBuf, MODE_NOP);
421:
422: /* Send it */
423: FsmOutput(fp, CODE_CONFIGREQ, fp->reqid++, reqBuf, cp - reqBuf);
424:
425: /* Restart restart timer and decrement restart counter */
426: TimerStart(&fp->timer);
427: fp->restart--;
428: fp->config--;
429: }
430:
431: static void
432: FsmSendTerminateReq(Fsm fp)
433: {
434: Log(fp->log, ("[%s] %s: SendTerminateReq #%d", Pref(fp), Fsm(fp), fp->reqid));
435: FsmOutput(fp, CODE_TERMREQ, fp->reqid++, NULL, 0);
436: if (fp->type->SendTerminateReq)
437: (*fp->type->SendTerminateReq)(fp);
438: TimerStart(&fp->timer); /* Restart restart timer */
439: fp->restart--; /* Decrement restart counter */
440: }
441:
442: static void
443: FsmSendTerminateAck(Fsm fp)
444: {
445: Log(fp->log, ("[%s] %s: SendTerminateAck #%d", Pref(fp), Fsm(fp), fp->reqid));
446: FsmOutput(fp, CODE_TERMACK, fp->reqid++, NULL, 0);
447: if (fp->type->SendTerminateAck)
448: (*fp->type->SendTerminateAck)(fp);
449: }
450:
451: static void
452: FsmSendConfigAck(Fsm fp, FsmHeader lhp, u_char *option, int count)
453: {
454: Log(fp->log, ("[%s] %s: SendConfigAck #%d", Pref(fp), Fsm(fp), lhp->id));
455: FsmDecodeBuffer(fp, option, count, MODE_NOP);
456: FsmOutput(fp, CODE_CONFIGACK, lhp->id, option, count);
457: }
458:
459: static void
460: FsmSendConfigRej(Fsm fp, FsmHeader lhp, u_char *option, int count)
461: {
462: Log(fp->log, ("[%s] %s: SendConfigRej #%d", Pref(fp), Fsm(fp), lhp->id));
463: FsmDecodeBuffer(fp, option, count, MODE_NOP);
464: FsmOutput(fp, CODE_CONFIGREJ, lhp->id, option, count);
465: fp->failure--;
466: }
467:
468: static void
469: FsmSendConfigNak(Fsm fp, FsmHeader lhp, u_char *option, int count)
470: {
471: Log(fp->log, ("[%s] %s: SendConfigNak #%d", Pref(fp), Fsm(fp), lhp->id));
472: FsmDecodeBuffer(fp, option, count, MODE_NOP);
473: FsmOutput(fp, CODE_CONFIGNAK, lhp->id, option, count);
474: fp->failure--;
475: }
476:
477: /*
478: * Timeout actions
479: */
480:
481: static void
482: FsmTimeout(void *arg)
483: {
484: Fsm fp = (Fsm) arg;
485:
486: if (fp->restart > 0) { /* TO+ */
487: switch (fp->state) {
488: case ST_CLOSING:
489: case ST_STOPPING:
490: FsmSendTerminateReq(fp);
491: break;
492: case ST_REQSENT:
493: case ST_ACKSENT:
494: FsmSendConfigReq(fp);
495: break;
496: case ST_ACKRCVD:
497: FsmNewState(fp, ST_REQSENT);
498: FsmSendConfigReq(fp);
499: break;
500: default:
501: break;
502: }
503: } else { /* TO- */
504: switch (fp->state) {
505: case ST_CLOSING:
506: FsmNewState(fp, ST_CLOSED);
507: FsmLayerFinish(fp);
508: break;
509: case ST_STOPPING:
510: FsmNewState(fp, ST_STOPPED);
511: FsmLayerFinish(fp);
512: break;
513: case ST_REQSENT:
514: case ST_ACKSENT:
515: case ST_ACKRCVD:
516: FsmFailure(fp, FAIL_NEGOT_FAILURE);
517: break;
518: default:
519: break;
520: }
521: }
522: }
523:
524: void
525: FsmInitRestartCounter(Fsm fp, int value)
526: {
527: const int retry = fp->type->link_layer ?
528: ((Link)(fp->arg))->conf.retry_timeout :
529: ((Bund)(fp->arg))->conf.retry_timeout;
530:
531: TimerStop(&fp->timer);
532: TimerInit(&fp->timer,
533: fp->type->name, retry * SECONDS, FsmTimeout, (void *) fp);
534: fp->restart = value;
535: }
536:
537: void
538: FsmInitMaxFailure(Fsm fp, int value)
539: {
540: fp->failure = value;
541: }
542:
543: void
544: FsmInitMaxConfig(Fsm fp, int value)
545: {
546: fp->config = value;
547: }
548:
549: /*
550: * Actions that happen when we receive packets
551: */
552:
553: /* RCR */
554:
555: static void
556: FsmRecvConfigReq(Fsm fp, FsmHeader lhp, Mbuf bp)
557: {
558: int fullyAcked;
559:
560: /* Check and process easy cases */
561: switch (fp->state) {
562: case ST_INITIAL:
563: case ST_STARTING:
564: Log(fp->log2, ("[%s] %s: Oops, RCR in %s", Pref(fp), Fsm(fp), FsmStateName(fp->state)));
565: mbfree(bp);
566: return;
567: case ST_CLOSED:
568: FsmSendTerminateAck(fp);
569: mbfree(bp);
570: return;
571: case ST_STOPPED:
572: if (fp->type->Configure)
573: (*fp->type->Configure)(fp);
574: break;
575: case ST_CLOSING:
576: case ST_STOPPING:
577: mbfree(bp);
578: return;
579: default:
580: break;
581: }
582:
583: /* Decode packet */
584: FsmDecodeBuffer(fp, MBDATA(bp), MBLEN(bp), MODE_REQ);
585:
586: /* State specific actions */
587: switch (fp->state) {
588: case ST_OPENED:
589: FsmLayerDown(fp);
590: FsmSendConfigReq(fp);
591: break;
592: case ST_STOPPED:
593: FsmLayerStart(fp); /* Missing in RFC 1661 */
594: FsmInitRestartCounter(fp, fp->conf.maxconfig);
595: FsmInitMaxFailure(fp, fp->conf.maxfailure);
596: FsmInitMaxConfig(fp, fp->conf.maxconfig);
597: FsmSendConfigReq(fp);
598: break;
599: default:
600: break;
601: }
602:
603: /* What did we think of packet? */
604: fullyAcked = (gNakSize == 0 && gRejSize == 0);
605: if (fullyAcked)
606: FsmSendConfigAck(fp, lhp, gAckBuf, gAckSize);
607: else {
608: if (fp->failure <= 0) {
609: Log(fp->log, ("[%s] %s: not converging", Pref(fp), Fsm(fp)));
610: FsmFailure(fp, FAIL_NEGOT_FAILURE);
611: mbfree(bp);
612: return;
613: } else {
614: if (gRejSize)
615: FsmSendConfigRej(fp, lhp, gRejBuf, gRejSize);
616: else if (gNakSize)
617: FsmSendConfigNak(fp, lhp, gNakBuf, gNakSize);
618: }
619: }
620:
621: /* Continue with state transition */
622: switch (fp->state) {
623: case ST_STOPPED:
624: case ST_OPENED:
625: if (fullyAcked)
626: FsmNewState(fp, ST_ACKSENT);
627: else
628: FsmNewState(fp, ST_REQSENT);
629: break;
630: case ST_REQSENT:
631: if (fullyAcked)
632: FsmNewState(fp, ST_ACKSENT);
633: break;
634: case ST_ACKRCVD:
635: if (fullyAcked)
636: {
637: FsmNewState(fp, ST_OPENED);
638: FsmLayerUp(fp);
639: }
640: break;
641: case ST_ACKSENT:
642: if (!fullyAcked)
643: FsmNewState(fp, ST_REQSENT);
644: break;
645: default:
646: break;
647: }
648: mbfree(bp);
649: }
650:
651: /* RCA */
652:
653: static void
654: FsmRecvConfigAck(Fsm fp, FsmHeader lhp, Mbuf bp)
655: {
656:
657: /* Check sequence number */
658: if (lhp->id != (u_char) (fp->reqid - 1)) {
659: Log(fp->log, ("[%s] Wrong id#, expecting %d", Pref(fp), (u_char) (fp->reqid - 1)));
660: mbfree(bp);
661: return;
662: }
663:
664: /* XXX We should verify the contents are equal to our last sent config-req */
665:
666: /* Decode packet */
667: FsmDecodeBuffer(fp, MBDATA(bp), MBLEN(bp), MODE_NOP);
668:
669: /* Do whatever */
670: switch (fp->state) {
671: case ST_CLOSED:
672: case ST_STOPPED:
673: FsmSendTerminateAck(fp);
674: break;
675: case ST_CLOSING:
676: case ST_STOPPING:
677: break;
678: case ST_REQSENT:
679: FsmNewState(fp, ST_ACKRCVD);
680: FsmInitRestartCounter(fp, fp->conf.maxconfig);
681: FsmInitMaxFailure(fp, fp->conf.maxfailure);
682: FsmInitMaxConfig(fp, fp->conf.maxconfig);
683: TimerStart(&fp->timer); /* Start restart timer */
684: break;
685: case ST_ACKRCVD:
686: FsmNewState(fp, ST_REQSENT);
687: FsmSendConfigReq(fp);
688: break;
689: case ST_ACKSENT:
690: FsmNewState(fp, ST_OPENED);
691: FsmInitRestartCounter(fp, fp->conf.maxconfig);
692: FsmInitMaxFailure(fp, fp->conf.maxfailure);
693: FsmInitMaxConfig(fp, fp->conf.maxconfig);
694: FsmLayerUp(fp);
695: break;
696: case ST_OPENED:
697: FsmNewState(fp, ST_REQSENT);
698: FsmLayerDown(fp);
699: FsmSendConfigReq(fp);
700: break;
701: default:
702: break;
703: }
704: mbfree(bp);
705: }
706:
707: /* RCN */
708:
709: static void
710: FsmRecvConfigNak(Fsm fp, FsmHeader lhp, Mbuf bp)
711: {
712:
713: /* Check sequence number */
714: if (lhp->id != (u_char) (fp->reqid - 1)) {
715: Log(fp->log, ("[%s] Wrong id#, expecting %d", Pref(fp), (u_char) (fp->reqid - 1)));
716: mbfree(bp);
717: return;
718: }
719:
720: /* Check and process easy cases */
721: switch (fp->state) {
722: case ST_INITIAL:
723: case ST_STARTING:
724: Log(fp->log, ("[%s] %s: Oops, RCN in %s", Pref(fp), Fsm(fp), FsmStateName(fp->state)));
725: mbfree(bp);
726: return;
727: case ST_CLOSED:
728: case ST_STOPPED:
729: FsmSendTerminateAck(fp);
730: mbfree(bp);
731: return;
732: case ST_CLOSING:
733: case ST_STOPPING:
734: mbfree(bp);
735: return;
736: default:
737: break;
738: }
739:
740: /* Decode packet */
741: FsmDecodeBuffer(fp, MBDATA(bp), MBLEN(bp), MODE_NAK);
742:
743: /* Not converging? */
744: if (fp->config <= 0) {
745: Log(fp->log, ("[%s] %s: not converging", Pref(fp), Fsm(fp)));
746: FsmFailure(fp, FAIL_NEGOT_FAILURE);
747: mbfree(bp);
748: return;
749: }
750:
751: /* Do whatever */
752: switch (fp->state) {
753: case ST_REQSENT:
754: case ST_ACKSENT:
755: FsmInitRestartCounter(fp, fp->conf.maxconfig);
756: FsmSendConfigReq(fp);
757: break;
758: case ST_OPENED:
759: FsmLayerDown(fp);
760: /* fall through */
761: case ST_ACKRCVD:
762: FsmNewState(fp, ST_REQSENT);
763: FsmSendConfigReq(fp);
764: break;
765: default:
766: break;
767: }
768: mbfree(bp);
769: }
770:
771: /* RCJ */
772:
773: static void
774: FsmRecvConfigRej(Fsm fp, FsmHeader lhp, Mbuf bp)
775: {
776:
777: /* Check sequence number */
778: if (lhp->id != (u_char) (fp->reqid - 1)) {
779: Log(fp->log, ("[%s] Wrong id#, expecting %d", Pref(fp), (u_char) (fp->reqid - 1)));
780: mbfree(bp);
781: return;
782: }
783:
784: /* XXX should verify contents are a subset of previously sent config-req */
785:
786: /* Check and process easy cases */
787: switch (fp->state) {
788: case ST_INITIAL:
789: case ST_STARTING:
790: Log(fp->log, ("[%s] %s: Oops, RCJ in %s", Pref(fp), Fsm(fp), FsmStateName(fp->state)));
791: mbfree(bp);
792: return;
793: case ST_CLOSED:
794: case ST_STOPPED:
795: FsmSendTerminateAck(fp);
796: mbfree(bp);
797: return;
798: case ST_CLOSING:
799: case ST_STOPPING:
800: mbfree(bp);
801: return;
802: default:
803: break;
804: }
805:
806: /* Decode packet */
807: FsmDecodeBuffer(fp, MBDATA(bp), MBLEN(bp), MODE_REJ);
808:
809: /* Not converging? */
810: if (fp->config <= 0) {
811: Log(fp->log, ("[%s] %s: not converging", Pref(fp), Fsm(fp)));
812: FsmFailure(fp, FAIL_NEGOT_FAILURE);
813: mbfree(bp);
814: return;
815: }
816:
817: /* Do whatever */
818: switch (fp->state) {
819: case ST_REQSENT:
820: case ST_ACKSENT:
821: FsmInitRestartCounter(fp, fp->conf.maxconfig);
822: FsmSendConfigReq(fp);
823: break;
824: case ST_OPENED:
825: FsmNewState(fp, ST_REQSENT);
826: FsmLayerDown(fp);
827: FsmSendConfigReq(fp);
828: break;
829: case ST_ACKRCVD:
830: FsmNewState(fp, ST_REQSENT);
831: FsmSendConfigReq(fp);
832: break;
833: default:
834: break;
835: }
836: mbfree(bp);
837: }
838:
839: /* RTR */
840:
841: static void
842: FsmRecvTermReq(Fsm fp, FsmHeader lhp, Mbuf bp)
843: {
844: if (fp->type->link_layer) {
845: RecordLinkUpDownReason(NULL, (Link)(fp->arg), 0, STR_PEER_DISC, NULL);
846: }
847: switch (fp->state) {
848: case ST_INITIAL:
849: case ST_STARTING:
850: Log(fp->log, ("[%s] %s: Oops, RTR in %s", Pref(fp), Fsm(fp), FsmStateName(fp->state)));
851: break;
852: case ST_CLOSED:
853: case ST_STOPPED:
854: case ST_CLOSING:
855: case ST_STOPPING:
856: case ST_REQSENT:
857: FsmSendTerminateAck(fp);
858: break;
859: case ST_ACKRCVD:
860: case ST_ACKSENT:
861: FsmNewState(fp, ST_REQSENT);
862: FsmSendTerminateAck(fp);
863: break;
864: case ST_OPENED:
865: FsmNewState(fp, ST_STOPPING);
866: FsmSendTerminateAck(fp);
867: FsmLayerDown(fp);
868: FsmInitRestartCounter(fp, 0); /* Zero restart counter */
869: TimerStart(&fp->timer); /* Start restart timer */
870: if (fp->type->UnConfigure)
871: (*fp->type->UnConfigure)(fp);
872: break;
873: }
874: mbfree(bp);
875: }
876:
877: /* RTA */
878:
879: static void
880: FsmRecvTermAck(Fsm fp, FsmHeader lhp, Mbuf bp)
881: {
882: switch (fp->state) {
883: case ST_CLOSING:
884: FsmNewState(fp, ST_CLOSED);
885: FsmLayerFinish(fp);
886: break;
887: case ST_STOPPING:
888: FsmNewState(fp, ST_STOPPED);
889: FsmLayerFinish(fp);
890: break;
891: case ST_ACKRCVD:
892: FsmNewState(fp, ST_REQSENT);
893: break;
894: case ST_OPENED:
895: FsmNewState(fp, ST_REQSENT);
896: FsmLayerDown(fp);
897: FsmSendConfigReq(fp);
898: break;
899: default:
900: break;
901: }
902: mbfree(bp);
903: }
904:
905: /*
906: * FsmRecvCodeRej()
907: *
908: * By default, this is fatal for most codes
909: */
910:
911: static void
912: FsmRecvCodeRej(Fsm fp, FsmHeader lhp, Mbuf bp)
913: {
914: u_char code = 0;
915: int fatal;
916:
917: /* Get code and log it */
918: bp = mbread(bp, &code, sizeof(code));
919: Log(fp->log, ("[%s] %s: code %s was rejected", Pref(fp), Fsm(fp), FsmCodeName(code)));
920:
921: /* Determine fatalness */
922: if (fp->type->RecvCodeRej)
923: fatal = (*fp->type->RecvCodeRej)(fp, code, bp);
924: else {
925: switch (code) {
926: case CODE_CONFIGREQ:
927: case CODE_CONFIGACK:
928: case CODE_CONFIGNAK:
929: case CODE_CONFIGREJ:
930: case CODE_TERMREQ:
931: case CODE_TERMACK:
932: case CODE_CODEREJ:
933: case CODE_PROTOREJ:
934: case CODE_ECHOREQ:
935: case CODE_ECHOREP:
936: case CODE_RESETREQ:
937: case CODE_RESETACK:
938: fatal = TRUE;
939: break;
940: case CODE_VENDOR:
941: case CODE_DISCREQ:
942: case CODE_IDENT:
943: case CODE_TIMEREM:
944: default: /* if we don't know it, that makes two of us */
945: fatal = FALSE;
946: break;
947: }
948: }
949:
950: /* Possibly shut down as a result */
951: if (fatal)
952: FsmFailure(fp, FAIL_RECD_CODEREJ); /* RXJ- */
953: else
954: FsmRecvRxjPlus(fp);
955: mbfree(bp);
956: }
957:
958: /*
959: * FsmRecvProtoRej()
960: *
961: * By default, this is non-fatal
962: */
963:
964: static void
965: FsmRecvProtoRej(Fsm fp, FsmHeader lhp, Mbuf bp)
966: {
967: u_short proto = 0;
968: int fatal = FALSE;
969:
970: bp = mbread(bp, &proto, sizeof(proto));
971: proto = ntohs(proto);
972: Log(fp->log, ("[%s] %s: protocol %s was rejected", Pref(fp), Fsm(fp), ProtoName(proto)));
973: if (fp->state == ST_OPENED && fp->type->RecvProtoRej)
974: fatal = (*fp->type->RecvProtoRej)(fp, proto, bp);
975: if (fatal)
976: FsmFailure(fp, FAIL_RECD_PROTREJ); /* RXJ- */
977: else
978: FsmRecvRxjPlus(fp);
979: mbfree(bp);
980: }
981:
982: /*
983: * FsmRecvRxjPlus()
984: */
985:
986: static void
987: FsmRecvRxjPlus(Fsm fp) /* RXJ+ */
988: {
989: switch (fp->state) {
990: case ST_ACKRCVD:
991: FsmNewState(fp, ST_REQSENT);
992: break;
993: default:
994: break;
995: }
996: }
997:
998: /*
999: * FsmFailure()
1000: *
1001: * Call this at any point if something fatal happens that is inherent
1002: * to the FSM itself, like a RXJ- event or negotiation failed to converge.
1003: * The action taken is like the RXJ- event.
1004: */
1005:
1006: void
1007: FsmFailure(Fsm fp, enum fsmfail reason)
1008: {
1009: Log(fp->log, ("[%s] %s: %s", Pref(fp), Fsm(fp), FsmFailureStr(reason)));
1010:
1011: /* Let layer do any special handling of error code */
1012: if (fp->type->Failure)
1013: (*fp->type->Failure)(fp, reason);
1014:
1015: /* Shut this state machine down */
1016: switch (fp->state) {
1017: case ST_CLOSING:
1018: FsmNewState(fp, ST_CLOSED);
1019: /* fall through */
1020: case ST_CLOSED:
1021: FsmLayerFinish(fp);
1022: break;
1023: case ST_STOPPING:
1024: FsmNewState(fp, ST_STOPPED);
1025: FsmLayerFinish(fp);
1026: break;
1027: case ST_ACKRCVD:
1028: case ST_ACKSENT:
1029: case ST_REQSENT:
1030: FsmNewState(fp, ST_STOPPED);
1031: if (!fp->conf.passive)
1032: FsmLayerFinish(fp);
1033: if (fp->type->UnConfigure)
1034: (*fp->type->UnConfigure)(fp);
1035: break;
1036:
1037: /*
1038: * In the opened state, the peer FSM has somehow died or did something
1039: * horribly wrong to us. So the common sense action in this case is to
1040: * bring the whole link down, rather than restarting just the FSM.
1041: * We do this by telling the lower layer to restart using tlf and tls
1042: * while also pretending that we got a DOWN event.
1043: */
1044: case ST_OPENED:
1045: FsmNewState(fp, ST_STOPPING);
1046: FsmInitRestartCounter(fp, fp->conf.maxterminate);
1047: FsmSendTerminateReq(fp);
1048: FsmLayerDown(fp);
1049: if (fp->type->UnConfigure)
1050: (*fp->type->UnConfigure)(fp);
1051: break;
1052:
1053: /*
1054: * In the STOPPED state, then most likely the negotiation timed out
1055: * or didn't converge. Just wait for the DOWN event from the previously
1056: * issued tlf action.
1057: */
1058: case ST_STOPPED:
1059: if (!fp->conf.passive)
1060: FsmLayerFinish(fp);
1061: break;
1062: default:
1063: break;
1064: }
1065: }
1066:
1067: /*
1068: * FsmFailureStr()
1069: */
1070:
1071: const char *
1072: FsmFailureStr(enum fsmfail reason)
1073: {
1074: const char *string = NULL;
1075:
1076: switch (reason) {
1077: case FAIL_NEGOT_FAILURE:
1078: string = STR_FAIL_NEGOT_FAILURE;
1079: break;
1080: case FAIL_RECD_BADMAGIC:
1081: string = STR_FAIL_RECD_BADMAGIC;
1082: break;
1083: case FAIL_RECD_CODEREJ:
1084: string = STR_FAIL_RECD_CODEREJ;
1085: break;
1086: case FAIL_RECD_PROTREJ:
1087: string = STR_FAIL_RECD_PROTREJ;
1088: break;
1089: case FAIL_WAS_PROTREJ:
1090: string = STR_FAIL_WAS_PROTREJ;
1091: break;
1092: case FAIL_ECHO_TIMEOUT:
1093: string = STR_FAIL_ECHO_TIMEOUT;
1094: break;
1095: case FAIL_CANT_ENCRYPT:
1096: string = STR_FAIL_CANT_ENCRYPT;
1097: break;
1098: default:
1099: assert(0);
1100: }
1101: return(string);
1102: }
1103:
1104: /*
1105: * FsmSendEchoReq()
1106: *
1107: * Send an echo request containing the supplied payload data.
1108: * Consumes the mbuf.
1109: */
1110:
1111: void
1112: FsmSendEchoReq(Fsm fp, Mbuf payload)
1113: {
1114: u_int32_t const self_magic = htonl(((Link)(fp->arg))->lcp.want_magic);
1115: Mbuf bp;
1116:
1117: if (fp->state != ST_OPENED)
1118: return;
1119:
1120: /* Prepend my magic number */
1121: bp = mbcopyback(payload, -(int)sizeof(self_magic), &self_magic, sizeof(self_magic));
1122:
1123: /* Send it */
1124: Log(LG_ECHO, ("[%s] %s: SendEchoReq #%d", Pref(fp), Fsm(fp), fp->echoid));
1125: FsmOutputMbuf(fp, CODE_ECHOREQ, fp->echoid++, bp);
1126: }
1127:
1128: /*
1129: * FsmSendIdent()
1130: *
1131: * Send an LCP ident packet.
1132: */
1133:
1134: void
1135: FsmSendIdent(Fsm fp, const char *ident)
1136: {
1137: u_int32_t self_magic = htonl(((Link)(fp->arg))->lcp.want_magic);
1138: const int len = strlen(ident) + 1; /* include NUL to be nice */
1139: Mbuf bp;
1140:
1141: /* Leave magic zero unless fully opened, as IDENT can be sent anytime */
1142: if (fp->state != ST_OPENED)
1143: self_magic = 0;
1144:
1145: /* Prepend my magic number */
1146: bp = mbcopyback(NULL, 0, (u_char *) &self_magic, sizeof(self_magic));
1147: bp = mbcopyback(bp, sizeof(self_magic), ident, len);
1148:
1149: /* Send it */
1150: Log(fp->log2, ("[%s] %s: SendIdent #%d", Pref(fp), Fsm(fp), fp->echoid));
1151: ShowMesg(fp->log2, Pref(fp), ident, len);
1152: FsmOutputMbuf(fp, CODE_IDENT, fp->echoid++, bp);
1153: }
1154:
1155: /*
1156: * FsmSendTimeRemaining()
1157: *
1158: * Send an LCP Time-Remaining packet.
1159: */
1160:
1161: void
1162: FsmSendTimeRemaining(Fsm fp, u_int seconds)
1163: {
1164: u_int32_t self_magic = htonl(((Link)(fp->arg))->lcp.want_magic);
1165: u_int32_t data = htonl(seconds);
1166: Mbuf bp;
1167:
1168: /* Leave magic zero unless fully opened, as IDENT can be sent anytime */
1169: if (fp->state != ST_OPENED)
1170: self_magic = 0;
1171:
1172: /* Prepend my magic number */
1173: bp = mbcopyback(NULL, 0, (u_char *) &self_magic, sizeof(self_magic));
1174: bp = mbcopyback(bp, sizeof(self_magic), &data, 4);
1175:
1176: /* Send it */
1177: Log(fp->log2, ("[%s] %s: SendTimeRemaining #%d", Pref(fp), Fsm(fp), fp->echoid));
1178: Log(fp->log2, ("[%s] %u seconds remain", Pref(fp), seconds));
1179: FsmOutputMbuf(fp, CODE_TIMEREM, fp->echoid++, bp);
1180: }
1181:
1182: /*
1183: * FsmRecvEchoReq()
1184: */
1185:
1186: static void
1187: FsmRecvEchoReq(Fsm fp, FsmHeader lhp, Mbuf bp)
1188: {
1189: u_int32_t self_magic;
1190:
1191: /* Validate magic number */
1192: bp = FsmCheckMagic(fp, bp);
1193:
1194: /* If not opened, do nothing */
1195: if (fp->state != ST_OPENED) {
1196: mbfree(bp);
1197: return;
1198: }
1199:
1200: /* Stick my magic number in there instead */
1201: self_magic = htonl(((Link)(fp->arg))->lcp.want_magic);
1202: bp = mbcopyback(bp, -(int)sizeof(self_magic), &self_magic, sizeof(self_magic));
1203:
1204: /* Send it back, preserving everything else */
1205: Log(LG_ECHO, ("[%s] %s: SendEchoRep #%d", Pref(fp), Fsm(fp), lhp->id));
1206: FsmOutputMbuf(fp, CODE_ECHOREP, lhp->id, bp);
1207: }
1208:
1209: /*
1210: * FsmRecvEchoRep()
1211: */
1212:
1213: static void
1214: FsmRecvEchoRep(Fsm fp, FsmHeader lhp, Mbuf bp)
1215: {
1216: bp = FsmCheckMagic(fp, bp);
1217: mbfree(bp);
1218: }
1219:
1220: /*
1221: * FsmRecvDiscReq()
1222: */
1223:
1224: static void
1225: FsmRecvDiscReq(Fsm fp, FsmHeader lhp, Mbuf bp)
1226: {
1227: bp = FsmCheckMagic(fp, bp);
1228: if (fp->type->RecvDiscReq)
1229: (*fp->type->RecvDiscReq)(fp, bp);
1230: mbfree(bp);
1231: }
1232:
1233: /*
1234: * FsmRecvIdent()
1235: */
1236:
1237: static void
1238: FsmRecvIdent(Fsm fp, FsmHeader lhp, Mbuf bp)
1239: {
1240: bp = FsmCheckMagic(fp, bp);
1241: if (bp)
1242: ShowMesg(fp->log, Pref(fp), (char *) MBDATA(bp), MBLEN(bp));
1243: if (fp->type->RecvIdent)
1244: (*fp->type->RecvIdent)(fp, bp);
1245: mbfree(bp);
1246: }
1247:
1248: /*
1249: * FsmRecvVendor()
1250: */
1251:
1252: static void
1253: FsmRecvVendor(Fsm fp, FsmHeader lhp, Mbuf bp)
1254: {
1255: bp = FsmCheckMagic(fp, bp);
1256: if (fp->type->RecvVendor)
1257: (*fp->type->RecvVendor)(fp, bp);
1258: mbfree(bp);
1259: }
1260:
1261: /*
1262: * FsmRecvTimeRemain()
1263: */
1264:
1265: static void
1266: FsmRecvTimeRemain(Fsm fp, FsmHeader lhp, Mbuf bp)
1267: {
1268: bp = FsmCheckMagic(fp, bp);
1269: if (bp) {
1270: u_int32_t remain = 0;
1271: mbcopy(bp, 0, &remain, sizeof(remain));
1272: remain = ntohl(remain);
1273: Log(fp->log, ("[%s] %u seconds remain", Pref(fp), remain));
1274: }
1275: if (fp->type->RecvTimeRemain)
1276: (*fp->type->RecvTimeRemain)(fp, bp);
1277: mbfree(bp);
1278: }
1279:
1280: /*
1281: * FsmRecvResetReq()
1282: */
1283:
1284: static void
1285: FsmRecvResetReq(Fsm fp, FsmHeader lhp, Mbuf bp)
1286: {
1287: if (fp->type->RecvResetReq)
1288: (*fp->type->RecvResetReq)(fp, lhp->id, bp);
1289: mbfree(bp);
1290: }
1291:
1292: /*
1293: * FsmRecvResetAck()
1294: */
1295:
1296: static void
1297: FsmRecvResetAck(Fsm fp, FsmHeader lhp, Mbuf bp)
1298: {
1299: if (fp->type->RecvResetAck)
1300: (*fp->type->RecvResetAck)(fp, lhp->id, bp);
1301: mbfree(bp);
1302: }
1303:
1304: /*
1305: * FsmLayerUp()
1306: */
1307:
1308: static void
1309: FsmLayerUp(Fsm fp)
1310: {
1311: Log(fp->log2, ("[%s] %s: LayerUp", Pref(fp), Fsm(fp)));
1312: if (fp->type->LayerUp)
1313: (*fp->type->LayerUp)(fp);
1314: }
1315:
1316: /*
1317: * FsmLayerDown()
1318: */
1319:
1320: static void
1321: FsmLayerDown(Fsm fp)
1322: {
1323: Log(fp->log2, ("[%s] %s: LayerDown", Pref(fp), Fsm(fp)));
1324: if (fp->type->LayerDown)
1325: (*fp->type->LayerDown)(fp);
1326: }
1327:
1328: /*
1329: * FsmLayerStart()
1330: */
1331:
1332: static void
1333: FsmLayerStart(Fsm fp)
1334: {
1335: Log(fp->log2, ("[%s] %s: LayerStart", Pref(fp), Fsm(fp)));
1336: if (fp->type->LayerStart)
1337: (*fp->type->LayerStart)(fp);
1338: }
1339:
1340: /*
1341: * FsmLayerFinish()
1342: */
1343:
1344: static void
1345: FsmLayerFinish(Fsm fp)
1346: {
1347: Log(fp->log2, ("[%s] %s: LayerFinish", Pref(fp), Fsm(fp)));
1348: if (fp->type->LayerFinish)
1349: (*fp->type->LayerFinish)(fp);
1350: }
1351:
1352: /*
1353: * FsmCheckMagic()
1354: */
1355:
1356: static Mbuf
1357: FsmCheckMagic(Fsm fp, Mbuf bp)
1358: {
1359: u_int32_t peer_magic;
1360: u_int32_t peer_magic_ought;
1361:
1362: /* Read magic number */
1363: bp = mbread(bp, &peer_magic, sizeof(peer_magic));
1364: peer_magic = ntohl(peer_magic);
1365:
1366: /* What should magic number be? */
1367: if (PROT_LINK_LAYER(fp->type->proto))
1368: peer_magic_ought = ((Link)(fp->arg))->lcp.peer_magic;
1369: else
1370: peer_magic_ought = 0;
1371:
1372: /* Verify */
1373: if (fp->conf.check_magic && peer_magic != 0
1374: && peer_magic != peer_magic_ought) {
1375: Log(fp->log, ("[%s] %s: magic number is wrong: 0x%08x != 0x%08x",
1376: Pref(fp), Fsm(fp), peer_magic, peer_magic_ought));
1377: FsmFailure(fp, FAIL_RECD_BADMAGIC);
1378: }
1379: return(bp);
1380: }
1381:
1382: /*
1383: * FsmEchoTimeout()
1384: */
1385:
1386: static void
1387: FsmEchoTimeout(void *arg)
1388: {
1389: Fsm const fp = (Fsm) arg;
1390: Bund b;
1391: Link l;
1392: struct ng_ppp_link_stat oldStats;
1393:
1394: if (fp->type->link_layer) {
1395: l = (Link)fp->arg;
1396: b = l->bund;
1397: } else {
1398: b = (Bund)fp->arg;
1399: l = NULL;
1400: }
1401:
1402: if (!b) {
1403: /* We can't get link stat without bundle present */
1404: return;
1405: }
1406:
1407: /* See if there was any traffic since last time */
1408: oldStats = fp->idleStats;
1409: NgFuncGetStats(b, l ?
1410: l->bundleIndex : NG_PPP_BUNDLE_LINKNUM, &fp->idleStats);
1411: if (fp->idleStats.recvFrames > oldStats.recvFrames)
1412: fp->quietCount = 0;
1413: else
1414: fp->quietCount++;
1415:
1416: /* See if peer hasn't responded for too many requests */
1417: switch (fp->quietCount) {
1418:
1419: /* Peer failed to reply to previous echo request */
1420: default:
1421: Log(LG_ECHO|fp->log,
1422: ("[%s] %s: no reply to %d echo request(s)",
1423: Pref(fp), Fsm(fp), fp->quietCount - 1));
1424:
1425: /* Has peer failed to reply for maximum allowable interval? */
1426: if (fp->quietCount * fp->conf.echo_int >= fp->conf.echo_max) {
1427: TimerStop(&fp->echoTimer);
1428: FsmFailure(fp, FAIL_ECHO_TIMEOUT);
1429: break;
1430: }
1431: /* fall through */
1432: case 1: /* one interval of silence elapsed; send first echo request */
1433: FsmSendEchoReq(fp, NULL);
1434: /* fall through */
1435: case 0:
1436: break;
1437: }
1438: }
1439:
1440: /*
1441: * FsmInput()
1442: *
1443: * Deal with an incoming packet for FSM pointed to by "fp"
1444: */
1445:
1446: void
1447: FsmInput(Fsm fp, Mbuf bp)
1448: {
1449: int log, recd_len, length;
1450: struct fsmheader hdr;
1451:
1452: /* Check for runt frames; discard them */
1453: if ((recd_len = MBLEN(bp)) < sizeof(hdr)) {
1454: Log(fp->log, ("[%s] %s: runt packet: %d bytes", Pref(fp), Fsm(fp), recd_len));
1455: mbfree(bp);
1456: return;
1457: }
1458:
1459: /* Read in the header */
1460: bp = mbread(bp, &hdr, sizeof(hdr));
1461: length = ntohs(hdr.length);
1462:
1463: /* Make sure length is sensible; discard otherwise */
1464: if (length < sizeof(hdr) || length > recd_len) {
1465: Log(fp->log, ("[%s] %s: bad length: says %d, rec'd %d",
1466: Pref(fp), Fsm(fp), length, recd_len));
1467: mbfree(bp);
1468: return;
1469: }
1470:
1471: /* Truncate off any padding bytes */
1472: if (length < recd_len)
1473: bp = mbtrunc(bp, length - sizeof(hdr));
1474:
1475: /* Check for a valid code byte -- if not, send code-reject */
1476: if ((hdr.code >= NUM_FSM_CODES) ||
1477: (((1 << hdr.code) & fp->type->known_codes) == 0)) { /* RUC */
1478: Log(fp->log, ("[%s] %s: unknown code %d", Pref(fp), Fsm(fp), hdr.code));
1479: FsmOutputMbuf(fp, CODE_CODEREJ, fp->rejid++, bp);
1480: return;
1481: }
1482:
1483: /* Log it */
1484: if (hdr.code == CODE_ECHOREQ || hdr.code == CODE_ECHOREP)
1485: log = LG_ECHO;
1486: else if (hdr.code == CODE_RESETREQ || hdr.code == CODE_RESETACK)
1487: log = fp->log2;
1488: else
1489: log = fp->log;
1490: Log(log, ("[%s] %s: rec'd %s #%d (%s)",
1491: Pref(fp), Fsm(fp), FsmCodeName(hdr.code), (int) hdr.id,
1492: FsmStateName(fp->state)));
1493:
1494: /* Do whatever */
1495: (*FsmCodes[hdr.code].action)(fp, &hdr, bp);
1496: }
1497:
1498: /*
1499: * FsmConfValue()
1500: *
1501: * Write in a configuration item with "len" bytes of information.
1502: * Special cases: length -2 or -4 means convert to network byte order.
1503: */
1504:
1505: u_char *
1506: FsmConfValue(u_char *cp, int type, int len, const void *data)
1507: {
1508: u_char *bytes = (u_char *) data;
1509: u_int16_t sv;
1510: u_int32_t lv;
1511:
1512: /* Special cases */
1513: switch (len) {
1514: case -2:
1515: len = 2;
1516: sv = htons(*((u_int16_t *) data));
1517: bytes = (u_char *) &sv;
1518: break;
1519: case -4:
1520: len = 4;
1521: lv = htonl(*((u_int32_t *) data));
1522: bytes = (u_char *) &lv;
1523: break;
1524: default:
1525: break;
1526: }
1527:
1528: /* Add header and data */
1529: *cp++ = type;
1530: *cp++ = len + 2;
1531: while (len-- > 0)
1532: *cp++ = *bytes++;
1533:
1534: /* Done */
1535: return(cp);
1536: }
1537:
1538: /*
1539: * FsmExtractOptions()
1540: *
1541: * Extract options from a config packet
1542: */
1543:
1544: static int
1545: FsmExtractOptions(Fsm fp, u_char *data, int dlen, FsmOption opts, int max)
1546: {
1547: int num;
1548:
1549: for (num = 0; dlen >= 2 && num < max; num++) {
1550: FsmOption const opt = &opts[num];
1551:
1552: opt->type = data[0];
1553: opt->len = data[1];
1554: opt->data = &data[2];
1555: if (opt->len < 2 || opt->len > dlen)
1556: break;
1557: data += opt->len;
1558: dlen -= opt->len;
1559: }
1560: if (dlen != 0)
1561: LogDumpBuf(LG_ERR, data, dlen,
1562: "[%s] %s: %d extra garbage bytes in config packet", Pref(fp), Fsm(fp), dlen);
1563: return(num);
1564: }
1565:
1566: /*
1567: * FsmFindOption()
1568: */
1569:
1570: FsmOptInfo
1571: FsmFindOptInfo(FsmOptInfo list, u_char type)
1572: {
1573: for (; list->name; list++)
1574: if (list->type == type)
1575: return(list);
1576: return(NULL);
1577: }
1578:
1579: /*
1580: * FsmDecodeBuffer()
1581: */
1582:
1583: static void
1584: FsmDecodeBuffer(Fsm fp, u_char *buf, int size, int mode)
1585: {
1586: struct fsmoption opts[FSM_MAX_OPTS];
1587: int num;
1588:
1589: if (mode == MODE_REQ)
1590: gAckSize = gNakSize = gRejSize = 0;
1591: num = FsmExtractOptions(fp, buf, size, opts, FSM_MAX_OPTS);
1592: (*fp->type->DecodeConfig)(fp, opts, num, mode);
1593: }
1594:
1595: /*
1596: * FsmAck()
1597: */
1598:
1599: void
1600: FsmAck(Fsm fp, const struct fsmoption *opt)
1601: {
1602: if (gAckSize + opt->len > sizeof(gAckBuf)) {
1603: Log(LG_ERR, ("[%s] %s: %s buffer full", Pref(fp), Fsm(fp), "ack"));
1604: return;
1605: }
1606: memcpy(&gAckBuf[gAckSize], opt, 2);
1607: memcpy(&gAckBuf[gAckSize + 2], opt->data, opt->len - 2);
1608: gAckSize += opt->len;
1609: }
1610:
1611: /*
1612: * FsmNak()
1613: */
1614:
1615: void
1616: FsmNak(Fsm fp, const struct fsmoption *opt)
1617: {
1618: if (gNakSize + opt->len > sizeof(gNakBuf)) {
1619: Log(LG_ERR, ("[%s] %s: %s buffer full", Pref(fp), Fsm(fp), "nak"));
1620: return;
1621: }
1622: memcpy(&gNakBuf[gNakSize], opt, 2);
1623: memcpy(&gNakBuf[gNakSize + 2], opt->data, opt->len - 2);
1624: gNakSize += opt->len;
1625: }
1626:
1627: /*
1628: * FsmRej()
1629: */
1630:
1631: void
1632: FsmRej(Fsm fp, const struct fsmoption *opt)
1633: {
1634: if (gRejSize + opt->len > sizeof(gRejBuf)) {
1635: Log(LG_ERR, ("[%s] %s: %s buffer full", Pref(fp), Fsm(fp), "rej"));
1636: return;
1637: }
1638: memcpy(&gRejBuf[gRejSize], opt, 2);
1639: memcpy(&gRejBuf[gRejSize + 2], opt->data, opt->len - 2);
1640: gRejSize += opt->len;
1641: }
1642:
1643: /*
1644: * FsmCodeName()
1645: */
1646:
1647: const char *
1648: FsmCodeName(int code)
1649: {
1650: if (code >= 0 && code < NUM_FSM_CODES)
1651: return (FsmCodes[code].name);
1652: return ("UNKNOWN");
1653: }
1654:
1655: /*
1656: * FsmStateName()
1657: */
1658:
1659: const char *
1660: FsmStateName(enum fsm_state state)
1661: {
1662: switch (state) {
1663: case ST_INITIAL: return "Initial";
1664: case ST_STARTING: return "Starting";
1665: case ST_CLOSED: return "Closed";
1666: case ST_STOPPED: return "Stopped";
1667: case ST_CLOSING: return "Closing";
1668: case ST_STOPPING: return "Stopping";
1669: case ST_REQSENT: return "Req-Sent";
1670: case ST_ACKRCVD: return "Ack-Rcvd";
1671: case ST_ACKSENT: return "Ack-Sent";
1672: case ST_OPENED: return "Opened";
1673: }
1674: return "???";
1675: }
1676:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to fsm.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src