ppp.h

用于嵌入式系统的TCP/IP协议栈及若干服务

                                         */
#define CHAPS_PEER_AUTH_SUCCESS      3  /* Once we successfully rechallenge we go to
                                           this state.
                                         */


#define CHAPS_INVALID                255 /* Should generate a warning or assert */


/* CHAP states - us authenticating peer */
#define CHAPS_AUTH_PEER_INIT         PPP_AUTH_STATE_INIT

#define CHAPS_RESP_EXPECTED          1  /* We sent challenge and await the response.  If
                                           we don't get one we timeout and challenge again.
                                         */
#define CHAPS_AUTH_EXPECTED          2  /* We got a challenge response and are waiting for
                                           the authenticator (RADIUS, etc.) to OK the
                                           peer or fail the peer.
                                        */
#define CHAPS_AUTH_PEER_SUCCESS      3  /* The peer has authenticated us succesfully. */


                                    
/* For ppp_linkstate */
#define PPP_LINK_DOWN	0
#define PPP_LINK_UP		1

/* Bit field */
#define PPP_AUTH_PEER_REQUIRED  0x01
#define PPP_PEER_AUTH_REQUIRED  0x02
/*
 * Session specific structure
 */
typedef struct pppsession {
	netdev          * ppp_ndp;           
	struct m        * ppp_inmp;  
    u8              * ppp_txbuf;  /* Allocated in ppp_stuff, freed in ppp_transmit_complete */
	u16             ppp_inflag;          
	i16             ppp_inlen;           
    i16             ppp_mlen;     /* The space allocated for data in ppp_inmp */
	int             ppp_CompressOn;      
	int             ppp_chn;             
	u8				ppp_linkstate;
	char            * ppp_outbuf;        
	tcb             * ppp_retryter[NUM_PPP_LAYERS]; 
	tcb             * ppp_retrycfg[NUM_PPP_LAYERS]; 
    tcb             *ppp_start_timer; 
	tcb			    *ppp_persist_timer;
	u8              ppp_state[NUM_PPP_LAYERS];    
    u8              ppplcp_reqrcvd;      /* Used with LCP_PASSIVE option */
    u8              ppp_adminstate;     /* Are we open or closed? */
    u16             ppprestart;
    u16             ppplcp_flags;        
	lcpconfig       ppplcp_theirconfig;  
    lcpconfig       ppplcp_wantconfig;   
	lcpconfig       ppplcp_myconfig;     
	lcpconfig       ppplcp_negotconfig;  
    u16             pppipcp_flags;       
	ipcpconfig      pppipcp_theirconfig; 
    ipcpconfig      pppipcp_wantconfig;
	ipcpconfig      pppipcp_myconfig;    
	ipcpconfig      pppipcp_negotconfig; 
    u32             pppipcp_peeraddr;    
	u32             ppplcp_ramerr;       
	u32             pppipcp_ramerr;      
	pppretries      pppretry[NUM_PPP_LAYERS];   
    pppretries      pppmaxretry;
	u8              ppp_rasyncmap[0x20]; 
	u8              ppp_tasyncmap[0x100];
	int             ppp_datasize;        
	int             ppp_iphdrsize;       
	slcompress      ppp_comp;            

    /* We store usernames and passwords as NULL terminated strings.
       We add 1 to max length to allow for NULL termination.
    */
	char            pap_user[MAX_PPP_USER+1]; /* Peer PAP/CHAP name */   
	char            pap_passwd[MAX_PPP_PSWD+1]; /* Peer PAP password/CHAP secret */   
	char            pap_ourname[MAX_PPP_USER+1]; /* Our PAP username  */   
	char            pap_ourpasswd[MAX_PPP_PSWD+1]; /* Our PAP password secret */   
	char            chap_id[MAX_PPP_USER+1]; /* Our CHAP ID  */   
	char            chap_secret[MAX_PPP_PSWD+1]; /* Our CHAP secret */   
    m               *chap_response; /* Saved response to previous CHAP challenge
                                       for sending again if TON occurs.
                                    */
	u8              ppplcp_id;           
	u8              ppppro_id;           
	u8              pppipcp_id;          
	u8              ppppap_id;   /* This is our current ID for authenticating ourself */
    u8              ppppap_req_id; /* This is the most recent ID in the peer's request */
    u16             rechall_int;
	PPP_event		PPP_event_queue[PPP_MAX_EVENTS]; /* For the FSM for this 
                                                        session */
	int				PPP_evq_ix; /* The index of the next location to insert 
                                   a new event */
	int				PPP_evq_ox; /* The index of the next event to be read out 
                                   of the queue. */
								/* The queue is empty if PPP_evq_ix == PPP_evq_ox.  
                                   It is full when PPP_evq_ix == ((PPP_evq_ox - 1) 
                                   mod PPP_MAX_EVENTS).
								*/
    u8              chap_chall_id;    /* ID used in our challenge packets.  Peer response
                                         must match.
                                      */
    u8              chap_challenge_len;
    u8              chap_challenge_value[CHAP_CHALL_MAX_VAL_LEN];

    u8              auth_status;   /* Set to bitwise or of PPP_AUTH_PEER_REQUIRED
                                      and PPP_PEER_AUTH_REQUIRED.  Authentication
                                      complete when auth_status is zero.
                                    */
    m               *mp_auth;       /* This is the message we'll use to return and auth ack
                                       or auth nack to the peer.
                                    */
    u16             session_id;     /* An ID incremented once per each time a pppsession
                                       structure is used for a call.  
                                    */
#ifdef PPP_AUTH_SERVER
    ppp_auth_info   *p_auth_info;   /* Pointer to the authentication info associate with
                                       the PPP session.
                                    */
#endif
    u8   multi_session_device;      /* multi-session device flag */
    u8   pppoe_device;              /* PPPoE session flag */
    int  nd_flags;                  /* flags used by multi-session device */
                                    /* device driver registery */
    void (*p_serial_init) (netdev * ndp);
    int  (*p_serial_updown) (netdev * ndp, u16 flags, char * opt);
    void (*p_serial_write) (char *p_buffer, int length, netdev * ndp);
    int  (*p_ppp_local_start) (m *mp, void *psp);
} pppsession;

