dhcpv6_internal.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef __DHCPV6_INTERNAL_H
#define __DHCPV6_INTERNAL_H
 
#include <constants.h>
#include <nettypes.h>
#include <udp.h>
//#include <ipv6/ipv6_interface.h>
#include <ipv6/dhcpv6_const.h>
#include <ipv6/dhcpv6_msg.h>
 
#define CLIENT_LONG_SERVID 18
 
//#define DHCPv6_DEBUG
 
#ifdef DHCPv6_DEBUG
#define DHCPv6_DBSHOW(msg) msg.ShowMsg()
#define DHCPv6_DBIPRINTF(...) \
 { \
 iprintf("\n[T:%d-%ld]%s:%s:%d::", OSTaskID(), TimeTick, __FILE__, __FUNCTION__, __LINE__); \
 iprintf(__VA_ARGS__); \
 }
#else
#define DHCPv6_DBSHOW(msg) ((void)0)
#define DHCPv6_DBIPRINTF(...) ((void)0)
#endif
 
class IPv6Interface;
struct IPV6_DHCPD;
 
namespace NB
{
namespace V6
{
namespace DHCPv6
{
class DHCPv6Message
{
 private:
 UDPPacket Msg;
 DHCP_Message *dhcp_msg;
 uint16_t msgLen;
 bool txNRx;
 
 uint32_t opts_present[4]; // 128-bit bitfield for option numbers
 
 public:
 static const IPADDR6 ALL_RELAY_AND_SERVERS;
 static const IPADDR6 ALL_SERVERS;
 
 DHCPv6Message();
 DHCPv6Message(DHCP_Message *msg, uint16_t len);
 DHCPv6Message(UDPPacket *msg);
 ~DHCPv6Message();
 
#ifdef DHCPv6_DEBUG
 void ShowMsg(); // Display DHCPv6 message for debug
#endif
 
 PoolPtr ReleaseBuffer();
 
 inline void ClrMsg()
 {
 Msg.ResetData();
 dhcp_msg = (DHCP_Message *)Msg.GetDataBuffer();
 txNRx = true;
 }
 inline void SetTypeAndXid(MessageType type, uint32_t xid)
 {
 ClrMsg();
 xid &= 0xFFFFFF; // 24 bit mask
 xid |= type << 24;
 beuint32_t tXid = xid; // needed for Little Endian hosts
 Msg.AddData((uint8_t *)&tXid, 4);
 msgLen += 4;
 }
 
 void AddOption(Option &opt, uint16_t overrideLen = 0);
 
 void AddClientID();
 void AddORO(Option_ID ids[], uint16_t len, int ifNum);
 void AddElapsedTime(uint16_t elapsedTime);
 void AddIA_NA(uint32_t IA_ID, uint32_t T1, uint32_t T2, uint16_t optLen = 0);
 void AddFQDN(const char *name);
 
 inline MessageType GetType() { return (MessageType)((dhcp_msg->typeAndXid) >> 24); }
 inline uint32_t GetXid() { return (dhcp_msg->typeAndXid) & 0xFFFFFF; }
 
 Option *GetOption(Option_ID optID, Option *lastOpt = NULL);
 inline IPADDR6 GetSourceAddress() { return Msg.GetSourceAddress(); }
 
 void SendMsg(const IPADDR6 &ServerIP = ALL_RELAY_AND_SERVERS, int via_interface = -1);
 
 static void SendSolicit(uint32_t ifNum, uint32_t xid, uint32_t timeElapsed);
 static void SendRequest(uint32_t ifNum, uint32_t xid, uint32_t timeElapsed, Opt::ClientServerID *serverID, Opt::IA_NA *ia_na);
 static void SendInfoReq(uint32_t ifNum, uint32_t xid);
};
 
class DHCPClient
{
 public:
 enum ClientState
 {
 STATE_SOLICIT_START = 0,
 STATE_SOLICIT_DLYED = 1,
 STATE_SOLICIT_MSG_REC = 2,
 STATE_REQUEST_SENDING = 3,
 STATE_CONFIRMED = 4,
 STATE_RENEWING = 5,
 STATE_REBINDING = 6,
 STATE_INFO_REQ_SENDING = 7,
 STATE_INFO_REP_REC = 8,
 STATE_STOPPED = 9
 };
 
 private:
 ClientState state;
 IPv6Interface *myInterface;
 uint32_t nextActionTick;
 uint32_t currentDelay;
 uint32_t retransmitCount;
 uint32_t startTick;
 uint32_t xid;
 uint8_t maxPrefSeen;
 bool hasDns;
 IPV6_DHCPD *activeDHCPD;
 uint8_t activeServerID[CLIENT_LONG_SERVID]; // Space to contain the ServerID of the leasing server
 
 PoolPtr actingMessage; // DHCP advert/reply to act on
 
 void ClearInfo();
 inline void SetState(ClientState newState)
 {
 DHCPv6_DBIPRINTF("Setting state: %s", GetStateString(newState));
 state = newState;
 }
 static char const *GetStateString(ClientState state);
 
 void SetCurrentDelay(uint32_t delayBase);
 void IncrementCurrentDelay(uint32_t maxDelay);
 uint32_t GetNewXid();
 
 void ProcessReply(DHCPv6Message &msg);
 void ProcessReply_Info(DHCPv6Message &msg);
 void ProcessReply_Solicit(DHCPv6Message &msg, bool needServerMatch);
 
 void ProcessReply_DNSOpt(IPV6_DHCPD *server, Opt::DNS_Servers *dnsOpt, uint32_t time);
 
 void ProcessAdvert(DHCPv6Message &msg);
 void ProcessReconfig(DHCPv6Message &msg);
 
 void SendSolicit();
 void SendRequest();
 void SendRenewRebind(bool renew);
 
 public:
 DHCPClient(IPv6Interface *intf);
 inline uint32_t GetNextActionTick() { return nextActionTick; }
 void Tick();
 void ProcessMsg(DHCPv6Message &msg);
 void StartInfoReq();
 void StartSolicit();
 inline ClientState GetState() { return state; }
 
 void ShowInfo();
 
 static void ProcessDHCPAvail(IPv6Interface *intf, uint8_t raFlags);
 static void ProcessDHCPMsg(UDPPacket *pkt);
};
 
// these are in the NB::V6::DHCPv6 namespace
extern Option_ID *(*pAddOROCB)(int ifNum);
extern void (*pRequestOptionCB)(int ifNum, DHCPv6Message &msg);
extern void (*pReplyCB)(int ifNum, DHCPv6Message &msg);
 
} // namespace DHCPv6
} // namespace V6
} // namespace NB
 
#endif /* ----- #ifndef __DHCPV6_INTERNAL_H ----- */