ipv6_interface.h

Go to the documentation of this file.

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef IPV6_INTERFACE_H
#define IPV6_INTERFACE_H
 
#include <basictypes.h>
#include <buffers.h>
#include <ipv6/dhcpv6_internal.h>
#include <ipv6/ipv6_addr.h>
#include <ipv6/ipv6_frames.h>
#include <nettimer.h>
#include <nettypes.h>
#include <utils.h>
 
#define ADDR_ALL_NODES_LINK_LOCAL IPADDR6::AsciiToIp6("FF02::1")          
#define ADDR_ALL_ROUTERS_LINK_LOCAL IPADDR6::AsciiToIp6("FF02::2")        
#define ADDR_ALL_NB_LINK_LOCAL IPADDR6::AsciiToIp6("FF02::4e42")          
#define ADDR_UNICAST_LINK_LOCAL_PREFIX IPADDR6::AsciiToIp6("FE80::")      
#define ADDR_MLDV2_REPORTS IPADDR6::AsciiToIp6("FF02::16")                
 
#define IPV6_MULTICAST_NODE_LOCAL 0xFF01    
#define IPV6_MULTICAST_LINK_LOCAL 0xFF02    
#define IPV6_MULTICAST_REALM_LOCAL 0xFF03   
#define IPV6_MULTICAST_ADMIN_LOCAL 0xFF04   
#define IPV6_MULTICAST_SITE_LOCAL 0xFF05    
#define IPV6_MULTICAST_ORG_LOCAL 0xFF08     
#define IPV6_MULTICAST_GLOBAL 0xFF0E        
struct IP6FRAME;
struct ICMP6_ND_ADVERT;
 
struct IPv6FrameProcessingStruct
{
    PoolPtr root_pp;          
    IP6FRAME *pIPf;          
    uint8_t *pData;          
    uint16_t nDataLen;       
    uint8_t *pLargeData;     
 
    void free_proc_struct();
 
    void release();
 
    uint8_t WalkNextHeader(int *pError_offset = NULL);
 
    bool DestOptHasError(puint8_t pData, int *pError_offset);
 
    bool HopByHopParseHasError(puint8_t pData, int *pError_offset);
 
    bool RouterHeaderParseHasError(puint8_t pData, int *pError_offset);
 
    IPv6FrameProcessingStruct(PoolPtr pp);
 
    IPv6FrameProcessingStruct()
    {
        root_pp = NULL;
        pIPf = NULL;
        pData = NULL;
        nDataLen = 0;
        pLargeData = 0;
    }
 
    inline puint8_t GetDataPointer()
    {
        if (pLargeData) return pLargeData;
        if (root_pp) return root_pp->pData;
        return NULL;
    }
 
    inline EFRAME *GetEframe()
    {
        if (pLargeData) return (EFRAME *)pLargeData;
        if (root_pp) return (EFRAME *)root_pp->pData;
        return NULL;
    }
};
// forward declarations
struct IPV6_ROOT_EL;
struct IPV6_PREFIX;
struct IPV6_ROUTER;
struct IPV6_DNS;
struct IPV6_NEIGHBOR;
struct IPV6_DEST;
struct IPV6_ROOT_EL_CONTAINER;
class IPv6Interface;
class UDPPacket;
class TcpCarrierPacket;
struct socket_struct;
typedef socket_struct SOCKET;
typedef SOCKET *PSOCKET;
 
enum IPV6_ROOT_EL_TYPE
{
    IPV6_ROOT_TYPE_EL = 0,              
    IPV6_ROOT_TYPE_EL_CONTAINER = 1,    
    IPV6_ROOT_TYPE_ROUTER = 2,          
    IPV6_ROOT_TYPE_DHCPD = 3,           
    IPV6_ROOT_TYPE_PREFIX = 4,          
    IPV6_ROOT_TYPE_DNS = 5,             
    IPV6_ROOT_TYPE_NEIGHBOR = 6,        
    IPV6_ROOT_TYPE_DEST = 7,            
};
 