#ifdef PPPOE_PROTOCOL
#define SERIAL_WRITE(a,b,c,d)\
if ( ((pppsession *)d)->pppoe_device )\
((pppsession *)d)->p_serial_write(a,b,(netdev *)d);\
else\
((pppsession *)d)->p_serial_write(a,b,c)
#else
#define SERIAL_WRITE(a,b,c,d)\
((pppsession *)d)->p_serial_write(a,b,c)
#endif

#ifdef PPPOE_PROTOCOL
#define SERIAL_UPDOWN(a,b,c,d,e)\
if ( ((pppsession *)d)->pppoe_device )\
e = ((pppsession *)d)->p_serial_updown((netdev *)d,b,c);\
else \
e = ((pppsession *)d)->p_serial_updown(a,b,c)
#else
#define SERIAL_UPDOWN(a,b,c,d,e)\
e = ((pppsession *)d)->p_serial_updown(a,b,c)
#endif



typedef void (*ppp_action)(pppsession *psp, u8 layer, m *mp);
typedef ppp_action* (*ppp_get_actions)(void);

#ifdef PPP_AUTH_SERVER

/************************* Config.h modifiable. **************************
 *
 * The following manifest constants should be overridden, if need be,
 * in config.h, rather than modifying this file.
 *
 */
#ifndef PPP_AUTH_MAX_CLIENTS
#define PPP_AUTH_MAX_CLIENTS    4  
#endif

#ifndef PPP_AUTH_MAX_NAMELEN
#define PPP_AUTH_MAX_NAMELEN    32
#endif
#ifndef PPP_AUTH_MAX_PASSLEN
#define PPP_AUTH_MAX_PASSLEN    32
#endif

#ifndef PPP_CHAP_SERVER_NAME
#define PPP_CHAP_SERVER_NAME "Fusion PPP"
#endif

/************************* Config.h modifiable. **************************/

typedef struct {
  char  name[PPP_AUTH_MAX_NAMELEN];
  char  passwd[PPP_AUTH_MAX_PASSLEN];
  u8    ip[4];
  u8    ip_mask[4];        /* optional for ppp link */  
  pppsession *ps;       /* Tells us what interface he is using and
                           also serves as boolean to indicate if
                           this user is already logged in or not.
                        */
} ppp_user_t;

