dhcpd.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef __DHCPD_H
#define __DHCPD_H
 
#include <predef.h>
#include <constants.h>
#include <buffers.h>
#include <nettypes.h>
 
#define DHCP_SERV_MAX_INTF (4)                     
#define DHCP_OFFER_DURATION (2 * TICKS_PER_SECOND) 
#define DHCP_SERV_MAX_HOSTNAME_LEN (32)            
 
#define LEASE_POOL_SIZE 150                        
#define DHCPD_STARTING_ADDRESS 0xC0A80184          
 
namespace DHCP
{
 
typedef enum LeaseState
{
    LEASE_OPEN = 0x0, 
    LEASE_OFFERED = 0x1, 
    LEASE_TAKEN = 0x2, 
    LEASE_STATIC = 0x3, 
    ARP_CONFLICT = 0x4, 
} LeaseState_t;
 
struct DhcpLeaseRequest
{
    IPADDR4 ip;                                      
    MACADR mac;                                      
    uint32_t duration;                               
    uint32_t xid;                                    
    char hostname[DHCP_SERV_MAX_HOSTNAME_LEN + 1];   
};
 
struct DhcpLeaseData
{
    IPADDR4 ip;                                      
    MACADR mac;                                      
    uint32_t expiration;                             
    char hostname[DHCP_SERV_MAX_HOSTNAME_LEN + 1];   
};
 
struct DhcpInfo
{
    IPADDR4 netmask;           
    IPADDR4 gateway;           
    IPADDR4 dns_1;             
    IPADDR4 dns_2;             
    IPADDR4 logServ;           
    IPADDR4 smtpServ;          
    IPADDR4 ntpServ;           
    const char *domain_name;   
    char *hostname;            
    char *tftp_name;           
    char *bootfile;            
    uint16_t bonusLength;      
    uint8_t *bonusOpts;        
};
 
class LeaseAllocator
{
    LeaseAllocator *m_pNext;
 
   public:
    LeaseAllocator();
    ~LeaseAllocator();
 
    inline LeaseAllocator *SetNextAllocator(LeaseAllocator *nextAlloc)
    {
        m_pNext = nextAlloc;
        return m_pNext;
    }
    inline LeaseAllocator *GetNextAllocator() { return m_pNext; }
 
    virtual uint32_t GetLeaseTime() = 0;
    virtual bool OfferLease(DhcpLeaseRequest *pLease, int intfNum) = 0;
    virtual bool RequestLease(DhcpLeaseRequest *pLease, int intfNum) = 0;
    virtual bool ReleaseLease(DhcpLeaseRequest *pLease, int intfNum) = 0;
    virtual bool LeaseValid(DhcpLeaseRequest *pLease, int intfNum) = 0;
    virtual bool GetDhcpInfo(DhcpInfo &infoBlock, MACADR &client_mac, int intfNum) = 0;
    virtual bool AddInterface(int intfNum) = 0;
    virtual void RemoveInterface(int intfNum) = 0;
    virtual bool GetLeaseData(DhcpLeaseData *data) = 0;
};
 
class SingleAllocator : public LeaseAllocator
{
    IPADDR4 m_theIP;
    int m_intfNum;
 
   protected:
    uint32_t m_leaseDuration;   //< @brief Lease duration to hand out, in seconds
    DhcpInfo m_configInfo;
 
   public:
    SingleAllocator(IPADDR4 ip) : LeaseAllocator(), m_theIP(ip), m_intfNum(-1), m_leaseDuration(3600) {}
    ~SingleAllocator();
 
    inline void ChangeAllocAddr(IPADDR4 ip) { m_theIP = ip; }
 
    inline virtual bool OfferLease(DhcpLeaseRequest *pLease, int intfNum)
    {
        if (!m_intfNum)
            return false;
        if ((m_intfNum > 0) && (m_intfNum != intfNum))
            return false;
        pLease->ip = m_theIP;
        pLease->duration = m_leaseDuration;
        return true;
    }
    inline virtual bool RequestLease(DhcpLeaseRequest *pLease, int intfNum)
    {
        if (!m_intfNum)
            return false;
        if ((m_intfNum > 0) && (m_intfNum != intfNum))
            return false;
        if (pLease->ip != m_theIP)
        {
            pLease->ip = 0x00000000;
            return false;
        }
        pLease->ip = m_theIP;
        pLease->duration = m_leaseDuration;
        return true;
    }
    inline virtual bool ReleaseLease(DhcpLeaseRequest *pLease, int intfNum)
    {
        if (!m_intfNum)
            return false;
        if ((m_intfNum > 0) && (m_intfNum != intfNum))
            return false;
        return pLease->ip == m_theIP;
    }
    inline virtual bool LeaseValid(DhcpLeaseRequest *pLease, int intfNum)
    {
        if (!m_intfNum)
            return false;
        if ((m_intfNum > 0) && (m_intfNum != intfNum))
            return false;
        pLease->duration = m_leaseDuration;
        return pLease->ip == m_theIP;
    }
    virtual bool SetStaticLease(DhcpLeaseRequest *pLease) { return false; }
    virtual uint32_t GetLeaseTime() { return m_leaseDuration; }
 