struct IPV6_ROOT_EL
{
    IPV6_ROOT_EL *m_pNext;                  
    IPV6_ROOT_EL *m_pPrev;                  
    IPV6_ROOT_EL_CONTAINER *m_pContainer;   
    IPADDR6 m_IPAddress;                    
 
    virtual void ShowItem();
 
    virtual bool AgeStillValidTest();
 
    virtual void free_element();
 
    virtual ~IPV6_ROOT_EL();
};
 
struct IPV6_ROOT_EL_CONTAINER
{
    const char *m_name;             
    IPV6_ROOT_EL *m_pHead;         
    IPV6_ROOT_EL *m_pTail;         
    IPv6Interface *m_pInterface;    
    int m_nElements;               
 
    void Insert(IPV6_ROOT_EL *pEl);
 
    void InsertBack(IPV6_ROOT_EL *pEl);
 
    IPV6_ROOT_EL *Find(const IPADDR6 &ip, bool age);
 
    IPV6_ROOT_EL *First();
 
    IPV6_ROOT_EL_CONTAINER();
 
    void Attach(IPv6Interface &Interface, const char *name);
 
    void MoveToTop(IPV6_ROOT_EL *pEl);
 
    void Remove(IPV6_ROOT_EL *pEl);
 
    void Show();
};
 
struct IPV6_PREFIX;
 
struct IPV6_DHCPD : public IPV6_ROOT_EL
{
    uint8_t m_ServerID[CLIENT_LONG_SERVID];   
    uint32_t m_IAID;                          
    uint32_t m_renewTick;                     
    uint32_t m_rebindTick;                    
 
    void free_element();
 
    virtual bool AgeStillValidTest();
 
    virtual void ShowItem();
 
    IPV6_PREFIX *FindIA_Addr(IPV6_PREFIX *start);
 
    inline uint32_t GetDhcpRenewTime() { return m_renewTick; }
 
    inline uint32_t GetDhcpRebindTime() { return m_rebindTick; }
};
 
struct IPV6_IA_ADDR : public IPV6_ROOT_EL
{
    void free_element();
 
    virtual bool AgeStillValidTest();
 
    virtual void ShowItem();
};
struct IPV6_ROUTER : public IPV6_ROOT_EL
{
    uint16_t m_CheckSumCache;       
    uint32_t m_SecsLastAdvertise;   
    IPV6_NEIGHBOR *m_pNeighbor;     
    uint32_t m_Life_In_Secs;        
    uint16_t m_PathMTU;             
 
    IPV6_ROUTER *GetNextValid();
 
    IPV6_ROUTER *GetNext();
 
    void CleanUpAndRemove();
 
    void RemoveFromDefault();
 
    void free_element();
 
    virtual bool AgeStillValidTest();
 
    virtual void ShowItem();
};
 
enum eMY_ADDR_STATE
{
    eTenative,           
    eValid_Preferred,    
    eValid_Depricated,   
    eInvalid            
};
 
enum ePrefixSource
{
    eLinkLocal,    
    eRouter,       
    eDHCP,         
    eStatic,       
    eUnknown       
};
 
struct IPV6_PREFIX : public IPV6_ROOT_EL
{
    eMY_ADDR_STATE m_state;                                    
    uint32_t time_to_lose_prefered_in_secs_from_establish;    
    uint32_t time_to_lose_valid_in_secs_from_establish;       
    uint32_t time_established_in_secs;                        
    uint32_t max_valid_time_seen;                             
    IPV6_ROUTER *pRouter;                                     
    IPV6_DHCPD *pDHCPD;                                       
    uint8_t PrefixLen;                                        
    bool bValidForInterface;                                   
    bool bOnLink;                                             
 
    IPV6_PREFIX *GetNext()
    {
        return (IPV6_PREFIX*)m_pNext;
    }
 
    IPV6_PREFIX();
 
    void CleanUpAndRemove();
 
    void free_element();
 
    bool OnLink(const IPADDR6 &ip);
 
    bool Prefered();
 
    eMY_ADDR_STATE GetState() { return m_state; };
 
    virtual void ShowItem();
 