typedef struct {
  u8      ip_pool_base_address[4];
  short   number_if;
  ppp_user_t  ppp_user[PPP_AUTH_MAX_CLIENTS];
} ppp_config_t;

extern ppp_config_t ppp_server_data;

#endif

#define nd_pppu         nd_dsu.ppp_u
#define nd_psp  nd_pppu.ppp_sessp

#ifndef MAX_NEGOT
#define MAX_NEGOT       128
#endif
#ifndef LCP_MIN_MRU     /* May be modified via config.h */
#define LCP_MIN_MRU     256
#endif
#define LCP_DEF_MRU     1500
#ifndef LCP_MAX_MRU     /* May be modified via config.h */
#define LCP_MAX_MRU     LCP_DEF_MRU
#endif

/*
 *    : put the checksum bytes inside the *2 (for escaping)
 */
#define LCP_MAX_SIZE    (LCP_MAX_MRU+sizeof(ppph)+2)*2+2
#define IPCP_MAX_SIZE   LCP_MAX_SIZE

#define PPPINITFCS      0xffff
#define PPPGOODFCS      0xf0b8
#define PPPFCSSIZE      2

/* For PPPSE.C */
#define FNS_PPP_DIAL 		1
#define FNS_PPP_HANGUP		2
#define FNS_PPP_LOGIN		3

extern  void    boot_ppp (void *dptr);
extern  int     PppCfgLcpTimeout(void * psp);
extern  int     ppp_start_timeout(void * psp);
extern  int     ppp_persist_timeout(void * psp);
extern  int     PppCfgIpcpTimeout(void * psp);
extern  int     PppTerLcpTimeout(void * psp);
extern  int     PppTerIpcpTimeout(void * psp);

extern  int     ppp_sendexpect (netdev *ndp, int option, char *modem_str);
extern  int     ppp_local_start(m * mp, void * psp);
extern  void    auth_respond(pppsession * psp, m *mp, u8 code);
extern  void    ppp_onechar_input(unsigned char ch, netdev * ndp, pppsession * psp);
extern  int     ppp_bringup(netdev * ndp, pppsession * pppsessp);
extern  int     ppp_bringup_ipcp(pppsession * psp);
extern  int     ppp_bringup_lcp(pppsession * psp);
extern  int     ppp_bringup_pap(pppsession * psp);
extern  int     ppp_bringup_chap(pppsession * psp);
extern  int     ppp_recv(pppsession * psp, m * mp);
extern  int     ppp_stuff(pppsession * psp, m * mp, u16 fcs);
extern	st      ppp_up(m * mp);
extern  int     ppptryfcs(u8 * start, int len);
extern  void    lcp_respond(pppsession * psp, m *mp, u8 code);
extern  void    ipcp_respond(pppsession * psp, m *mp, u8 code);

extern  void    ppp_bringdown(pppsession * psp);
extern  void    ppp_bringup_end(pppsession * psp);
extern  void    ppp_cleartimers(pppsession * psp, short DelOrNot);
extern  void    ppp_rbuildmap(u8 * rasyncmap, u32 map);
extern  void    ppp_tbuildmap(u8 * tasyncmap, u32 map);
extern  void    ppp_reset_fsm (pppsession * psp);

extern  char	*pppsetoption (u8 type, u8 len, u8 * value, char * tp);
extern  char	*pppsetnetoption (u8 type, u8 len, u8 *value, char *tp);
extern  void    single_ppp_sm(pppsession *psp, u8 event, u8 layer, m *pkt);
extern  int		pppgetoption(u8 *ptr, u8 *end, u8 *result, u8 cpysize, u8 *len);
extern  int		pppgetnetoption(u8 *ptr, u8 *end, u8 *result, u8 , u8 *len);
extern  void    ipcp_parse_nakrej(pppsession * psp, m * mp, int nak);
extern  void    lcp_parse_nakrej(pppsession * psp, m * mp, int nak);
extern  void    ppp_lcp_tlu(pppsession *psp),
                ppp_ipcp_tlu(pppsession *psp);