    void SetLeaseTime(uint32_t hours, uint32_t minutes = 0, uint32_t seconds = 0);
    virtual bool GetDhcpInfo(DhcpInfo &infoBlock, MACADR &client_mac, int intfNum);
    virtual void UpdateDhcpInfo(const DhcpInfo *infoBlock) { return; }
    virtual bool AddInterface(int intfNum) { m_intfNum = intfNum; return true; }
    virtual void RemoveInterface(int intfNum) { if (m_intfNum == intfNum) m_intfNum = 0; return; }
    virtual bool IsRegisteredInterface(int intfNum) { return true; }
    virtual bool GetLeaseData(DhcpLeaseData *data) { return false; }
};
 
class BlockAllocator : public LeaseAllocator
{
    IPADDR4 m_startIP;
    const int m_leaseCount;
    DhcpLeaseData *const m_leaseBlock;
    bool m_staticLeaseExist;
    uint32_t m_lastIndex;
    int m_validIntf[DHCP_SERV_MAX_INTF];
 
    bool IsValidIntf(int intfNum);
    uint32_t m_leaseDuration;   
    DhcpInfo m_configInfo;
 
   public:
    BlockAllocator(const IPADDR4 startIP, const int leaseCount, DhcpLeaseData *const leaseBlock);
    ~BlockAllocator();
    void SetLeaseTime(uint32_t hours, uint32_t minutes = 0, uint32_t seconds = 0);
 
    virtual uint32_t GetLeaseTime() { return m_leaseDuration; }
    virtual bool OfferLease(DhcpLeaseRequest *pLease, int intfNum);
    virtual bool RequestLease(DhcpLeaseRequest *pLease, int intfNum);
    virtual bool ReleaseLease(DhcpLeaseRequest *pLease, int intfNum);
    virtual bool LeaseValid(DhcpLeaseRequest *pLease, int intfNum);
    virtual bool SetStaticLease(DhcpLeaseRequest *pLease);
    virtual bool GetDhcpInfo(DhcpInfo &infoBlock, MACADR &client_mac, int intfNum);
    virtual void UpdateDhcpInfo(const DhcpInfo *infoBlock);
    virtual bool AddInterface(int intfNum);
    virtual void RemoveInterface(int intfNum);
    inline virtual bool IsRegisteredInterface(int intfNum)
    {
        for (int i = 0; i < DHCP_SERV_MAX_INTF; i++)
        {
            if (m_validIntf[i] == intfNum) { return true; }
        }
        return false;
    }
    virtual bool GetLeaseData(DhcpLeaseData *data);
 
    void ResetLeases();
    inline void SetStartIP(const IPADDR4 newStartIP)
    {
        m_startIP = newStartIP;
        ResetLeases();
    }
};
 
class MacPrefixAllocator : public BlockAllocator
{
    const MACADR m_macMask;     // the bitmask to filter against
    const MACADR m_macPrefix;   // the MAC prefix to scan against
    const bool m_whitelist;     // are we operating in Whitelist mode?
 
   public:
    MacPrefixAllocator(const MACADR prefix,
                       const MACADR mask,
                       const bool whitelist,
                       const IPADDR4 startIP,
                       const int leaseCount,
                       DhcpLeaseData *const leaseBlock);
    ~MacPrefixAllocator();
    virtual bool OfferLease(DhcpLeaseRequest *pLease, int intfNum);
    virtual bool RequestLease(DhcpLeaseRequest *pLease, int intfNum);
    virtual bool SetStaticLease(DhcpLeaseRequest *pLease);
};
 
class Server
{
    static Server *theInstance;
    LeaseAllocator *m_pLeaseAlloc;
    uint32_t m_nextTick;
 
    void ProcessDiscover(PoolPtr pp);
    void ProcessRequest(PoolPtr pp);
    void ProcessDecline(PoolPtr pp);
    void ProcessRelease(PoolPtr pp);
    void ProcessInform(PoolPtr pp);
 
    void ProcessParamReq(uint8_t *&optBuf, uint8_t *ReqList, uint8_t reqLen, const DhcpInfo &info, IPADDR4 intfIP);
 
   public:
    Server();
    ~Server();
    bool AddLeaseAllocator(LeaseAllocator *newAllocator);
    bool ProcessServerMessage(PoolPtr pp);
 
    bool GetDhcpClients(DhcpLeaseData *data);
 
    bool AddInterface(int intfNum);
    void RemoveInterface(int intfNum);
 
    static inline bool AddServerInterface(int intfNum)
    {
        if (theInstance) { return theInstance->AddInterface(intfNum); }
        return false;
    }
    static inline void RemoveServerInterface(int intfNum)
    {
        if (theInstance) { theInstance->RemoveInterface(intfNum); }
    }
    static inline void ProcessMessage(PoolPtr pp)
    {
        if (theInstance) { theInstance->ProcessServerMessage(pp); }
    }
    static inline Server *GetInstance() { return theInstance; }
};
}   // namespace DHCP
 
bool AddStandardDHCPServer(int intf = 0, IPADDR4 startAddr = IPADDR4::NullIP());
 
#endif /* ----- #ifndef __DHCPD_H  ----- */