    inline ePrefixSource Source()
    {
        if (pDHCPD) return eDHCP;
        if (pRouter) return eRouter;
        if (m_IPAddress.IsLinkLocal()) return eLinkLocal;
        if ((bValidForInterface) && (bOnLink)) return eStatic;
        return eUnknown;
    }
 
    inline uint32_t RemainingValidTime()
    {
        uint32_t lastt = time_established_in_secs;
        if (pRouter) lastt = pRouter->m_SecsLastAdvertise;
        if (time_to_lose_valid_in_secs_from_establish == 0xffffffff) return 0xffffffff;
        return time_to_lose_valid_in_secs_from_establish - (Secs - lastt);
    };
 
    inline uint32_t GetRemainingDhcpLeaseTime() { return time_to_lose_valid_in_secs_from_establish + time_established_in_secs - Secs; }
 
    inline uint32_t GetRemainingDhcpLeasePreferredTime()
    {
        return time_to_lose_prefered_in_secs_from_establish + time_established_in_secs - Secs;
    }
 
    virtual bool AgeStillValidTest();
 
    bool AgeStillPreferred();
 
    void CheckTenative();
};
 
enum eRouteOutResult
{
    eSent,       
    eDoingND,    
    eNoRoute     
};
 
inline bool ThisCheck(void * p) {return p!=0; }
 
 
 
struct IPV6_DEST : public IPV6_ROOT_EL
{
    IPV6_NEIGHBOR *m_pNeighbor;   
    uint16_t m_PathMTU;           
    uint32_t m_nSecsLastUsed;     
    int m_nLockCount;             
    bool m_bStaticRoute;          
 
    IPV6_DEST *GetNext()
    {
        if (ThisCheck(this))
            return (IPV6_DEST *)m_pNext;
        else
            return NULL;
    }
 
    void free_element();
 
    virtual bool AgeStillValidTest();
 
    virtual void ShowItem();
};
struct IPV6_DNS : public IPV6_ROOT_EL
{
    uint32_t m_nSecsToBeValid;   
    IPV6_ROUTER *pRouter;        
    IPV6_DHCPD *pDHCPD;         
 
    IPV6_DNS *GetNext()
    {
        return (IPV6_DNS *)m_pNext;
    }
 
    virtual bool AgeStillValidTest();
 
    virtual void ShowItem();
 
    void CleanUpAndRemove();
 
    void free_element();
};
enum eMY_NEIGHBOR_STATE
{
    eIncomplete,   
    eReachable,    
    eStale,        
    eDelay,        
    eProbe         
};
 
 
struct IPV6_NEIGHBOR : public IPV6_ROOT_EL
{
    MACADR m_Macaddr;                       
    eMY_NEIGHBOR_STATE m_NeighborState;     
    uint8_t m_SentNDCount;                  
    uint32_t m_TickTimeOfNextAction;        
    bool m_bActiveTimer;                    
 
    IPV6_ROUTER *m_pRouter;                 
    PoolPtr m_pOutBound1;                   
    PoolPtr m_pOutBound2;                   
 
    IPV6_NEIGHBOR();
 
    IPV6_NEIGHBOR *GetNext()
    {
        if (ThisCheck(this))
            return (IPV6_NEIGHBOR *)m_pNext;
        else
            return NULL;
    }
 
    void free_element();
 
    void Discard();
 
    bool ProcessAdvert(IPv6FrameProcessingStruct &p6proc, ICMP6_ND_ADVERT *pRsp);
 
    void ProcessTick();
 
    void Send_ND_Solicit(bool multicast);
 
    eRouteOutResult Send(IPv6FrameProcessingStruct &p6proc, uint16_t mtu);
 
    virtual bool AgeStillValidTest();
 
    bool StillValidToSend();
 
    void SetState(eMY_NEIGHBOR_STATE s);
 
    eMY_NEIGHBOR_STATE GetState() { return m_NeighborState; };
 
    void CoreSendPend(PoolPtr pp);
 
    bool SendPending();
 