extern  void    ppp_lcp_tld(pppsession *psp),
                ppp_ipcp_tld(pppsession *psp);
extern  void    ppp_lcp_tls(pppsession *psp),
                ppp_ipcp_tls(pppsession *psp);
extern  void    ppp_lcp_tlf(pppsession *psp),
                ppp_ipcp_tlf(pppsession *psp);
extern  int     ppp_lcp_scr(pppsession *psp, m *mp), 
                ppp_ipcp_scr(pppsession *psp, m *mp);
extern  int     ppp_lcp_scr(pppsession *psp, m *mp), 
                ppp_ipcp_scr(pppsession *psp, m *mp);
extern  int     ppp_lcp_sca(pppsession *psp, m *mp), 
                ppp_ipcp_sca(pppsession *psp, m *mp);
extern  int     ppp_lcp_scn(pppsession *psp, m *mp), 
                ppp_ipcp_scn(pppsession *psp, m *mp);
extern  int     ppp_lcp_str(pppsession *psp, m *mp), ppp_ipcp_str(pppsession *psp, m *mp);
extern  void    ppp_lcp_init(pppsession *psp);
extern  void    ppp_ipcp_init(pppsession *psp);
extern  void    ppp_ncp_is_up( pppsession *psp, u8 layer );
extern  void    ppp_ncp_is_finished( pppsession *psp, u8 layer );
extern  int     lcp_parse_cfg(pppsession * psp, m * mp_in, m ** mpp);
extern  int	    ipcp_parse_cfg(pppsession * psp, m * mp_in, m ** mpp);
extern  pppsession *psp_from_devname(char *devname);
extern  void    ppp_pap_recv(pppsession *psp, m *mp);
extern  void    ppp_chap_recv(pppsession *psp, m *mp);
extern  void    ppp_lcp_ser (pppsession * psp, m * mp);


extern  void    ppp_auth_server_init(void);
extern  int     pap_parse_auth(pppsession * psp, m * mp_in, m ** mpp);
extern  u32     assign_peer_ipaddr(pppsession *psp);
extern  int     ppp_auth_peer_lookup( char *username, char *o_buf_secret, int buflen );
extern  int     ppp_auth_login_peer(pppsession *psp, char *name);
extern  void 	ppp_auth_logout_peer(pppsession *psp);


extern  u16	    pppfcsset(u16 fcs, u8 * start, int len);

extern  void    single_ppp_sm(pppsession *psp, u8 event, u8 layer, m *pkt);
extern  void    ppp_fsm_input_event(pppsession *psp, u8 event, u8 layer, m *imp);

/* For Events destined to LCP and IPCP layers use this macro to input event */
#define PROCESS_PPP_EVENT(a,b,c,d)  ppp_fsm_input_event(a,b,c,d)

#ifdef PPP_TRACE
#define ppp_trace0(s)       os_printf(s)
#define ppp_trace1(s,x)     os_printf(s,x)
#define ppp_trace2(s,x,y)   os_printf(s,x,y)
#define ppp_trace3(s,x,y,z) os_printf(s,x,y,z)
#else
#ifndef ppp_trace0
#define ppp_trace0(s)
#endif
#ifndef ppp_trace1
#define ppp_trace1(s,x)
#endif
#ifndef ppp_trace2
#define ppp_trace2(s,x,y)
#endif
#ifndef ppp_trace3
#define ppp_trace3(s,x,y,z)
#endif
#endif

#ifdef PPP_DEBUG
#define ppp_debug0(s)       os_printf(s)
#define ppp_debug1(s,x)     os_printf(s,x)
#define ppp_debug2(s,x,y)   os_printf(s,x,y)
#define ppp_debug3(s,x,y,z) os_printf(s,x,y,z)
#else
#ifndef ppp_debug0
#define ppp_debug0(s)
#endif
#ifndef ppp_debug1
#define ppp_debug1(s,x)
#endif
#ifndef ppp_debug2
#define ppp_debug2(s,x,y)
#endif
#ifndef ppp_debug3
#define ppp_debug3(s,x,y,z)
#endif
#endif

#endif /* _PPP_ */