Annotation of embedaddon/mpd/src/fsm.h, revision 1.1.1.2

1.1       misho       1: 
                      2: /*
                      3:  * fsm.h
                      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: #ifndef _FSM_H_
                     15: #define _FSM_H_
                     16: 
                     17: #include <netinet/in.h>
                     18: #include "mbuf.h"
                     19: #include "timer.h"
                     20: #include <netgraph/ng_ppp.h>
                     21: 
                     22: /*
                     23:  * DEFINITIONS
                     24:  */
                     25: 
                     26:     /* States: don't change these! */
                     27:     enum fsm_state {
                     28:        ST_INITIAL = 0,
                     29:        ST_STARTING,
                     30:        ST_CLOSED,
                     31:        ST_STOPPED,
                     32:        ST_CLOSING,
                     33:        ST_STOPPING,
                     34:        ST_REQSENT,
                     35:        ST_ACKRCVD,
                     36:        ST_ACKSENT,
                     37:        ST_OPENED
                     38:     };
                     39: 
                     40:   #define OPEN_STATE(s)                ((s) > ST_CLOSING || ((s) & 1))
                     41: 
                     42:   #define MODE_REQ     0
                     43:   #define MODE_NAK     1
                     44:   #define MODE_REJ     2
                     45:   #define MODE_NOP     3
                     46: 
                     47:   /* Codes */
                     48:   #define CODE_VENDOR          0
                     49:   #define CODE_CONFIGREQ       1
                     50:   #define CODE_CONFIGACK       2
                     51:   #define CODE_CONFIGNAK       3
                     52:   #define CODE_CONFIGREJ       4
                     53:   #define CODE_TERMREQ         5
                     54:   #define CODE_TERMACK         6
                     55:   #define CODE_CODEREJ         7
                     56:   #define CODE_PROTOREJ                8
                     57:   #define CODE_ECHOREQ         9
                     58:   #define CODE_ECHOREP         10
                     59:   #define CODE_DISCREQ         11
                     60:   #define CODE_IDENT           12
                     61:   #define CODE_TIMEREM         13
                     62:   #define CODE_RESETREQ                14
                     63:   #define CODE_RESETACK                15
                     64: 
                     65:   /* All the various ways that the FSM can fail */
                     66:   /* XXX This should be extended to contain more descriptive information
                     67:      XXX about the cause of the failure, like what the rejected protocol
                     68:      XXX or option was, etc. */
                     69:   enum fsmfail {
                     70:     FAIL_NEGOT_FAILURE,                /* option negotiation failed */
                     71:     FAIL_RECD_BADMAGIC,                /* rec'd bad magic number */
                     72:     FAIL_RECD_CODEREJ,         /* rec'd fatal code reject */
                     73:     FAIL_RECD_PROTREJ,         /* rec'd fatal protocol reject */
                     74:     FAIL_WAS_PROTREJ,          /* protocol was rejected */
                     75:     FAIL_ECHO_TIMEOUT,         /* peer not responding to echo requests */
                     76:     FAIL_CANT_ENCRYPT          /* failed to negotiate required encryption */
                     77:   };
                     78: 
                     79:   /* FSM descriptor */
                     80:   struct fsm;
                     81:   typedef struct fsm                   *Fsm;
                     82:   struct fsmoption;
                     83:   typedef struct fsmoption             *FsmOption;
                     84:   struct fsmoptinfo;
                     85:   typedef const struct fsmoptinfo      *FsmOptInfo;
                     86: 
                     87:   struct fsmconf {
                     88:     short      maxconfig;      /* "Max-Configure" initial value */
                     89:     short      maxterminate;   /* "Max-Terminate" initial value */
                     90:     short      maxfailure;     /* "Max-Failure" initial value */
                     91:     short      echo_int;       /* LCP echo interval (zero disables) */
                     92:     short      echo_max;       /* LCP max quiet timeout */
                     93:     u_char     check_magic;    /* Validate any magic numbers seen */
                     94:     u_char     passive;        /* Passive option (see rfc 1661) */
                     95:   };
                     96:   typedef struct fsmconf       *FsmConf;
                     97: 
                     98:   struct fsmtype {
                     99:     const char         *name;          /* Name of protocol */
                    100:     uint16_t           proto;          /* Protocol number */
                    101:     uint16_t           known_codes;    /* Accepted FSM codes */
                    102:     u_char             link_layer;     /* Link level FSM */
                    103:     int                        log, log2;      /* Log levels for FSM events */
                    104: 
                    105:     void               (*NewState)(Fsm f, enum fsm_state old, enum fsm_state new);
                    106:     void               (*LayerUp)(Fsm f);
                    107:     void               (*LayerDown)(Fsm f);
                    108:     void               (*LayerStart)(Fsm f);
                    109:     void               (*LayerFinish)(Fsm f);
                    110:     u_char *           (*BuildConfigReq)(Fsm f, u_char *cp);
                    111:     void               (*DecodeConfig)(Fsm f, FsmOption a, int num, int mode);
                    112:     void               (*Configure)(Fsm f);
                    113:     void               (*UnConfigure)(Fsm f);
                    114:     void               (*SendTerminateReq)(Fsm f);
                    115:     void               (*SendTerminateAck)(Fsm f);
                    116:     int                        (*RecvCodeRej)(Fsm f, int code, Mbuf bp);
                    117:     int                        (*RecvProtoRej)(Fsm f, int proto, Mbuf bp);
                    118:     void               (*Failure)(Fsm f, enum fsmfail reason);
                    119:     void               (*RecvResetReq)(Fsm f, int id, Mbuf bp);
                    120:     void               (*RecvResetAck)(Fsm f, int id, Mbuf bp);
                    121:     void               (*RecvIdent)(Fsm f, Mbuf bp);
                    122:     void               (*RecvDiscReq)(Fsm f, Mbuf bp);
                    123:     void               (*RecvTimeRemain)(Fsm f, Mbuf bp);
                    124:     void               (*RecvVendor)(Fsm f, Mbuf bp);
                    125:   };
                    126:   typedef const struct fsmtype *FsmType;
                    127: 
                    128:   struct fsm {
                    129:     FsmType            type;           /* FSM constant stuff */
                    130:     void               *arg;           /* Context (Link or Bund) */
                    131:     int                        log;            /* Current log level */
                    132:     int                        log2;           /* Current log2 level */
                    133:     struct fsmconf     conf;           /* FSM parameters */
                    134:     enum fsm_state     state;          /* State of the machine */
                    135:     u_char             reqid;          /* Next request id */
                    136:     u_char             rejid;          /* Next reject id */
                    137:     u_char             echoid;         /* Next echo request id */
                    138:     short              restart;        /* Restart counter value */
                    139:     short              failure;        /* How many failures left */
                    140:     short              config;         /* How many configs left */
                    141:     short              quietCount;     /* How long peer has been silent */
                    142:     struct pppTimer    timer;          /* Restart Timer */
                    143:     struct pppTimer    echoTimer;      /* Keep-alive timer */
1.1.1.2 ! misho     144: #ifndef NG_PPP_STATS64
1.1       misho     145:     struct ng_ppp_link_stat
                    146:                        idleStats;      /* Stats for echo timeout */
1.1.1.2 ! misho     147: #else
        !           148:     struct ng_ppp_link_stat64
        !           149:                        idleStats;      /* Stats for echo timeout */
        !           150: #endif
1.1       misho     151:   };
                    152: 
                    153:   /* Packet header */
                    154:   struct fsmheader {
                    155:     u_char     code;           /* Request code */
                    156:     u_char     id;             /* Identification */
                    157:     u_short    length;         /* Length of packet */
                    158:   };
                    159:   typedef struct fsmheader     *FsmHeader;
                    160: 
                    161:   /* One config option */
                    162:   struct fsmoption {
                    163:     u_char     type;
                    164:     u_char     len;
                    165:     u_char     *data;
                    166:   };
                    167: 
                    168:   /* Fsm option descriptor */
                    169:   struct fsmoptinfo {
                    170:     const char *name;
                    171:     u_char     type;
                    172:     u_char     minLen;
                    173:     u_char     maxLen;
                    174:     u_char     supported;
                    175:   };
                    176: 
                    177: /*
                    178:  * VARIABLES
                    179:  */
                    180: 
                    181:   extern u_int         gAckSize, gNakSize, gRejSize;
                    182: 
                    183: /*
                    184:  * FUNCTIONS
                    185:  */
                    186: 
                    187:   extern void          FsmInit(Fsm f, FsmType t, void *arg);
                    188:   extern void          FsmInst(Fsm fp, Fsm fpt, void *arg);
                    189:   extern void          FsmOpen(Fsm f);
                    190:   extern void          FsmClose(Fsm f);
                    191:   extern void          FsmUp(Fsm f);
                    192:   extern void          FsmDown(Fsm f);
                    193:   extern void          FsmInput(Fsm f, Mbuf bp);
                    194:   extern void          FsmOutput(Fsm, u_int, u_int, u_char *, int);
                    195:   extern void          FsmOutputMbuf(Fsm, u_int, u_int, Mbuf);
                    196:   extern void          FsmSendEchoReq(Fsm fp, Mbuf payload);
                    197:   extern void          FsmSendIdent(Fsm fp, const char *ident);
                    198:   extern void          FsmSendTimeRemaining(Fsm fp, u_int seconds);
                    199:   extern u_char                *FsmConfValue(u_char *cp, int ty,
                    200:                                int len, const void *data);
                    201:   extern void          FsmFailure(Fsm fp, enum fsmfail reason);
                    202:   extern const char    *FsmFailureStr(enum fsmfail reason);
                    203: 
                    204:   extern void          FsmAck(Fsm fp, const struct fsmoption *opt);
                    205:   extern void          FsmNak(Fsm fp, const struct fsmoption *opt);
                    206:   extern void          FsmRej(Fsm fp, const struct fsmoption *opt);
                    207: 
                    208:   extern FsmOptInfo    FsmFindOptInfo(FsmOptInfo list, u_char type);
                    209:   extern const char    *FsmStateName(enum fsm_state state);
                    210:   extern const char    *FsmCodeName(int code);
                    211: 
                    212: #define Pref(fp)        ( (fp)->type->link_layer ? ((Link)((fp)->arg))->name : ((Bund)((fp)->arg))->name )
                    213: #define Fsm(fp)                 ( (fp)->type->name )
                    214: 
                    215: #endif /* _FSM_H_ */
                    216: 

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>