    virtual void ShowItem();
};
class IPv6Interface : public TimeOutElement
{
    int m_ifnum;                              
    MACADR m_myMac;                          
    uint32_t m_LastFragCheckSec;             
    uint32_t m_LastRouterSolSec;             
    uint32_t m_RouterSolCount;               
    uint32_t m_LastMLDRepSec;                
    bool m_solicitSendLinkLayer;             
    NB::V6::DHCPv6::DHCPClient *m_pDhcpClient; 
 
    OS_CRIT NDCrit;                          
    IPV6_ROOT_EL_CONTAINER Prefixes;        
    IPV6_ROOT_EL_CONTAINER Destinations;    
    IPV6_ROOT_EL_CONTAINER Neighbors;       
    IPV6_ROOT_EL_CONTAINER Routers;         
    IPV6_ROOT_EL_CONTAINER DnsList;         
    IPV6_ROOT_EL_CONTAINER DHCPServers;     
 
    volatile PoolPtr m_pp_FragmentParts;    
    virtual void TimeElementEvent();        
    OS_FIFO m_PingFifo;                     
 
    // Private allocation methods
    IPV6_PREFIX *PrefixAlloc(const IPADDR6 &ip);
    IPV6_DEST *DestAlloc(const IPADDR6 &ip);
    IPV6_ROUTER *RouterAlloc(const IPADDR6 &ip);
    IPV6_NEIGHBOR *NeighborAlloc(const IPADDR6 &ip);
    IPV6_DNS *DnsAlloc(const IPADDR6 &ip, bool front = false);
    IPV6_DHCPD *DHCPDAlloc(const IPADDR6 &ip);
 
    // Private lookup methods
    inline IPV6_PREFIX *FindPrefix(const IPADDR6 &ip, bool age = false) { return (IPV6_PREFIX *)Prefixes.Find(ip, age); };
    inline IPV6_DEST *FindDest(const IPADDR6 &ip, bool age = false) { return (IPV6_DEST *)Destinations.Find(ip, age); };
    inline IPV6_ROUTER *FindRouter(const IPADDR6 &ip, bool age = false) { return (IPV6_ROUTER *)Routers.Find(ip, age); };
    inline IPV6_DHCPD *FindDHCPD(const IPADDR6 &ip, bool age = false) { return (IPV6_DHCPD *)DHCPServers.Find(ip, age); };
    inline IPV6_NEIGHBOR *FindNeighbor(const IPADDR6 &ip, bool age = false) { return (IPV6_NEIGHBOR *)Neighbors.Find(ip, age); };
    IPV6_NEIGHBOR *FindCreateNeighbor(const IPADDR6 &ip);
    inline IPV6_PREFIX *FindIA_Addr(IPV6_DHCPD *dhcpd, IPV6_PREFIX *prefix = NULL)
    {
        if (prefix == NULL) { prefix = FirstPrefix(); }
        return dhcpd->FindIA_Addr(prefix);
    }
 
    IPV6_DNS *FindDNS(const IPADDR6 &ip, bool age = false, IPV6_DHCPD *pDhcp = NULL);
    IPV6_DNS *FindDNSByDHCPD(IPV6_DHCPD *pDhcp, IPV6_DNS *pEl);
 
    // Interface parameters
    uint16_t CurHopLimit;                    
    uint32_t BaseReachableTime_Ticks;       
    uint32_t ReachableTime_Ticks;           
    uint32_t ND_RetranmistTimer_Ticks;      
 
    uint32_t CalcRandomReachable();         
 
    IPADDR6 RoundRobinRouterIP;             
    eRouteOutResult RouteOut(IPv6FrameProcessingStruct &p6proc, IPV6_DEST *dest = NULL);
 
    uint16_t m_MultiCastMtu;                
    uint16_t m_DefMTU;                      
    uint8_t m_DefHopCount;                  
    volatile bool bHadLink;                 
    volatile int m_bStill_Need_To_Process_DupDiscovery_Ticks; 
    volatile bool m_bNeighborTicks;         
 
    // Static interface list management
    static IPv6Interface *gifList;          
    IPv6Interface *m_pNext;                 
    static IPADDR6 NetBurnerMultiCast;      
 
   private:
    // Private methods for internal processing
    void StartND();
    void SumIcmp(IPv6FrameProcessingStruct &p6proc);
    void RootErrors(uint8_t typev, uint8_t code, uint32_t ptr, IPv6FrameProcessingStruct &p6proc);
    void SendParameterProblem(IPv6FrameProcessingStruct &p6proc, int prob, int offset);
    void SendTimeExceeded(PoolPtr pp);
    void SendUnreachable(IPv6FrameProcessingStruct &p6proc);
    void Tick();
    bool Process_UDP(IPv6FrameProcessingStruct &p6proc);
    bool Process_TCP(IPv6FrameProcessingStruct &p6proc);
    bool Process_Fragment(IPv6FrameProcessingStruct &p6proc);
    bool ProcessND_N_Solicit(IPv6FrameProcessingStruct &p6proc);
    bool ProcessND_N_Advertise(IPv6FrameProcessingStruct &p6proc);
    bool ProcessND_R_Advertise(IPv6FrameProcessingStruct &p6proc);
    bool ProcessRouterOptions(IPV6_ROUTER *pRouter, IPv6FrameProcessingStruct &p6proc, int &rem, uint8_t *&pD);
    bool ProcessND_Redirect(IPv6FrameProcessingStruct &p6proc);
    bool ProcessPingRequest(IPv6FrameProcessingStruct &p6proc);
    bool ProcessPingReply(IPv6FrameProcessingStruct &p6proc);
    bool ProcessIcmpUnreach(IPv6FrameProcessingStruct &p6proc);
    bool ProcessTooBig(IPv6FrameProcessingStruct &p6proc);
    bool ProcessTimeExceeded(IPv6FrameProcessingStruct &p6proc);
    bool ProcessParamProb(IPv6FrameProcessingStruct &p6proc);
    bool ProcessIcmpV6(IPv6FrameProcessingStruct &p6proc);
    bool ProcessV6(IPv6FrameProcessingStruct &p6proc);
    void AddDefAddress(const IPADDR6 &ip);
    void AddPrefix(const IPADDR6 &ip, int len, int expire);
    bool ValidateIcmpPacket(IPv6FrameProcessingStruct &p6proc);
    void SendRouterSolicit(bool sendLinkLayer);
    void SendDUP_Discover(const IPADDR6 &ip);
 
    IPADDR6 MyLinkLocalAddress()
    {
        if (m_pMyLinkLocal) return m_pMyLinkLocal->m_IPAddress;
        return IPADDR6::NullIP();
    };
 
    // Friend declarations for internal access
    friend struct IPV6_PREFIX;
    friend struct IPV6_DEST;
    friend struct IPV6_ROUTER;
    friend struct IPV6_NEIGHBOR;
    friend struct IPV6_DNS;
    friend struct IPV6_DHCPD;
    friend class UDPPacket;
    friend class NB::V6::DHCPv6::DHCPClient;
    friend void RetransmitV6Packet(PoolPtr pp, PSOCKET ps);
    friend void TcpSendwSum6(PSOCKET ps, const IPADDR &IPto, TcpCarrierPacket &pkt, BOOL keep, uint32_t data_sum);
    friend void TcpSendwSumFrom6(const IPADDR &IPto, const IPADDR &IPfrom, TcpCarrierPacket &pkt, BOOL keep, uint32_t data_sum);
    friend void InitIPv6(int ifnum);
    friend int Ping6(const IPADDR6 &to, uint16_t id, uint16_t seq, uint16_t maxwaitticks, int size);
    friend int Ping6ViaInterface(IPADDR6 &to, uint16_t id, uint16_t seq, uint16_t wait, int interface, int size);
 
    static void RootProcessV6(PoolPtr pp);
 
    void MLDTick();
    bool ProcessICMPExtension(IPv6FrameProcessingStruct &p6proc);
    void JoinMulticastGroup(const IPADDR6 &addr);
    void LeaveMulticastGroup(const IPADDR6 &addr);
    void ReadyMLDBase(IPv6FrameProcessingStruct &p6proc, const IPADDR6 &recAddr);
    void LinkLocalIsNowValid();
    void ClearDHCPDInfo(IPV6_DHCPD *pDhcpd = NULL);
 
