![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ppp_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 / libpdel / ppp|
Return to ppp_fsm.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / ppp |
1.1 misho 1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include "ppp/ppp_defs.h"
42: #include "ppp/ppp_log.h"
43: #include "ppp/ppp_util.h"
44: #include "ppp/ppp_fsm_option.h"
45: #include "ppp/ppp_fsm.h"
46:
47: /* FSM defaults */
48: #define FSM_MAX_CONFIGURE 10
49: #define FSM_MAX_TERMINATE 3
50: #define FSM_MAX_FAILURE 8
51: #define FSM_TIMEOUT 2
52:
53: /* Memory type */
54: #define FSM_MTYPE "ppp_fsm"
55:
56: /* Max amount of packet data to copy & send back */
57: #define MAX_PKTCOPY 200
58:
59: /* FSM events */
60: enum fsm_event {
61: UP =0,
62: DOWN =1,
63: OPEN =2,
64: CLOSE =3,
65: TO_P =4,
66: TO_M =5,
67: RCR_P =6,
68: RCR_M =7,
69: RCA =8,
70: RCN =9,
71: RTR =10,
72: RTA =11,
73: RXJ_P =12,
74: RXJ_M =13
75: };
76: #define FSM_EVENT_MAX 14
77:
78: /* Actions to take on events */
79: #define TLU 0x0010 /* this layer up */
80: #define TLD 0x0020 /* this layer down */
81: #define TLS 0x0040 /* this layer started */
82: #define TLF 0x0080 /* this layer finished */
83: #define IRC 0x0100 /* init restart counter */
84: #define ZRC 0x0200 /* zero restart counter */
85: #define SCR 0x0400 /* send config request */
86: #define SCA 0x0800 /* send config ack */
87: #define SCN 0x1000 /* send config nak/rej */
88: #define STR 0x2000 /* send terminate request */
89: #define STA 0x4000 /* send terminate ack */
90:
91: #define STMASK 0x000f /* next state mask */
92: #define NA 0xffff /* impossible event */
93:
94: /* Configurations we keep */
95: #define FSM_CONF_SELF 0 /* my requested config */
96: #define FSM_CONF_PEER 1 /* peer requested config */
97: #define FSM_CONF_NAK 2 /* nak'd peer config */
98: #define FSM_CONF_REJ 3 /* rejected peer config */
99: #define FSM_CONF_MAX 4
100:
101: /* Information describing an instance of an FSM */
102: struct ppp_fsm {
103: struct ppp_fsm_instance *inst; /* fsm instance object */
104: enum ppp_fsm_state state; /* fsm state */
105: struct ppp_log *log; /* log object */
106: struct ppp_fsm_options *config[FSM_CONF_MAX]; /* config options */
107: u_char ids[FSM_CODE_MAX]; /* packet ids */
108: u_char rejcode[FSM_CODE_MAX]; /* rejected codes */
109: short restart; /* restart counter */
110: short failure[2]; /* failure counter */
111: time_t last_heard; /* time last heard from */
112: struct ppp_fsm_output dead; /* if dead and reason why */
113: struct pevent_ctx *ev_ctx; /* event context */
114: pthread_mutex_t *mutex; /* mutex */
115: struct pevent *timer; /* restart timer */
116: struct mesg_port *outport; /* where output goes */
117: };
118:
119: #define FSM_TIMER_STATE(state) \
120: ((state) >= FSM_STATE_CLOSING && (state) != FSM_STATE_OPENED)
121:
122: #define FSM_DEAD(fsm) \
123: (((fsm)->state == FSM_STATE_INITIAL \
124: || (fsm)->state == FSM_STATE_CLOSED) \
125: && (fsm)->dead.u.down.reason != 0)
126:
127: /* Macro for logging */
128: #define LOG(sev, fmt, args...) PPP_LOG(fsm->log, sev, fmt , ## args)
129:
130: /*
131: * RFC 1661 PPP state transition table
132: *
133: * Differences from RFC 1661:
134: * TLS added in [OPEN, CLOSED]
135: * TLF added in [DOWN, CLOSING]
136: * TLS added in [RCR+, STOPPED]
137: * TLS added in [RCR-, STOPPED]
138: * RUC and RXR events removed (handled directly)
139: *
140: * The extra TLS/TLF actions are to keep intention of lower layer in sync
141: * with the intention of this layer (i.e., if TLS -> lower layer OPEN and
142: * TLF -> lower layer CLOSE).
143: */
144: static const u_int16_t fsm_actions[FSM_EVENT_MAX][FSM_STATE_MAX] = {
145:
146: /*INITL STARTNG CLOSED STOPPED CLOSING STOPPNG REQ-SNT ACK-RCD ACK-SNT OPENED*/
147:
148: /* Up */
149: { 2, IRC|SCR|6,
150: NA, NA, NA, NA, NA, NA, NA, NA },
151: /* Down */
152: { NA, NA, 0, TLS|1, TLF|0, 1, 1, 1, 1, TLD|1 },
153: /* Open */
154: { TLS|1,1, TLS|IRC|SCR|6,
155: 3, 5, 5, 6, 7, 8, 9 },
156: /* Close */
157: { 0, TLF|0, 2, 2, 4, 4, IRC|STR|4,
158: IRC|STR|4,
159: IRC|STR|4,
160: TLD|IRC|STR|4},
161: /* TO+ */
162: { NA, NA, NA, NA, STR|4, STR|5, SCR|6, SCR|6, SCR|8, NA },
163: /* TO- */
164: { NA, NA, NA, NA, TLF|2, TLF|3, TLF|3, TLF|3, TLF|3, NA },
165: /* RCR+ */
166: { NA, NA, STA|2, TLS|IRC|SCR|SCA|8,
167: 4, 5, SCA|8, SCA|TLU|9,
168: SCA|8,
169: TLD|SCR|SCA|8},
170: /* RCR- */
171: { NA, NA, STA|2, TLS|IRC|SCR|SCN|6,
172: 4, 5, SCN|6, SCN|7, SCN|6,
173: TLD|SCR|SCN|6},
174: /* RCA */
175: { NA, NA, STA|2, STA|3, 4, 5, IRC|7,
176: SCR|6, IRC|TLU|9,
177: TLD|SCR|6 },
178: /* RCN */
179: { NA, NA, STA|2, STA|3, 4, 5, IRC|SCR|6,
180: SCR|6, IRC|SCR|8,
181: TLD|SCR|6 },
182: /* RTR */
183: { NA, NA, STA|2, STA|3, STA|4, STA|5, STA|6, STA|6, STA|6,
184: TLD|ZRC|STA|5},
185: /* RTA */
186: { NA, NA, 2, 3, TLF|2, TLF|3, 6, 6, 8,
187: TLD|SCR|6 },
188: /* RXJ+ */
189: { NA, NA, 2, 3, 4, 5, 6, 6, 8, 9 },
190: /* RXJ- */
191: { NA, NA, TLF|2, TLF|3, TLF|2, TLF|3, TLF|3, TLF|3, TLF|3,
192: TLD|IRC|STR|5},
193: };
194:
195: /* Minimum packet data lengths */
196: static const u_char fsm_minlen[FSM_CODE_MAX] = {
197: 0, /* FSM_CODE_VENDOR */
198: 0, /* FSM_CODE_CONFIGREQ */
199: 0, /* FSM_CODE_CONFIGACK */
200: 0, /* FSM_CODE_CONFIGNAK */
201: 0, /* FSM_CODE_CONFIGREJ */
202: 0, /* FSM_CODE_TERMREQ */
203: 0, /* FSM_CODE_TERMACK */
204: 1, /* FSM_CODE_CODEREJ */
205: 2, /* FSM_CODE_PROTOREJ */
206: 4, /* FSM_CODE_ECHOREQ */
207: 4, /* FSM_CODE_ECHOREP */
208: 4, /* FSM_CODE_DISCREQ */
209: 4, /* FSM_CODE_IDENT */
210: 8, /* FSM_CODE_TIMEREM */
211: 0, /* FSM_CODE_RESETREQ */
212: 0, /* FSM_CODE_RESETACK */
213: };
214:
215: /*
216: * Internal functions
217: */
218: static void ppp_fsm_input_packet(struct ppp_fsm *fsm,
219: const u_char *data, u_int dlen);
220: static void ppp_fsm_event(struct ppp_fsm *fsm, int event);
221: static void ppp_fsm_send_config(struct ppp_fsm *fsm,
222: enum ppp_fsm_code code);
223: static void ppp_fsm_send_packet(struct ppp_fsm *fsm, u_char code,
224: const void *data, u_int len);
225: static void ppp_fsm_record(struct ppp_fsm *fsm,
226: /* enum ppp_fsm_reason reason, */ ...);
227: static int ppp_fsm_output(struct ppp_fsm *fsm,
228: enum ppp_fsmoutput type, ...);
229: static void ppp_fsm_output_build(struct ppp_fsm_output *output,
230: enum ppp_fsmoutput type, va_list args);
231: static void ppp_fsm_output_dead(struct ppp_fsm *fsm);
232: static void ppp_fsm_syserr(struct ppp_fsm *fsm, const char *func);
233:
234: static void ppp_fsm_log_pkt(struct ppp_fsm *fsm, int sev,
235: const char *prefix, const u_char *pkt);
236:
237: static pevent_handler_t ppp_fsm_timeout;
238:
239: static const char *st2str(u_int state);
240: static const char *ev2str(u_int event);
241: static const char *cd2str(u_int code);
242:
243: /***********************************************************************
244: PUBLIC API FUNCTIONS
245: ***********************************************************************/
246:
247: /*
248: * Create a new FSM.
249: *
250: * "inst" is freed when the FSM is destroyed.
251: */
252: struct ppp_fsm *
253: ppp_fsm_create(struct pevent_ctx *ev_ctx, pthread_mutex_t *mutex,
254: struct ppp_fsm_instance *inst, struct ppp_log *log)
255: {
256: struct ppp_fsm *fsm;
257: int i;
258:
259: /* Get new FSM object */
260: if ((fsm = MALLOC(FSM_MTYPE, sizeof(*fsm))) == NULL)
261: return (NULL);
262: memset(fsm, 0, sizeof(*fsm));
263: fsm->ev_ctx = ev_ctx;
264: fsm->mutex = mutex;
265: fsm->inst = inst;
266: fsm->state = FSM_STATE_INITIAL;
267:
268: /* Prefix log with FSM name */
269: if ((fsm->log = ppp_log_prefix(log,
270: "%s: ", inst->type->name)) == NULL) {
271: FREE(FSM_MTYPE, fsm);
272: return (NULL);
273: }
274:
275: /* Get message port */
276: if ((fsm->outport = mesg_port_create(inst->type->name)) == NULL) {
277: FREE(FSM_MTYPE, fsm);
278: return (NULL);
279: }
280:
281: /* For 'shell' FSM's like MP LCP, no config required */
282: if ((inst->type->sup_codes & (1 << FSM_CODE_CONFIGREQ)) == 0) {
283: fsm->state = FSM_STATE_OPENED;
284: return (fsm);
285: }
286:
287: /* Initialize configuration options */
288: for (i = 0; i < FSM_CONF_MAX; i++) {
289: if ((fsm->config[i] = ppp_fsm_option_create()) == NULL) {
290: while (i-- > 0)
291: ppp_fsm_option_destroy(&fsm->config[i]);
292: mesg_port_destroy(&fsm->outport);
293: FREE(FSM_MTYPE, fsm);
294: return (NULL);
295: }
296: }
297:
298: /* Done */
299: inst->fsm = fsm;
300: return (fsm);
301: }
302:
303: /*
304: * Destroy an FSM
305: */
306: void
307: ppp_fsm_destroy(struct ppp_fsm **fsmp)
308: {
309: struct ppp_fsm *const fsm = *fsmp;
310: struct ppp_fsm_output *output;
311: int i;
312:
313: if (fsm == NULL)
314: return;
315: *fsmp = NULL;
316: pevent_unregister(&fsm->timer);
317: for (i = 0; i < FSM_CONF_MAX; i++)
318: ppp_fsm_option_destroy(&fsm->config[i]);
319: while ((output = mesg_port_get(fsm->outport, 0)) != NULL)
320: ppp_fsm_free_output(output);
321: mesg_port_destroy(&fsm->outport);
322: (*fsm->inst->type->destroy)(fsm->inst);
323: ppp_log_close(&fsm->log);
324: FREE(FSM_MTYPE, fsm);
325: }
326:
327: /*
328: * Get output port.
329: */
330: struct mesg_port *
331: ppp_fsm_get_outport(struct ppp_fsm *fsm)
332: {
333: return (fsm->outport);
334: }
335:
336: /*
337: * Free an FSM output structure.
338: */
339: void
340: ppp_fsm_free_output(struct ppp_fsm_output *output)
341: {
342: switch (output->type) {
343: case FSM_OUTPUT_DATA:
344: FREE(FSM_MTYPE, output->u.data.data);
345: break;
346: default:
347: break;
348: }
349: FREE(FSM_MTYPE, output);
350: }
351:
352: /*
353: * Input something to the FSM.
354: */
355: void
356: ppp_fsm_input(struct ppp_fsm *fsm, enum ppp_fsm_input input, ...)
357: {
358: const u_char *data;
359: va_list args;
360: u_int dlen;
361:
362: /* If we're dead, ignore it */
363: if (FSM_DEAD(fsm))
364: return;
365:
366: /* Handle input */
367: va_start(args, input);
368: switch (input) {
369: case FSM_INPUT_OPEN:
370: ppp_fsm_event(fsm, OPEN);
371: break;
372: case FSM_INPUT_CLOSE:
373: ppp_fsm_record(fsm, FSM_REASON_CLOSE);
374: ppp_fsm_event(fsm, CLOSE);
375: break;
376: case FSM_INPUT_UP:
377: ppp_fsm_event(fsm, UP);
378: break;
379: case FSM_INPUT_DOWN_FATAL:
380: ppp_fsm_record(fsm, FSM_REASON_DOWN_FATAL);
381: ppp_fsm_event(fsm, DOWN);
382: ppp_fsm_event(fsm, CLOSE);
383: break;
384: case FSM_INPUT_DOWN_NONFATAL:
385: ppp_fsm_record(fsm, FSM_REASON_DOWN_NONFATAL);
386: ppp_fsm_event(fsm, DOWN);
387: break;
388: case FSM_INPUT_RECD_PROTOREJ:
389: {
390: u_int16_t proto;
391:
392: proto = va_arg(args, int);
393: ppp_fsm_record(fsm, FSM_REASON_PROTOREJ, proto);
394: ppp_fsm_event(fsm, RXJ_M);
395: break;
396: }
397: case FSM_INPUT_DATA:
398: data = va_arg(args, const u_char *);
399: dlen = va_arg(args, u_int);
400: ppp_fsm_input_packet(fsm, data, dlen);
401: break;
402: case FSM_INPUT_XMIT_PROTOREJ:
403: {
404: u_int16_t proto;
405: u_int16_t *prj;
406: u_int prlen;
407:
408: proto = va_arg(args, int);
409: data = va_arg(args, const u_char *);
410: dlen = va_arg(args, u_int);
411: prlen = 2 + MIN(dlen, MAX_PKTCOPY);
412: if ((prj = MALLOC(TYPED_MEM_TEMP, prlen)) == NULL)
413: break;
414: *prj = htons(proto);
415: memcpy((char *)prj + 2, data, MIN(dlen, MAX_PKTCOPY));
416: ppp_fsm_send_packet(fsm, FSM_CODE_PROTOREJ, prj, prlen);
417: FREE(TYPED_MEM_TEMP, prj);
418: break;
419: }
420: default:
421: LOG(LOG_ERR, "invalid input %d", input);
422: break;
423: }
424: va_end(args);
425: }
426:
427: /*
428: * Get FSM state.
429: */
430: enum ppp_fsm_state
431: ppp_fsm_get_state(struct ppp_fsm *fsm)
432: {
433: return (fsm->state);
434: }
435:
436: /*
437: * Get time we last heard from the peer.
438: */
439: time_t
440: ppp_fsm_last_heard(struct ppp_fsm *fsm)
441: {
442: return (fsm->last_heard);
443: }
444:
445: /*
446: * Get underlying FSM instance.
447: */
448: struct ppp_fsm_instance *
449: ppp_fsm_get_instance(struct ppp_fsm *fsm)
450: {
451: return (fsm->inst);
452: }
453:
454: /*
455: * Send a reset-request.
456: */
457: void
458: ppp_fsm_send_reset_req(struct ppp_fsm *fsm, const void *data, size_t dlen)
459: {
460: fsm->ids[FSM_CODE_RESETREQ]++;
461: ppp_fsm_send_packet(fsm, FSM_CODE_RESETREQ, data, dlen);
462: }
463:
464: /*
465: * Send a reset-ack.
466: */
467: void
468: ppp_fsm_send_reset_ack(struct ppp_fsm *fsm, const void *data, size_t dlen)
469: {
470: ppp_fsm_send_packet(fsm, FSM_CODE_RESETACK, data, dlen);
471: }
472:
473: /***********************************************************************
474: INTERNAL FUNCTIONS
475: ***********************************************************************/
476:
477: /*
478: * Handle an incoming packet
479: */
480: static void
481: ppp_fsm_input_packet(struct ppp_fsm *fsm, const u_char *pkt, u_int dlen)
482: {
483: const u_char *const payload = pkt + sizeof(struct ppp_fsm_pkt);
484: const struct ppp_fsm_type *const ftyp = fsm->inst->type;
485: struct ppp_fsm_options *opts = NULL;
486: struct ppp_fsm_pkt hdr;
487: u_int len;
488:
489: /* Drop packet if it's unexpected */
490: if (fsm->state == FSM_STATE_INITIAL
491: || fsm->state == FSM_STATE_STARTING)
492: goto done;
493:
494: /* Check packet length */
495: if (dlen < sizeof(hdr)) {
496: LOG(LOG_NOTICE, "rec'd %s packet (%u bytes)", "runt", dlen);
497: goto done;
498: }
499:
500: /* Copy packet header into aligned memory */
501: memcpy(&hdr, pkt, sizeof(hdr));
502:
503: /* Check packet length again */
504: if ((len = ntohs(hdr.length)) < sizeof(hdr)) {
505: LOG(LOG_NOTICE, "rec'd %s packet (%u bytes)", "runt", dlen);
506: goto done;
507: }
508: if (len > dlen) {
509: LOG(LOG_NOTICE, "rec'd %s packet (%u bytes)",
510: "truncated", dlen);
511: goto done;
512: }
513: len -= sizeof(hdr); /* get length of just the data part */
514:
515: /* Check code; send code-reject if not supported */
516: if (hdr.code >= FSM_CODE_MAX
517: || (ftyp->sup_codes & (1 << hdr.code)) == 0) {
518: code_reject: LOG(LOG_DEBUG, "rejecting unsupported code %u", hdr.code);
519: ppp_fsm_send_packet(fsm, FSM_CODE_CODEREJ,
520: pkt, MIN(dlen, MAX_PKTCOPY));
521: goto done;
522: }
523:
524: /* Check data length */
525: if (len < fsm_minlen[hdr.code]) {
526: LOG(LOG_DEBUG + 1, "ignoring truncated packet");
527: goto done;
528: }
529:
530: /* Reset peer's idle time */
531: fsm->last_heard = time(NULL);
532:
533: /* Initialize failure counters if appropriate */
534: if (fsm->state < FSM_STATE_REQSENT) {
535: fsm->failure[PPP_SELF] = FSM_MAX_FAILURE;
536: fsm->failure[PPP_PEER] = FSM_MAX_FAILURE;
537: }
538:
539: /* Logging */
540: ppp_fsm_log_pkt(fsm, (hdr.code == FSM_CODE_ECHOREQ
541: || hdr.code == FSM_CODE_ECHOREP) ? LOG_DEBUG : LOG_INFO,
542: "recv", pkt);
543:
544: /* Extract encoded config options */
545: switch (hdr.code) {
546: case FSM_CODE_CONFIGREQ:
547: case FSM_CODE_CONFIGACK:
548: case FSM_CODE_CONFIGNAK:
549: case FSM_CODE_CONFIGREJ:
550: ppp_fsm_record(fsm, FSM_REASON_CONF, hdr.code);
551: if ((opts = ppp_fsm_option_unpack(payload, len)) == NULL) {
552: ppp_fsm_syserr(fsm, "malloc");
553: goto close;
554: }
555: break;
556: default:
557: break;
558: }
559:
560: /* Check magic number */
561: switch (hdr.code) {
562: case FSM_CODE_ECHOREQ:
563: case FSM_CODE_ECHOREP:
564: case FSM_CODE_IDENT:
565: case FSM_CODE_DISCREQ:
566: case FSM_CODE_TIMEREM:
567: {
568: u_int32_t pkt_magic;
569: u_int32_t req_magic;
570:
571: /* Get what peer's magic number ought to be */
572: if (ftyp->get_magic == NULL)
573: break;
574: req_magic = (*ftyp->get_magic)(fsm->inst, PPP_PEER);
575:
576: /* Get actual magic number received */
577: memcpy(&pkt_magic, payload, 4);
578: pkt_magic = ntohl(pkt_magic);
579:
580: /*
581: * Only check if both magic numbers are non-zero and
582: * the FSM has reached the opened state.
583: */
584: if (req_magic == 0
585: || pkt_magic == 0
586: || fsm->state != FSM_STATE_OPENED)
587: break;
588:
589: /* If wrong, bail out */
590: if (pkt_magic != req_magic) {
591: LOG(LOG_NOTICE,
592: "rec'd %s with invalid magic# 0x%08x != 0x%08x",
593: cd2str(hdr.code), pkt_magic, req_magic);
594: ppp_fsm_record(fsm, FSM_REASON_BADMAGIC);
595: goto close;
596: }
597: break;
598: }
599: default:
600: break;
601: }
602:
603: /* Deal with packet */
604: switch (hdr.code) {
605: case FSM_CODE_VENDOR:
606: if (ftyp->recv_vendor == NULL)
607: goto code_reject;
608: (*ftyp->recv_vendor)(fsm->inst, payload, len);
609: break;
610:
611: case FSM_CODE_CONFIGREQ:
612: {
613: int ack;
614: int i;
615:
616: /* Update reply id's */
617: fsm->ids[FSM_CODE_CONFIGACK] = hdr.id;
618: fsm->ids[FSM_CODE_CONFIGNAK] = hdr.id;
619: fsm->ids[FSM_CODE_CONFIGREJ] = hdr.id;
620:
621: /* Update peer's requested options with new info */
622: ppp_fsm_option_destroy(&fsm->config[FSM_CONF_PEER]);
623: fsm->config[FSM_CONF_PEER] = opts;
624: opts = NULL; /* avoid double free */
625:
626: /* Reset nak and rej reply options */
627: ppp_fsm_option_zero(fsm->config[FSM_CONF_NAK]);
628: ppp_fsm_option_zero(fsm->config[FSM_CONF_REJ]);
629:
630: /* Examine peer's options for basic validity */
631: for (i = 0; i < fsm->config[FSM_CONF_PEER]->num; i++) {
632: const struct ppp_fsm_option *const opt
633: = &fsm->config[FSM_CONF_PEER]->opts[i];
634: const struct ppp_fsm_optdesc *const desc
635: = ppp_fsm_option_desc(ftyp->options, opt);
636:
637: /* If not supported or invalid, reject it */
638: if (desc == NULL
639: || !desc->supported
640: || opt->len < desc->min
641: || opt->len > desc->max) {
642:
643: /* Add to reject list */
644: if (ppp_fsm_option_add(
645: fsm->config[FSM_CONF_REJ],
646: opt->type, opt->len, opt->data) == -1) {
647: ppp_fsm_syserr(fsm, "malloc");
648: goto close;
649: }
650:
651: /* Remove from request list */
652: ppp_fsm_option_del(
653: fsm->config[FSM_CONF_PEER], i--);
654: }
655: }
656:
657: /* Call FSM type method to deal with remaining options */
658: if ((*ftyp->recv_conf_req)(fsm->inst,
659: fsm->config[FSM_CONF_PEER],
660: fsm->config[FSM_CONF_NAK],
661: fsm->config[FSM_CONF_REJ]) == -1)
662: goto config_error;
663:
664: /* Check if not converging */
665: if (fsm->config[FSM_CONF_NAK]->num > 0
666: && --fsm->failure[PPP_PEER] <= 0) {
667: LOG(LOG_NOTICE, "negotiation failed to converge:"
668: " configuration not accepted by %s", "me");
669: ppp_fsm_record(fsm, FSM_REASON_NEGOT);
670: goto close;
671: }
672:
673: /* Evoke RCR+ or RCR- event */
674: ack = (fsm->config[FSM_CONF_NAK]->num
675: + fsm->config[FSM_CONF_REJ]->num == 0);
676: if (ack)
677: fsm->failure[PPP_PEER] = FSM_MAX_FAILURE;
678: ppp_fsm_event(fsm, ack ? RCR_P : RCR_M);
679: break;
680: }
681:
682: case FSM_CODE_CONFIGACK:
683:
684: /* Validate id and contents */
685: if (hdr.id != fsm->ids[FSM_CODE_CONFIGREQ]) {
686: LOG(LOG_DEBUG + 1, "ignoring id #%u", hdr.id);
687: goto done;
688: }
689: if (!ppp_fsm_option_equal(opts, -1,
690: fsm->config[FSM_CONF_SELF], -1)) {
691: LOG(LOG_DEBUG + 1, "ignoring altered contents");
692: goto done;
693: }
694:
695: /* Generate RCA event */
696: fsm->ids[FSM_CODE_CONFIGREQ]++;
697: fsm->failure[PPP_SELF] = FSM_MAX_FAILURE;
698: ppp_fsm_event(fsm, RCA);
699: break;
700:
701: case FSM_CODE_CONFIGNAK:
702: case FSM_CODE_CONFIGREJ:
703: {
704: int (*func)(struct ppp_fsm_instance *inst,
705: struct ppp_fsm_options *rej);
706:
707: /* Validate id */
708: if (hdr.id != fsm->ids[FSM_CODE_CONFIGREQ]) {
709: LOG(LOG_DEBUG + 1, "ignoring id #%u", hdr.id);
710: goto done;
711: }
712:
713: /* Check if not converging */
714: if (hdr.code == FSM_CODE_CONFIGNAK
715: && --fsm->failure[PPP_SELF] <= 0) {
716: LOG(LOG_NOTICE, "negotiation failed to converge:"
717: " configuration not accepted by %s", "peer");
718: ppp_fsm_record(fsm, FSM_REASON_NEGOT);
719: goto close;
720: }
721:
722: /* Call implementation to deal with options */
723: func = (hdr.code == FSM_CODE_CONFIGNAK) ?
724: ftyp->recv_conf_nak : ftyp->recv_conf_rej;
725: if ((*func)(fsm->inst, opts) == -1) {
726: config_error: if (errno == ELOOP)
727: ppp_fsm_record(fsm, FSM_REASON_LOOPBACK);
728: else if (errno == EINVAL)
729: ppp_fsm_record(fsm, FSM_REASON_NEGOT);
730: else
731: ppp_fsm_record(fsm, FSM_REASON_SYSERR, errno);
732: goto close;
733: }
734:
735: /* Generate RCN event */
736: fsm->ids[FSM_CODE_CONFIGREQ]++;
737: ppp_fsm_event(fsm, RCN);
738: break;
739: }
740:
741: case FSM_CODE_TERMREQ:
742:
743: /* Generate RTR event */
744: fsm->ids[FSM_CODE_TERMACK] = hdr.id;
745: ppp_fsm_record(fsm, FSM_REASON_TERM);
746: ppp_fsm_event(fsm, RTR);
747: goto close;
748:
749: case FSM_CODE_TERMACK:
750:
751: /* Validate id */
752: if (hdr.id != fsm->ids[FSM_CODE_TERMREQ]) {
753: LOG(LOG_DEBUG + 1, "ignoring id #%u", hdr.id);
754: goto done;
755: }
756: fsm->ids[FSM_CODE_TERMREQ]++;
757:
758: /* Generate RTA event */
759: fsm->ids[FSM_CODE_TERMACK] = hdr.id;
760: ppp_fsm_event(fsm, RTA);
761: break;
762:
763: case FSM_CODE_CODEREJ:
764: {
765: const u_char code = payload[0];
766:
767: /* See if rejected code is required */
768: if (code >= FSM_CODE_MAX
769: || (ftyp->req_codes & (1 << code)) == 0) {
770: fsm->rejcode[code] = 1;
771: ppp_fsm_event(fsm, RXJ_P);
772: } else {
773: ppp_fsm_record(fsm, FSM_REASON_CODEREJ, code);
774: ppp_fsm_event(fsm, RXJ_M);
775: goto close;
776: }
777: break;
778: }
779:
780: case FSM_CODE_PROTOREJ:
781: {
782: u_int16_t proto;
783:
784: /* Get rejected protocol */
785: memcpy(&proto, payload, 2);
786: proto = ntohs(proto);
787: if (proto == ftyp->proto) {
788: ppp_fsm_record(fsm, FSM_REASON_PROTOREJ, proto);
789: ppp_fsm_event(fsm, RXJ_M);
790: goto close;
791: }
792: ppp_fsm_output(fsm, FSM_OUTPUT_PROTOREJ, proto);
793: ppp_fsm_event(fsm, RXJ_P); /* assume RXJ+ until hear o/w */
794: break;
795: }
796:
797: case FSM_CODE_ECHOREQ:
798: {
799: u_char buf[MAX_PKTCOPY];
800: u_int32_t magic;
801:
802: /* Update reply id */
803: fsm->ids[FSM_CODE_ECHOREP] = hdr.id;
804:
805: /* Only reply when in opened state (except MP LCP) */
806: if (fsm->state != FSM_STATE_OPENED) {
807: LOG(LOG_DEBUG + 1, "ignoring: not in %s yet",
808: st2str(FSM_STATE_OPENED));
809: goto done;
810: }
811:
812: /* Insert my magic number and reply */
813: memcpy(buf, payload, MIN(len, sizeof(buf)));
814: magic = (ftyp->get_magic != NULL) ?
815: (*ftyp->get_magic)(fsm->inst, PPP_SELF) : 0;
816: magic = htonl(magic);
817: memcpy(buf, &magic, 4);
818: ppp_fsm_send_packet(fsm, FSM_CODE_ECHOREP,
819: buf, MIN(len, sizeof(buf)));
820: break;
821: }
822: case FSM_CODE_RESETREQ:
823: if (ftyp->recv_reset_req == NULL)
824: goto code_reject;
825: fsm->ids[FSM_CODE_RESETACK] = hdr.id;
826: (*ftyp->recv_reset_req)(fsm->inst, payload, len);
827: break;
828:
829: case FSM_CODE_RESETACK:
830: if (ftyp->recv_reset_ack == NULL)
831: goto code_reject;
832: if (hdr.id != fsm->ids[FSM_CODE_RESETREQ])
833: break;
834: (*ftyp->recv_reset_ack)(fsm->inst, payload, len);
835: break;
836:
837: case FSM_CODE_ECHOREP: /* ignore these */
838: case FSM_CODE_IDENT:
839: case FSM_CODE_DISCREQ:
840: case FSM_CODE_TIMEREM:
841: break;
842:
843: default: /* already handled above */
844: break;
845: }
846:
847: /* Done */
848: goto done;
849:
850: close:
851: /* Handle failure by closing up shop */
852: ppp_fsm_event(fsm, CLOSE);
853:
854: done:
855: /* Clean up */
856: ppp_fsm_option_destroy(&opts);
857: }
858:
859: /*
860: * Handle an event
861: */
862: static void
863: ppp_fsm_event(struct ppp_fsm *fsm, int event)
864: {
865: const int ostate = fsm->state;
866: const int action = fsm_actions[event][fsm->state];
867:
868: /* Debugging */
869: if (action == NA) {
870: LOG(LOG_ERR, "%s event %s in state %s",
871: "invalid", ev2str(event), st2str(fsm->state));
872: return;
873: }
874: LOG(LOG_DEBUG, "event %s in state %s",
875: ev2str(event), st2str(fsm->state));
876:
877: /* Perform actions */
878: if ((action & TLU) != 0)
879: ppp_fsm_output(fsm, FSM_OUTPUT_UP);
880: if ((action & TLD) != 0)
881: ppp_fsm_output(fsm, FSM_OUTPUT_DOWN, fsm->dead.u.down.reason);
882: if ((action & TLS) != 0)
883: ppp_fsm_output(fsm, FSM_OUTPUT_OPEN);
884: if ((action & TLF) != 0)
885: ppp_fsm_output(fsm, FSM_OUTPUT_CLOSE);
886: if ((action & IRC) != 0) {
887: fsm->restart = (event == CLOSE || event == RXJ_M) ?
888: FSM_MAX_TERMINATE : FSM_MAX_CONFIGURE;
889: }
890: if ((action & SCR) != 0)
891: ppp_fsm_send_config(fsm, FSM_CODE_CONFIGREQ);
892: if ((action & SCA) != 0)
893: ppp_fsm_send_config(fsm, FSM_CODE_CONFIGACK);
894: if ((action & SCN) != 0) {
895: if (fsm->config[FSM_CONF_REJ]->num != 0)
896: ppp_fsm_send_config(fsm, FSM_CODE_CONFIGREJ);
897: if (fsm->config[FSM_CONF_NAK]->num != 0)
898: ppp_fsm_send_config(fsm, FSM_CODE_CONFIGNAK);
899: }
900: if ((action & STR) != 0)
901: ppp_fsm_send_packet(fsm, FSM_CODE_TERMREQ, NULL, 0);
902: if ((action & STA) != 0)
903: ppp_fsm_send_packet(fsm, FSM_CODE_TERMACK, NULL, 0);
904:
905: /* Transition to new state */
906: fsm->state = (action & STMASK);
907: if (fsm->state != ostate)
908: LOG(LOG_DEBUG, "%s -> %s", st2str(ostate), st2str(fsm->state));
909:
910: /* Initialize failure counter if appropriate */
911: if (ostate < FSM_STATE_REQSENT && fsm->state >= FSM_STATE_REQSENT) {
912: fsm->failure[PPP_SELF] = FSM_MAX_FAILURE;
913: fsm->failure[PPP_PEER] = FSM_MAX_FAILURE;
914: }
915:
916: /* Stop the restart timer if it's not supposed to be running */
917: if (!FSM_TIMER_STATE(fsm->state)) {
918: pevent_unregister(&fsm->timer);
919: goto no_timer;
920: }
921:
922: /* Check if timer is already running and doesn't need to be restarted */
923: if (FSM_TIMER_STATE(ostate) && (action & (SCR|STR)) == 0)
924: goto no_timer;
925:
926: /* (Re)start restart timer */
927: pevent_unregister(&fsm->timer);
928: if (pevent_register(fsm->ev_ctx, &fsm->timer, 0, fsm->mutex,
929: ppp_fsm_timeout, fsm, PEVENT_TIME, FSM_TIMEOUT * 1000) == -1) {
930: ppp_fsm_syserr(fsm, "pevent_register");
931: return;
932: }
933:
934: no_timer:
935: /* Emit 'dead' output if we're dead */
936: if (FSM_DEAD(fsm))
937: ppp_fsm_output_dead(fsm);
938: }
939:
940: /*
941: * Send a config req, ack, nak, or rej packet
942: */
943: static void
944: ppp_fsm_send_config(struct ppp_fsm *fsm, enum ppp_fsm_code code)
945: {
946: const struct ppp_fsm_type *const ftyp = fsm->inst->type;
947: struct ppp_fsm_options *opts;
948: u_char *buf;
949: u_int len;
950:
951: /* Get the corresponding config option data */
952: switch (code) {
953: case FSM_CODE_CONFIGREQ:
954: {
955: u_int i;
956: u_int j;
957:
958: /* Regenerate my requested config options */
959: opts = fsm->config[FSM_CONF_SELF];
960: ppp_fsm_option_zero(opts);
961: if ((*ftyp->build_conf_req)(fsm->inst, opts) == -1) {
962: if (errno == EINVAL)
963: ppp_fsm_record(fsm, FSM_REASON_NEGOT);
964: else
965: ppp_fsm_syserr(fsm, "build_conf_req");
966: return;
967: }
968:
969: /* Elide default values from within config-request */
970: if (fsm->inst->type->defaults == NULL)
971: break;
972: for (i = 0; i < fsm->inst->type->defaults->num; i++) {
973: for (j = 0; j < opts->num; j++) {
974: if (ppp_fsm_option_equal(
975: fsm->inst->type->defaults, i, opts, j))
976: ppp_fsm_option_del(opts, j--);
977: }
978: }
979: break;
980: }
981: case FSM_CODE_CONFIGACK:
982: opts = fsm->config[FSM_CONF_PEER];
983: break;
984: case FSM_CODE_CONFIGNAK:
985: opts = fsm->config[FSM_CONF_NAK];
986: break;
987: case FSM_CODE_CONFIGREJ:
988: opts = fsm->config[FSM_CONF_REJ];
989: break;
990: default:
991: assert (0);
992: return;
993: }
994:
995: /* Construct packet payload */
996: len = ppp_fsm_option_packlen(opts);
997: if ((buf = MALLOC(TYPED_MEM_TEMP, len)) == NULL) {
998: LOG(LOG_ERR, "%s: %m", "malloc");
999: ppp_fsm_syserr(fsm, "malloc");
1000: return;
1001: }
1002:
1003: /* Send packet */
1004: ppp_fsm_option_pack(opts, buf);
1005: ppp_fsm_send_packet(fsm, code, buf, len);
1006: FREE(TYPED_MEM_TEMP, buf);
1007: }
1008:
1009: /*
1010: * Handler for an FSM timeout event.
1011: */
1012: static void
1013: ppp_fsm_timeout(void *arg)
1014: {
1015: struct ppp_fsm *const fsm = arg;
1016:
1017: /* Cancel event */
1018: pevent_unregister(&fsm->timer);
1019:
1020: /* If we're dead, ignore it */
1021: if (FSM_DEAD(fsm))
1022: return;
1023:
1024: /* Send timeout event */
1025: if (--fsm->restart <= 0)
1026: ppp_fsm_event(fsm, TO_M);
1027: else
1028: ppp_fsm_event(fsm, TO_P);
1029: }
1030:
1031: /*
1032: * Send a packet.
1033: *
1034: * Handle any errors by shutting down the FSM.
1035: */
1036: static void
1037: ppp_fsm_send_packet(struct ppp_fsm *fsm,
1038: u_char code, const void *data, u_int len)
1039: {
1040: struct ppp_fsm_pkt *pkt;
1041:
1042: /* If peer rejected code, don't bother */
1043: if (fsm->rejcode[code])
1044: return;
1045:
1046: /* Build packet */
1047: if ((pkt = MALLOC(FSM_MTYPE, sizeof(*pkt) + len)) == NULL) {
1048: ppp_fsm_syserr(fsm, "malloc");
1049: return;
1050: }
1051: pkt->code = code;
1052: pkt->id = fsm->ids[code];
1053: pkt->length = htons(sizeof(*pkt) + len);
1054: memcpy(pkt->data, data, len);
1055:
1056: /* Logging */
1057: ppp_fsm_log_pkt(fsm, (pkt->code == FSM_CODE_ECHOREQ
1058: || pkt->code == FSM_CODE_ECHOREP) ? LOG_DEBUG : LOG_INFO,
1059: "xmit", (u_char *)pkt);
1060:
1061: /* Send packet */
1062: if (ppp_fsm_output(fsm, FSM_OUTPUT_DATA, pkt, sizeof(*pkt) + len) == -1)
1063: FREE(FSM_MTYPE, pkt);
1064: }
1065:
1066: /*
1067: * Record the reason for the FSM going down or dying.
1068: *
1069: * This information is saved until it can be output later.
1070: */
1071: static void
1072: ppp_fsm_record(struct ppp_fsm *fsm, ...)
1073: {
1074: struct ppp_fsm_output *const output = &fsm->dead;
1075: va_list args;
1076:
1077: /* Prioritize reason first on severity, then first come, first serve */
1078: if (fsm->dead.u.down.reason == 0)
1079: goto record;
1080: switch (fsm->dead.u.down.reason) {
1081: case FSM_REASON_CONF:
1082: case FSM_REASON_DOWN_NONFATAL:
1083: break;
1084: default:
1085: return;
1086: }
1087:
1088: record:
1089: /* Build output message */
1090: va_start(args, fsm);
1091: ppp_fsm_output_build(output, FSM_OUTPUT_DEAD, args);
1092: va_end(args);
1093: }
1094:
1095: /*
1096: * Emit some sort of output from the FSM.
1097: *
1098: * Any errors are handled internally by shutting down the FSM.
1099: */
1100: static int
1101: ppp_fsm_output(struct ppp_fsm *fsm, enum ppp_fsmoutput type, ...)
1102: {
1103: struct ppp_fsm_output *output;
1104: va_list args;
1105:
1106: /* Allocate new output message */
1107: if ((output = MALLOC(FSM_MTYPE, sizeof(*output))) == NULL) {
1108: ppp_fsm_syserr(fsm, "malloc");
1109: return (-1);
1110: }
1111: memset(output, 0, sizeof(*output));
1112:
1113: /* Build output message */
1114: va_start(args, type);
1115: ppp_fsm_output_build(output, type, args);
1116: va_end(args);
1117:
1118: /* Send it */
1119: if (mesg_port_put(fsm->outport, output) == -1) {
1120: ppp_fsm_syserr(fsm, "mesg_port_put");
1121: FREE(FSM_MTYPE, output);
1122: return (-1);
1123: }
1124:
1125: /* Done */
1126: return (0);
1127: }
1128:
1129: /*
1130: * Output FSM_OUTPUT_DEAD message because we're dead.
1131: *
1132: * This is called when we reach the initial state after a fatal error.
1133: * We copy the reason information previously recorded via ppp_fsm_record().
1134: */
1135: static void
1136: ppp_fsm_output_dead(struct ppp_fsm *fsm)
1137: {
1138: struct ppp_fsm_output *output;
1139:
1140: /* Create new output message */
1141: if ((output = MALLOC(FSM_MTYPE, sizeof(*output))) == NULL) {
1142: ppp_fsm_syserr(fsm, "malloc");
1143: return;
1144: }
1145: memset(output, 0, sizeof(*output));
1146:
1147: /* Copy previously recorded output message, changing DOWN to DEAD */
1148: *output = fsm->dead;
1149:
1150: /* Send it */
1151: if (mesg_port_put(fsm->outport, output) == -1) {
1152: ppp_fsm_syserr(fsm, "mesg_port_put");
1153: FREE(FSM_MTYPE, output);
1154: }
1155: }
1156:
1157: /*
1158: * Build an FSM output structure.
1159: */
1160: static void
1161: ppp_fsm_output_build(struct ppp_fsm_output *output,
1162: enum ppp_fsmoutput type, va_list args)
1163: {
1164: output->type = type;
1165: switch (type) {
1166: case FSM_OUTPUT_OPEN:
1167: case FSM_OUTPUT_CLOSE:
1168: case FSM_OUTPUT_UP:
1169: break;
1170: case FSM_OUTPUT_DOWN:
1171: case FSM_OUTPUT_DEAD:
1172: output->u.down.reason = va_arg(args, int);
1173: switch (output->u.down.reason) {
1174: case FSM_REASON_SYSERR:
1175: output->u.down.u.error = va_arg(args, int);
1176: break;
1177: case FSM_REASON_CONF:
1178: case FSM_REASON_CODEREJ:
1179: output->u.down.u.code = va_arg(args, int);
1180: break;
1181: case FSM_REASON_PROTOREJ:
1182: output->u.down.u.proto = va_arg(args, int);
1183: break;
1184: default:
1185: break;
1186: }
1187: break;
1188: case FSM_OUTPUT_DATA:
1189: output->u.data.data = va_arg(args, u_char *);
1190: output->u.data.length = va_arg(args, u_int);
1191: break;
1192: case FSM_OUTPUT_PROTOREJ:
1193: output->u.proto = va_arg(args, int);
1194: break;
1195: default:
1196: assert(0);
1197: }
1198: }
1199:
1200: /*
1201: * Handle system error
1202: */
1203: static void
1204: ppp_fsm_syserr(struct ppp_fsm *fsm, const char *func)
1205: {
1206: LOG(LOG_ERR, "%s: %m", func);
1207: ppp_fsm_record(fsm, FSM_REASON_SYSERR, errno);
1208: }
1209:
1210: /*
1211: * Decode and log contents of an FSM packet
1212: */
1213: static void
1214: ppp_fsm_log_pkt(struct ppp_fsm *fsm, int sev,
1215: const char *prefix, const u_char *pkt)
1216: {
1217: const u_char *const payload = pkt + sizeof(struct ppp_fsm_pkt);
1218: struct ppp_fsm_pkt hdr;
1219: char buf[512] = { '\0' };
1220: u_int16_t dlen;
1221:
1222: memcpy(&hdr, pkt, sizeof(hdr));
1223: dlen = ntohs(hdr.length) - sizeof(hdr);
1224: switch (hdr.code) {
1225: case FSM_CODE_CONFIGREQ:
1226: case FSM_CODE_CONFIGNAK:
1227: case FSM_CODE_CONFIGREJ:
1228: case FSM_CODE_CONFIGACK:
1229: ppp_fsm_options_decode(fsm->inst->type->options,
1230: payload, dlen, buf, sizeof(buf));
1231: break;
1232: case FSM_CODE_CODEREJ:
1233: snprintf(buf, sizeof(buf), "code=%u", payload[0]);
1234: break;
1235: case FSM_CODE_PROTOREJ:
1236: snprintf(buf, sizeof(buf),
1237: "proto=0x%02x%02x", payload[0], payload[1]);
1238: break;
1239: case FSM_CODE_IDENT:
1240: case FSM_CODE_TERMREQ:
1241: case FSM_CODE_TERMACK:
1242: if (dlen > 0) {
1243: strlcpy(buf, "msg=\"", sizeof(buf));
1244: ppp_util_ascify(buf + strlen(buf),
1245: sizeof(buf) - strlen(buf), payload + 4, dlen - 4);
1246: strlcat(buf, "\"", sizeof(buf));
1247: }
1248: break;
1249: case FSM_CODE_TIMEREM:
1250: {
1251: u_int32_t remain;
1252: char tbuf[32];
1253:
1254: memcpy(&remain, payload + 4, 4);
1255: remain = ntohl(remain);
1256: if (remain == ~0)
1257: strlcpy(tbuf, "unlimited", sizeof(tbuf));
1258: else {
1259: snprintf(tbuf, sizeof(tbuf),
1260: "%lu seconds", (u_long)remain);
1261: }
1262: strlcpy(buf, "remaining=", sizeof(buf));
1263: strlcat(buf, tbuf, sizeof(buf));
1264: if (dlen > 4) {
1265: strlcat(buf, " msg=\"", sizeof(buf));
1266: ppp_util_ascify(buf + strlen(buf),
1267: sizeof(buf) - strlen(buf), payload + 8, dlen - 8);
1268: strlcat(buf, "\"", sizeof(buf));
1269: }
1270: break;
1271: }
1272: default:
1273: break;
1274: }
1275:
1276: /* Finally, log it */
1277: if (*buf == '\0')
1278: LOG(sev, "%s %s #%u", prefix, cd2str(hdr.code), hdr.id);
1279: else {
1280: LOG(sev, "%s %s #%u: %s", prefix,
1281: cd2str(hdr.code), hdr.id, buf);
1282: }
1283: }
1284:
1285: static const char *
1286: st2str(u_int state)
1287: {
1288: static const char *const snames[FSM_STATE_MAX] = {
1289: "INITIAL", "STARTING", "CLOSED", "STOPPED", "CLOSING",
1290: "STOPPING", "REQ-SENT", "ACK-RCVD", "ACK-SENT", "OPENED"
1291: };
1292: static char buf[16];
1293:
1294: if (state >= sizeof(snames) / sizeof(*snames)) {
1295: snprintf(buf, sizeof(buf), "?[%u]", state);
1296: return (buf);
1297: }
1298: return (snames[state]);
1299: }
1300:
1301: static const char *
1302: ev2str(u_int event)
1303: {
1304: static const char *const enames[FSM_EVENT_MAX] = {
1305: "UP", "DOWN", "OPEN", "CLOSE", "TO+", "TO-", "RCR+",
1306: "RCR-", "RCA", "RCN", "RTR", "RTA", "RXJ+", "RXJ-"
1307: };
1308: static char buf[16];
1309:
1310: if (event >= sizeof(enames) / sizeof(*enames)) {
1311: snprintf(buf, sizeof(buf), "?[%u]", event);
1312: return (buf);
1313: }
1314: return (enames[event]);
1315: }
1316:
1317: static const char *
1318: cd2str(u_int code)
1319: {
1320: static const char *const cnames[FSM_CODE_MAX] = {
1321: "Vendor", "Conf-Req", "Conf-Ack", "Conf-Nak", "Conf-Rej",
1322: "Term-Req", "Term-Ack", "Code-Rej", "Proto-Rej", "Echo-Req",
1323: "Echo-Rsp", "Disc-Req", "Ident", "Time-Rem", "Reset-Req",
1324: "Reset-Ack"
1325: };
1326: static char buf[16];
1327:
1328: if (code >= sizeof(cnames) / sizeof(*cnames)) {
1329: snprintf(buf, sizeof(buf), "?[%u]", code);
1330: return (buf);
1331: }
1332: return (cnames[code]);
1333: }
1334:
1335: /***********************************************************************
1336: PUBLIC DEBUGGING FUNCTIONS
1337: ***********************************************************************/
1338:
1339: /*
1340: * Return a string describing FSM output.
1341: */
1342: const char *
1343: ppp_fsm_output_str(struct ppp_fsm_output *output)
1344: {
1345: static char buf[256];
1346:
1347: switch (output->type) {
1348: case FSM_OUTPUT_OPEN:
1349: snprintf(buf, sizeof(buf), "OPEN");
1350: break;
1351: case FSM_OUTPUT_CLOSE:
1352: snprintf(buf, sizeof(buf), "CLOSE");
1353: break;
1354: case FSM_OUTPUT_UP:
1355: snprintf(buf, sizeof(buf), "UP");
1356: break;
1357: case FSM_OUTPUT_DOWN:
1358: snprintf(buf, sizeof(buf), "DOWN reason=%s",
1359: ppp_fsm_reason_str(output));
1360: break;
1361: case FSM_OUTPUT_DATA:
1362: snprintf(buf, sizeof(buf), "DATA type=%s",
1363: cd2str(output->u.data.data[0]));
1364: break;
1365: case FSM_OUTPUT_PROTOREJ:
1366: snprintf(buf, sizeof(buf), "PROTOREJ proto=0x%04x",
1367: output->u.proto);
1368: break;
1369: case FSM_OUTPUT_DEAD:
1370: snprintf(buf, sizeof(buf), "DEAD reason=%s",
1371: ppp_fsm_reason_str(output));
1372: break;
1373: default:
1374: snprintf(buf, sizeof(buf), "?[%u]?", output->type);
1375: break;
1376: }
1377: return (buf);
1378: }
1379:
1380: /*
1381: * Return a string describing a FSM_OUTPUT_DOWN or FSM_OUTPUT_DEAD output.
1382: */
1383: const char *
1384: ppp_fsm_reason_str(struct ppp_fsm_output *output)
1385: {
1386: static char buf[64];
1387:
1388: /* Sanity check */
1389: if (output->type != FSM_OUTPUT_DEAD
1390: && output->type != FSM_OUTPUT_DOWN)
1391: return ("?not FSM_OUTPUT_DOWN or FSM_OUTPUT_DEAD");
1392:
1393: /* Describe reason */
1394: switch (output->u.down.reason) {
1395: case FSM_REASON_CLOSE:
1396: strlcpy(buf, "administratively closed", sizeof(buf));
1397: break;
1398: case FSM_REASON_DOWN_FATAL:
1399: strlcpy(buf, "the underlying packet delivery"
1400: " layer failed (fatal)", sizeof(buf));
1401: break;
1402: case FSM_REASON_DOWN_NONFATAL:
1403: strlcpy(buf, "the underlying packet delivery"
1404: " layer failed (non-fatal)", sizeof(buf));
1405: break;
1406: case FSM_REASON_CONF:
1407: snprintf(buf, sizeof(buf),
1408: "rec'd %s after reaching opened state",
1409: cd2str(output->u.down.u.code));
1410: break;
1411: case FSM_REASON_TERM:
1412: snprintf(buf, sizeof(buf),
1413: "rec'd a Terminate-Request from peer");
1414: break;
1415: case FSM_REASON_CODEREJ:
1416: snprintf(buf, sizeof(buf),
1417: "rec'd a fatal Code-Reject (code=%s)",
1418: cd2str(output->u.down.u.code));
1419: break;
1420: case FSM_REASON_PROTOREJ:
1421: snprintf(buf, sizeof(buf),
1422: "rec'd a fatal Protocol-Reject (proto=0x%04x)",
1423: output->u.down.u.proto);
1424: break;
1425: case FSM_REASON_NEGOT:
1426: strlcpy(buf, "local and remote configurations"
1427: " are not compatible", sizeof(buf));
1428: break;
1429: case FSM_REASON_BADMAGIC:
1430: strlcpy(buf, "rec'd a packet with an invalid magic number",
1431: sizeof(buf));
1432: break;
1433: case FSM_REASON_LOOPBACK:
1434: strlcpy(buf, "a loopback condition was detected", sizeof(buf));
1435: break;
1436: case FSM_REASON_TIMEOUT:
1437: strlcpy(buf, "timed out waiting for an echo response",
1438: sizeof(buf));
1439: break;
1440: case FSM_REASON_SYSERR:
1441: snprintf(buf, sizeof(buf), "internal system error, error=%s",
1442: strerror(output->u.down.u.error));
1443: break;
1444: default:
1445: snprintf(buf, sizeof(buf), "?[%u]", output->u.down.reason);
1446: break;
1447: }
1448: return (buf);
1449: }
1450: