ppp.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _NB_PPP_H
#define _NB_PPP_H
 
#include <nettypes.h>
#include <buffers.h>
#include <netinterface.h>
#include <vjhc.h>
 
class PPPInterface;   // forward declaration
 
class ahdlc
{
   private:
    /* User controlled variables. */
    uint8_t tx_accm[32], rx_accm[32];
 
    /* Internal state data. */
    unsigned char *rx_bufp;
    PoolPtr rx_pool;
    beuint16_t rx_crc;
    char escaped;
    OS_SEM TransmitSemaphore;
 
    void initialize_rxbuffer();
    PPPInterface *m_pIf;
 
   public:
    ahdlc(PPPInterface *pIf);
    ~ahdlc();
    void clear();
    void receive(char *buffer, int count);
    void sendone(int fd, char c);
    void transmit(int fd, char *buffer, int n);
    void set_tx_accm(uint32_t tx_accm);
    void set_rx_accm(uint32_t rx_accm);
};
 
typedef enum
{
    eClosed,              
    eInitializingModem,   
    eDialing,             
    eWait4Ring,           
    eAnswering,           
    eWaitForTrain,        
    eLCPNegotiate,        
    ePAPAuthenticate,     
    eCHAPAuthenticate,    
    eNCPNegotiate,        
    eOpen,                
    eClosing              
} enum_PPPState;
#define ERR_PPP_SUCCESS (0)         
#define ERR_PPP_ALREADY_OPEN (-1)   
#define ERR_PPP_NO_DIALTONE (-2)    
#define ERR_PPP_NO_ANSWER (-3)      
#define ERR_PPP_BUSY (-4)           
#define ERR_PPP_FAIL (-5)           
#define ERR_PPP_PASSFAIL (-6)       
#define ERR_PPP_LOSTCARRIER (-7)    
#define ERR_PPP_NO_MODEM (-8)       
#define ERR_PPP_LCP_FAILED (-9)     
#define ERR_PPP_CHAPFAIL (-10)      
/* Definition for a PPP Frame */
typedef struct
{
    uint8_t unused[10];
    beuint16_t PPPAddr;
    beuint16_t PPPFrameType;
    uint8_t code;
    uint8_t idval;
    beuint16_t length;
    beuint16_t pData[4];
} __attribute__((packed)) PPPFRAME;
 
class LCPState_Class
{
   protected:
    int m_nState;
    uint16_t m_nOptions;
    uint32_t options_ok_mask;
    uint32_t options_nak_mask;
    uint32_t options_rej_mask;
    uint16_t m_TicksLeft;
    uint16_t m_toCount;
    uint16_t m_FrameType;
    uint16_t m_nRequests_Sent;
    LCPState_Class *pNextLayerUp;
    LCPState_Class *pNextLayerDn;
    uint8_t m_Last_ReqSent;
    uint8_t m_Last_ReqRespond;
    PPPInterface *m_ifc;
 
   public:
    void RecieveMsg(PPPFRAME *pPPP, PoolPtr pp);
    virtual void TestOption(puint8_t option_start, uint32_t maskv) = 0;
 
    void Up();
    void Down();
    void Open();
    void Close();
    void Tick();
    void Initialize(PPPInterface *ppi, uint16_t frame_type, LCPState_Class *next_layer, LCPState_Class *pre_layer);
    int GetState();
    void SendPPPBuffer(PoolPtr ppSend);
    void SendProtoReject(PPPFRAME *pPPP, PoolPtr pp);
 
   protected:
    void SetState(int i);
    void do_irc();
    void do_zrc();
    virtual void do_scr() = 0;
    virtual void do_RCN(PPPFRAME *pPPP, int reject) = 0;
    virtual void do_wereup();
    virtual void do_weredown();
    void do_sca(PPPFRAME *pPPP, PoolPtr pp);
    void do_scn(PPPFRAME *pPPP, PoolPtr pp);
    void CopyOptions(PPPFRAME *pPPPOut, PPPFRAME *pPPPin, uint32_t option_mask);
    void do_str();
    void do_sta(PPPFRAME *pPPP, PoolPtr pp);
    void do_ser(PPPFRAME *pPPP, PoolPtr pp);
    void do_abortconn();
};
 
class LCP_Class : public LCPState_Class
{
   public:
    virtual void TestOption(puint8_t option_start, uint32_t maskv);
    virtual void do_scr();
    virtual void do_RCN(PPPFRAME *pPPP, int reject);
    virtual void do_wereup();
    virtual void do_weredown();
};
 
class IPCP_Class : public LCPState_Class
{
   public:
    virtual void TestOption(puint8_t option_start, uint32_t maskv);
    virtual void do_scr();
    virtual void do_RCN(PPPFRAME *pPPP, int reject);
    virtual void do_wereup();
    virtual void do_weredown();
};
 
class PPPInterface : public InterfaceBlock
{
   protected:
    PPPInterface(const char *name = "PPP", const char *pDesc = "PPP Interface");
    PPPInterface *pNext;
 
   public:
    config_int Restart_Interval{
        3, "Restart_Interval",
        "Seconds to wait to restart failed negotiation"};   
    config_int Max_Terminate{2, "Max_Terminate",
                             "Max times to send terminate request before giving up"};   
    config_int Max_Configure{
        25, "Max_Configure",
        "Max number of config request loops before giving up"};   
    config_int Max_Failure{25, "Max_Failure",
                           "The max number of config failure before giving up"};   
    config_bool DNSRequest{true, "DNSRequest", "Request DNS from the other side of the connection"};
    config_bool CHAPenable{true, "CHAPEnable", "Enable CHAP authentication"};
    config_bool RestartOnClose{false, "RestartOnclose", "Restart PPP automatically from close"};
    config_pass UserName{"nburn", "User", "PPP Username for this interface"};
    config_pass PassWord{"nburn", "Password", "PPP Password for this interface"};
    uint32_t TX_DESIRED_ACCM;   
    uint32_t RX_DESIRED_ACCM;   
    config_IPADDR4 OfferedDNSAddress{"0.0.0.0", "OfferedDNS", "Offer a DNS address to the other side"};
    ConfigEndMarker;
 
    uint32_t dwflags;
    uint16_t MRU;
    uint32_t TX_ACCM;
    uint32_t RX_ACCM;
 
    volatile bool if_up;
    volatile int abort_ppp;
    volatile enum_PPPState cur_State;
    volatile bool abortornot;
    volatile bool m_bDataSeen;
    volatile uint32_t NextTick;
 
    int fdserial;
 
    OS_SEM state_semaphore;
 
    int ppp_nError;
 
    volatile uint16_t PPPIds;
 
    const char *hang_string;
    int hang_state;
 
    bool bTO;   // Did we time out
    int pap_to;
    int chap_to;
    BOOL client;   // Are we a client?
 
    uint8_t ChallengeID;
    uint32_t CurrentRand[4];
 
    bool DoVJCompress;
    slcompress VJHCStruct;
    ahdlc ahdlc_obj{this};
    LCP_Class lcp_automaton;
    IPCP_Class ipcp_automaton;
    bool pap_complete;
    bool chap_complete;
 
    virtual void send_func(PoolPtr poolPtr);
    virtual bool LinkActive();
    virtual int LinkSpeed();
    virtual bool LinkDuplex();
    virtual bool bNeedsArp();
 
    volatile enum_PPPState GetPPPState();
 
    void EnableMulticast(MACADR macAddress, BOOL addAddress);
    void processppp();
    void ClosePPPSesion();
    void SendPAP();
    void PAPTick();
    void ProcessPAP(PPPFRAME *pPPP, PoolPtr pp);
    void ProcessPPPIP(PPPFRAME *pPPP, PoolPtr pp);
    void SendCHAP(uint8_t code, uint8_t id = 0);   // Sends a CHAP packet to the PPP connected device
    void SendCHAPChallenge();
    void CHAPTick();
    void ProcessCHAP(PPPFRAME *pPPP, PoolPtr pp);
    void process_rx(PoolPtr pp);
    void UpdateTimeout();
 
    int StartIf(int fd);
    void Restart();
 
    static void PPPDaemonTask(void *p);
    static PPPInterface *pListHead;
};
 
class PPPServer : public PPPInterface
{
   public:
    PPPServer(const char *name = "PPPS", const char *pDesc = "PPP Server Interface");
};
 
class PPPClient : public PPPInterface
{
   public:
    PPPClient(const char *name = "PPPC", const char *pDesc = "PPP Server Interface");
};
 
#endif