ppp.h

Go to the documentation of this file.

 
#ifndef _PPP_H
#define _PPP_H
 
//Forward declaration of structures
struct _PppPacket;
struct _PppContext;
#define PppPacket struct _PppPacket
#define PppContext struct _PppContext
 
//Dependencies
#include "core/net.h"
#include "ppp/pap.h"
#include "ppp/chap.h"
 
//PPP support
#ifndef PPP_SUPPORT
   #define PPP_SUPPORT DISABLED
#elif (PPP_SUPPORT != ENABLED && PPP_SUPPORT != DISABLED)
   #error PPP_SUPPORT parameter is not valid
#endif
 
//TX buffer size
#ifndef PPP_TX_BUFFER_SIZE
   #define PPP_TX_BUFFER_SIZE 4096
#elif (PPP_TX_BUFFER_SIZE < 3006)
   #error PPP_TX_BUFFER_SIZE parameter is not valid
#endif
 
//RX buffer size
#ifndef PPP_RX_BUFFER_SIZE
   #define PPP_RX_BUFFER_SIZE 8192
#elif (PPP_RX_BUFFER_SIZE < 3006)
   #error PPP_RX_BUFFER_SIZE parameter is not valid
#endif
 
//Maximum user name length
#ifndef PPP_MAX_USERNAME_LEN
   #define PPP_MAX_USERNAME_LEN 31
#elif (PPP_MAX_USERNAME_LEN < 7)
   #error PPP_MAX_USERNAME_LEN parameter is not valid
#endif
 
//Maximum password length
#ifndef PPP_MAX_PASSWORD_LEN
   #define PPP_MAX_PASSWORD_LEN 31
#elif (PPP_MAX_PASSWORD_LEN < 7)
   #error PPP_MAX_PASSWORD_LEN parameter is not valid
#endif
 
//PPP tick interval
#ifndef PPP_TICK_INTERVAL
   #define PPP_TICK_INTERVAL 500
#elif (PPP_TICK_INTERVAL < 10)
   #error PPP_TICK_INTERVAL parameter is not valid
#endif
 
//Polling interval for blocking functions
#ifndef PPP_POLLING_INTERVAL
   #define PPP_POLLING_INTERVAL 50
#elif (PPP_POLLING_INTERVAL < 1)
   #error PPP_POLLING_INTERVAL parameter is not valid
#endif
 
//Restart timer
#ifndef PPP_RESTART_TIMER
   #define PPP_RESTART_TIMER 3000
#elif (PPP_RESTART_TIMER < 1000)
   #error PPP_RESTART_TIMER parameter is not valid
#endif
 
//Maximum number of retransmissions for Configure-Requests
#ifndef PPP_MAX_CONFIGURE
   #define PPP_MAX_CONFIGURE 10
#elif (PPP_MAX_CONFIGURE < 1)
   #error PPP_MAX_CONFIGURE parameter is not valid
#endif
 
//Maximum number of retransmissions for Terminate-Requests
#ifndef PPP_MAX_TERMINATE
   #define PPP_MAX_TERMINATE 2
#elif (PPP_MAX_TERMINATE < 1)
   #error PPP_MAX_TERMINATE parameter is not valid
#endif
 
//Maximum number of Configure-Nak packets sent
#ifndef PPP_MAX_FAILURE
   #define PPP_MAX_FAILURE 5
#elif (PPP_MAX_FAILURE < 1)
   #error PPP_MAX_FAILURE parameter is not valid
#endif
 
//PPP special characters
#define PPP_MASK_CHAR 0x20
#define PPP_ESC_CHAR  0x7D
#define PPP_FLAG_CHAR 0x7E
 
//PPP default MRU
#define PPP_DEFAULT_MRU 1500
//PPP default async control character map
#define PPP_DEFAULT_ACCM 0xFFFFFFFF
//PPP default magic number
#define PPP_DEFAULT_MAGIC_NUMBER 0
 
//Minimum acceptable value for MRU
#define PPP_MIN_MRU 32
//Maximum acceptable value for MRU
#define PPP_MAX_MRU 1500
 
//Maximum size of Configure-Request packets
#define PPP_MAX_CONF_REQ_SIZE 128
 
//Maximum size of PPP frame header
#define PPP_FRAME_HEADER_SIZE 4
//FCS field size
#define PPP_FCS_SIZE 2
//Maximum size of PPP frames
#define PPP_MAX_FRAME_SIZE (PPP_FRAME_HEADER_SIZE + PPP_MAX_MRU + PPP_FCS_SIZE)
 
//PPP Address field
#define PPP_ADDR_FIELD 0xFF
#define PPP_CTRL_FIELD 0x03
 
//C++ guard
#ifdef __cplusplus
extern "C" {
#endif
 
 
typedef enum
{
   PPP_PHASE_DEAD         = 0, 
   PPP_PHASE_ESTABLISH    = 1, 
   PPP_PHASE_AUTHENTICATE = 2, 
   PPP_PHASE_NETWORK      = 3, 
   PPP_PHASE_TERMINATE    = 4  
} PppPhase;
 
 
typedef enum
{
   PPP_STATE_0_INITIAL  = 0,
   PPP_STATE_1_STARTING = 1,
   PPP_STATE_2_CLOSED   = 2,
   PPP_STATE_3_STOPPED  = 3,
   PPP_STATE_4_CLOSING  = 4,
   PPP_STATE_5_STOPPING = 5,
   PPP_STATE_6_REQ_SENT = 6,
   PPP_STATE_7_ACK_RCVD = 7,
   PPP_STATE_8_ACK_SENT = 8,
   PPP_STATE_9_OPENED   = 9
} PppState;
 
 
typedef enum
{
   PPP_PROTOCOL_IP     = 0x0021, 
   PPP_PROTOCOL_IPV6   = 0x0057, 
   PPP_PROTOCOL_IPCP   = 0x8021, 
   PPP_PROTOCOL_IPV6CP = 0x8057, 
   PPP_PROTOCOL_LCP    = 0xC021, 
   PPP_PROTOCOL_PAP    = 0xC023, 
   PPP_PROTOCOL_LQR    = 0xC025, 
   PPP_PROTOCOL_CHAP   = 0xC223  
} PppProtocol;
 
 
typedef enum
{
   PPP_CODE_CONFIGURE_REQ = 1,  
   PPP_CODE_CONFIGURE_ACK = 2,  
   PPP_CODE_CONFIGURE_NAK = 3,  
   PPP_CODE_CONFIGURE_REJ = 4,  
   PPP_CODE_TERMINATE_REQ = 5,  
   PPP_CODE_TERMINATE_ACK = 6,  
   PPP_CODE_CODE_REJ      = 7,  
   PPP_CODE_PROTOCOL_REJ  = 8,  
   PPP_CODE_ECHO_REQ      = 9,  
   PPP_CODE_ECHO_REP      = 10, 
   PPP_CODE_DISCARD_REQ   = 11  
} PppCode;
 
 
typedef enum
{
   PPP_AUTH_PROTOCOL_PAP       = 0x01, //PAP
   PPP_AUTH_PROTOCOL_CHAP_MD5  = 0x02, //CHAP with MD5
   PPP_AUTH_PROTOCOL_MS_CHAP   = 0x04, //MS-CHAP
   PPP_AUTH_PROTOCOL_MS_CHAP_2 = 0x08  //MS-CHAP-2
} PppAuthProtocol;
 
 
//CodeWarrior or Win32 compiler?
#if defined(__CWCC__) || defined(_WIN32)
   #pragma pack(push, 1)
#endif
 
 
__packed_struct _PppPacket
{
   uint8_t code;       //0
   uint8_t identifier; //1
   uint16_t length;    //2-3
   uint8_t data[];     //4
};
 
 
typedef __packed_struct
{
   uint8_t code;       //0
   uint8_t identifier; //1
   uint16_t length;    //2-3
   uint8_t options[];  //4
} PppConfigurePacket;
 
 
typedef __packed_struct
{
   uint8_t code;       //0
   uint8_t identifier; //1
   uint16_t length;    //2-3
   uint8_t data[];     //4
} PppTerminatePacket;
 
 
typedef __packed_struct
{
   uint8_t code;             //0
   uint8_t identifier;       //1
   uint16_t length;          //2-3
   uint8_t rejectedPacket[]; //4
} PppCodeRejPacket;
 
 
typedef __packed_struct
{
   uint8_t code;              //0
   uint8_t identifier;        //1
   uint16_t length;           //2-3
   uint16_t rejectedProtocol; //4-5
   uint8_t rejectedInfo[];    //6
} PppProtocolRejPacket;
 
 
typedef __packed_struct
{
   uint8_t code;         //0
   uint8_t identifier;   //1
   uint16_t length;      //2-3
   uint32_t magicNumber; //4-7
   uint8_t data[];       //8
} PppEchoPacket;
 
 
typedef __packed_struct
{
   uint8_t code;         //0
   uint8_t identifier;   //1
   uint16_t length;      //2-3
   uint32_t magicNumber; //4-7
   uint8_t data[];       //8
} PppDiscardReqPacket;
 
 
typedef __packed_struct
{
   uint8_t type;   //0
   uint8_t length; //1
   uint8_t data[]; //2
} PppOption;
 
 
//CodeWarrior or Win32 compiler?
#if defined(__CWCC__) || defined(_WIN32)
   #pragma pack(pop)
#endif
 
 
typedef error_t (*PppRandCallback)(uint8_t *data, size_t length);
 
 
typedef bool_t (*PppAuthCallback)(NetInterface *interface,
   const char_t *username);
 
 
typedef struct
{
   NetInterface *interface;      
   uint16_t mru;                 
   uint32_t accm;                
   uint_t authProtocol;          
   PppRandCallback randCallback; 
   PppAuthCallback authCallback; 
} PppSettings;
 
 
typedef struct
{
   uint_t state;          
   uint8_t identifier;    
   uint_t restartCounter; 
   uint_t failureCounter; 
   systime_t timestamp;   
} PppFsm;
 
 
typedef struct
{
   uint16_t mru;
   bool_t mruRejected;
   uint32_t accm;
   bool_t accmRejected;
   uint16_t authProtocol;
   uint8_t authAlgo;
   bool_t authProtocolRejected;
   uint32_t magicNumber;
   bool_t magicNumberRejected;
   bool_t pfc;
   bool_t pfcRejected;
   bool_t acfc;
   bool_t acfcRejected;
#if (IPV4_SUPPORT == ENABLED)
   Ipv4Addr ipAddr;
   bool_t ipAddrRejected;
   Ipv4Addr primaryDns;
   bool_t primaryDnsRejected;
   Ipv4Addr secondaryDns;
   bool_t secondaryDnsRejected;
#endif
#if (IPV6_SUPPORT == ENABLED)
   Eui64 interfaceId;
   bool_t interfaceIdRejected;
#endif
} PppConfig;
 
 
struct _PppContext
{
   PppSettings settings;    
   NetInterface *interface; 
   systime_t timeout;       
 
   char_t username[PPP_MAX_USERNAME_LEN + 1]; 
   char_t password[PPP_MAX_PASSWORD_LEN + 1]; 
   char_t peerName[PPP_MAX_USERNAME_LEN + 1]; 
 
   bool_t localAuthDone;
   bool_t peerAuthDone;
 
   PppPhase pppPhase;       
   PppFsm lcpFsm;           
#if (IPV4_SUPPORT == ENABLED)
   PppFsm ipcpFsm;          
#endif
#if (IPV6_SUPPORT == ENABLED)
   PppFsm ipv6cpFsm;        
#endif
#if (PAP_SUPPORT == ENABLED)
   PapFsm papFsm;           
#endif
#if (CHAP_SUPPORT == ENABLED)
   ChapFsm chapFsm;         
#endif
   PppConfig localConfig;   
   PppConfig peerConfig;    
   bool_t ipRejected;       
   bool_t ipv6Rejected;     
 
   uint8_t frame[PPP_MAX_FRAME_SIZE]; 
 
   uint8_t txBuffer[PPP_TX_BUFFER_SIZE]; 
   uint_t txBufferLen;
   uint_t txWriteIndex;
   uint_t txReadIndex;
 
   uint8_t rxBuffer[PPP_RX_BUFFER_SIZE]; 
   uint_t rxBufferLen;
   uint_t rxWriteIndex;
   uint_t rxReadIndex;
   uint_t rxFrameCount;
};
 
 
//Tick counter to handle periodic operations
extern systime_t pppTickCounter;
 
//PPP related functions
void pppGetDefaultSettings(PppSettings *settings);
error_t pppInit(PppContext *context, const PppSettings *settings);
 
error_t pppSetTimeout(NetInterface *interface, systime_t timeout);
 
error_t pppSetAuthInfo(NetInterface *interface, const char_t *username,
   const char_t *password);
 
bool_t pppCheckPassword(NetInterface *interface, const char_t *password);
 
error_t pppSendAtCommand(NetInterface *interface, const char_t *data);
error_t pppReceiveAtCommand(NetInterface *interface, char_t *data, size_t size);
 
error_t pppConnect(NetInterface *interface);
error_t pppClose(NetInterface *interface);
 
void pppTick(NetInterface *interface);
 
void pppProcessFrame(NetInterface *interface, uint8_t *frame, size_t length,
   NetRxAncillary *ancillary);
 
error_t pppSendFrame(NetInterface *interface, NetBuffer *buffer, size_t offset,
   uint16_t protocol);
 
size_t pppParseFrameHeader(const uint8_t *frame, size_t length, uint16_t *protocol);
 
uint16_t pppCalcFcs(const uint8_t *data, size_t length);
uint16_t pppCalcFcsEx(const NetBuffer *buffer, size_t offset, size_t length);
 
NetBuffer *pppAllocBuffer(size_t length, size_t *offset);
 
//C++ guard
#ifdef __cplusplus
}
#endif
 
#endif