   public:
    // Element access methods
    inline IPV6_PREFIX *FirstPrefix() { return (IPV6_PREFIX *)Prefixes.First(); };
    inline IPV6_DEST *FirstDest() { return (IPV6_DEST *)Destinations.First(); };
    inline IPV6_ROUTER *FirstRouter() { return (IPV6_ROUTER *)Routers.First(); };
    IPV6_ROUTER *FirstDefRouter();
    IPV6_DHCPD *FirstDHCPD() { return (IPV6_DHCPD *)DHCPServers.First(); };
    inline IPV6_NEIGHBOR *FirstNeighbor() { return (IPV6_NEIGHBOR *)Neighbors.First(); };
    inline IPV6_DNS *FirstDNS() { return (IPV6_DNS *)DnsList.First(); };
 
    IPV6_PREFIX *m_pMyLinkLocal;             
    IPADDR6 m_StaticDNS;                     
 
    uint16_t GetDestinationMTU(const IPADDR &ip);
 
    static IPv6Interface *GetInterfaceForDestination(const IPADDR6 &ip);
 
    static IPv6Interface *GetInterfaceForSource(const IPADDR6 &ip);
 
    static IPv6Interface *GetInterfaceN(int n);
 
    static IPv6Interface *GetFirst_IP6_Interface();
 
    IPv6Interface *GetNext_IP6_Interface();
 
    IPADDR6 MySourceAddress(const IPADDR6 &ip);
 
    int GetInterfaceNumber() { return m_ifnum; };
 
    IPADDR6 MyDNSAddress();
 
    inline bool HadLink() { return bHadLink; }
 
    IPV6_PREFIX *AddStaticAddress(const IPADDR6 &ip, int PrefixLen);
 
    IPV6_ROUTER *AddDefaultGateway(const IPADDR6 &ip);
 
    IPV6_DNS *AddStaticDNS(const IPADDR6 &ip);
 
    bool RemoveStaticAddress(const IPADDR6 &ip);
 
    bool RemoveDefaultGateway(const IPADDR6 &ip);
 
    bool RemoveStaticDNS(const IPADDR6 &ip);
 
    void SetStaticDNS(IPADDR6 dns) { m_StaticDNS = dns; };
 
    inline void StartDHCP_Solicit() { NB::V6::DHCPv6::DHCPClient::ProcessDHCPAvail(this, (uint8_t)RA_FLAG_MANAGED_IP); }
 
    inline void StartDHCP_InfoReq() { NB::V6::DHCPv6::DHCPClient::ProcessDHCPAvail(this, (uint8_t)RA_FLAG_OTHER_AVAIL); }
 
    bool IsMyAddress(const IPADDR6 &ip6, bool bMustBePrefered);
 
    bool OnLink(const IPADDR6 &ip6);
 
    bool HasRoute(const IPADDR6 &ip6);
 
    void NotifyReachable(const IPADDR6 &ip6);
 
    void NotifyUnreachable(const IPADDR6 &ip);
 
    IPADDR6 GetMyFirstAddress()
    {
        IPV6_PREFIX *pPrefix = FirstPrefix();
        if (pPrefix) return pPrefix->m_IPAddress;
        return IPADDR6::NullIP();
    };
 
    IPADDR6 GetMyNextAddress(const IPADDR6 &ip)
    {
        IPV6_PREFIX *pPrefix = FindPrefix(ip);
        if (pPrefix)
        {
            pPrefix = pPrefix->GetNext();
            if (pPrefix) return pPrefix->m_IPAddress;
        }
        return IPADDR6::NullIP();
    };
 
    IPv6Interface(int ifnum);
 
    int ping(const IPADDR6 &ip, uint16_t id, uint16_t seq, uint16_t wait, int siz);
 
    int SendMLDRegistration(const IPADDR &regAddr, bool joinNotLeave = true);
 
    void ShowInfo();
 
    static void ShowAllInfo();
};
 
void ShowIP6Counters();
 
#endif