nettypes.h

Go to the documentation of this file.

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef NB_NET_TYPES_H
#define NB_NET_TYPES_H
 
#include <predef.h>
#include <basictypes.h>
 
typedef int(PutCharsFunction)(void *data, const char *chars, int len);
 
/*
 *******************************************************************************
 *
 * Definitions
 *
 *******************************************************************************
 */
 
#define PPP_TYPE (0x0021)  /* These are Big Endian constants! */
#define EIP_TYPE (0x0800)  /* These are Big Endian constants! */
#define EIP6_TYPE (0x86DD) /* These are Big Endian constants! */
#define HARD_ENET (0x0001) /* These are Big Endian constants! */
#define VLAN_TYPE (0x8100)
#define EARP_TYPE (0x0806)
#define ARP_REQUEST (0x01)
#define ARP_RESPONSE (0x02)
 
/*
 * Media Access Control (MAC) address size in 8 bit bytes and 16 bit words
 */
#define MACADDRESS_OCTETS_48 (6)
#define MACADDRESS_WORDS_48 (3)
typedef struct _MACADDRESS_48
{
    uint8_t octet[MACADDRESS_OCTETS_48];
} __attribute__((packed)) MACADDRESS_48;
 
class MACADR;   // Forward
 
typedef class MACADR
{
   public:
    beuint16_t phywadr[MACADDRESS_WORDS_48] = {0};
    inline bool IsNull() { return ((phywadr[2] == 0) && (phywadr[1] == 0) && (phywadr[0] == 0)); };
    inline bool IsMultiCast() { return (phywadr[0] & 0x0100); };
    inline bool IsBroadCast() { return ((phywadr[0] == 0xFFFF) && (phywadr[1] == 0xFFFF) && (phywadr[2] == 0xFFFF)); };
    uint8_t GetByte(int n) const
    {
        //#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
        //       if (n&1) { return ((phywadr[n/2]>>8)&0xFF); }
        //       else     { return (phywadr[n/2]&0xFF); }
        //#else
        if (n & 1) { return (phywadr[n / 2] & 0xFF); }
        else
        {
            return ((phywadr[n / 2] >> 8) & 0xFF);
        }
        //#endif
    };
    inline void SetFromBytes(const uint8_t *pb)
    {
        uint8_t *pto = (uint8_t *)phywadr;
        for (int i = 0; i < 6; i++)
        {
            pto[i] = pb[i];
        }
    };
    void fdprint(int fd);
    inline void print() { fdprint(1); };
    MACADR operator+(uint32_t rhs)
    {
        MACADR ret = *this;
        uint32_t tmp;
        tmp = ret.phywadr[2] + rhs;
        do {
            ret.phywadr[2] = tmp & 0xffff;
            tmp >>= 16;
            tmp = phywadr[1] + tmp;
            ret.phywadr[1] = tmp & 0xffff;
            tmp >>= 16;
            tmp = phywadr[0] + tmp;
            ret.phywadr[0] = tmp & 0xffff;
            tmp >>= 16;
        } while (tmp && ((tmp = ret.phywadr[2] + rhs)));
        return ret;
    }
    MACADR operator-(uint32_t rhs)
    {
        MACADR ret = *this;
        uint32_t tmp;
        tmp = ret.phywadr[2] - rhs;
        do {
            ret.phywadr[2] = tmp & 0xffff;
            tmp >>= 16;
            tmp = phywadr[1] - tmp;
            ret.phywadr[1] = tmp & 0xffff;
            tmp >>= 16;
            tmp = phywadr[0] - tmp;
            ret.phywadr[0] = tmp & 0xffff;
            tmp >>= 16;
        } while (tmp && ((tmp = ret.phywadr[2] - rhs)));
        return ret;
    }
} __attribute__((packed)) MACADR;
 
inline bool operator==(const MACADR &i, const MACADR &j)
{
    if (i.phywadr[0] != j.phywadr[0]) return FALSE;
    if (i.phywadr[1] != j.phywadr[1]) return FALSE;
    if (i.phywadr[2] != j.phywadr[2]) return FALSE;
    return TRUE;
}
 
inline bool operator!=(const MACADR &i, const MACADR &j)
{
    if (i.phywadr[0] != j.phywadr[0]) return TRUE;
    if (i.phywadr[1] != j.phywadr[1]) return TRUE;
    if (i.phywadr[2] != j.phywadr[2]) return TRUE;
    return FALSE;
}
 
inline bool operator>(const MACADR &i, const MACADR &j)
{
    if (i.phywadr[0] > j.phywadr[0])
        return true;
    else if (i.phywadr[0] < j.phywadr[0])
        return false;
 
    if (i.phywadr[1] > j.phywadr[1])
        return true;
    else if (i.phywadr[1] < j.phywadr[1])
        return false;
 
    if (i.phywadr[2] > j.phywadr[2]) return true;
 
    return false;
}
 
extern MACADR ENET_BCAST;
extern MACADR ENET_ZERO;
 
// Forward declaration
class CUR_IPADDR4;
 
class IPADDR4
{
   private:
    beuint32_t ip_val;
 
   public:
    IPADDR4() = default;
 
    IPADDR4(const IPADDR4 &v) = default;
 
    IPADDR4 &operator=(const IPADDR4 &v)
    {
        ip_val = v.ip_val;
        return *this;
    };
 
    volatile IPADDR4 &operator=(const IPADDR4 &v) volatile
    {
        ip_val = v.ip_val;
        return *this;
    };
 
    IPADDR4 &operator=(const uint32_t v)
    {
        ip_val = v;
        return *this;
    };
 
    volatile IPADDR4 &operator=(const uint32_t v) volatile
    {
        ip_val = v;
        return *this;
    };
 
    bool IsEmbeddedIPV4() const { return true; };
    IPADDR4 Extract4() const { return *this; };
    operator uint32_t() const { return (uint32_t)ip_val; };
 
    inline bool IsNull() const { return ip_val == 0; };
 
    inline bool NotNull() const { return !IsNull(); };
 
    inline void SetNull() { ip_val = 0; };
 
    inline bool IsLoopBack() const { return ((ip_val & 0xFF000000) == 0x7F000000); };
 
    inline bool IsMultiCast() const { return ((ip_val & 0xF0000000) == 0xE0000000); };   // 224. to 239. E0....EF.
 
    inline bool IsmDns() { return (ip_val==0xE00000FB); };
 
 
    inline bool IsGlobalBroadCast() const { return ip_val == 0xffffffff; };
 
    inline bool IsAutoIP() { return ((ip_val & 0xFFFF0000) == 0xA9FE0000); };
 
    //    IPADDR4() {ip_val=0; };
    IPADDR4(uint32_t v) { ip_val = v; };
    IPADDR4(uint8_t a, uint8_t b, uint8_t c, uint8_t d) { ip_val = (a << 24) | (b << 16) | (c << 8) | d; }
 
    // Return the MAC address for multicasts on at this address, NULL if not multicast
    inline MACADR McastMac() const
    {
        uint32_t ipDst = ip_val;
        ipDst &= 0x007FFFFF;
        MACADR ma;
        ma.phywadr[0] = 0x0100;
        ma.phywadr[1] = 0x5E00 | (uint16_t)((ipDst >> 16) & 0x7F);
        ma.phywadr[2] = (uint16_t)(ipDst & (0xFFFF));
        return ma;
    };
 
    inline static IPADDR4 NullIP()
    {
        IPADDR4 i4;
        i4.ip_val = 0;
        return i4;
    };
 
    inline static IPADDR4 GlobalBroadCast()
    {
        IPADDR4 i4;
        i4.ip_val = 0xFFFFFFFF;
        return i4;
    };
 
    void print() const;
 
    void fdprint(int fd) const;
 
    int sprintf(char *cp, int maxl) const;
 
    void SetFromAscii(const char *cp);
 
    int GetPrintLen(bool compact);
    int PrintHelper(PutCharsFunction *pf, void *data, bool compact);
 
    bool IsBcastNetMask(IPADDR4 intfIP, IPADDR4 mask) const
    {
        return ((ip_val & mask.ip_val) == (intfIP.ip_val & mask.ip_val)) && ((ip_val & ~mask.ip_val) == (~mask.ip_val));
    }
 
    // Helpers for === and != tests....
    friend bool operator==(const IPADDR4 i, const IPADDR4 j);
    friend bool operator!=(const IPADDR4 i, const IPADDR4 j);
    friend bool operator>(const IPADDR4 i, const IPADDR4 j);
    friend bool operator<(const IPADDR4 i, const IPADDR4 j);
 
    friend bool operator==(const uint32_t i, const IPADDR4 j);
    friend bool operator!=(const uint32_t i, const IPADDR4 j);
    friend bool operator>(const uint32_t i, const IPADDR4 j);
    friend bool operator<(const uint32_t i, const IPADDR4 j);
 
    friend bool operator==(const IPADDR4 i, const uint32_t j);
    friend bool operator!=(const IPADDR4 i, const uint32_t j);
    friend bool operator>(const IPADDR4 i, const uint32_t j);
    friend bool operator<(const IPADDR4 i, const uint32_t j);
 
    friend IPADDR4 IPV4FromConst(uint32_t d);
    friend IPADDR4 IPV4FromConst(beuint32_t d);
 
    friend IPADDR4 LocalBroadCast(IPADDR4 ifip, IPADDR4 ipmask);
 
    friend class CUR_IPADDR4;
 
    // friend BE32<uint32_t>::BE32(IPADDR4 rhs);
    // friend BE32<int32_t>::BE32(IPADDR4 rhs);
 
} __attribute__((packed));
 
// Helpers for === and != tests....
inline bool operator==(const IPADDR4 i, const IPADDR4 j)
{
    return i.ip_val == j.ip_val;
}
inline bool operator!=(const IPADDR4 i, const IPADDR4 j)
{
    return i.ip_val != j.ip_val;
}
inline bool operator>(const IPADDR4 i, const IPADDR4 j)
{
    return i.ip_val > j.ip_val;
}
inline bool operator<(const IPADDR4 i, const IPADDR4 j)
{
    return i.ip_val < j.ip_val;
}
 
inline bool operator==(const uint32_t i, const IPADDR4 j)
{
    return i == j.ip_val;
}
inline bool operator!=(const uint32_t i, const IPADDR4 j)
{
    return i != j.ip_val;
}
inline bool operator>(const uint32_t i, const IPADDR4 j)
{
    return i > j.ip_val;
}
inline bool operator<(const uint32_t i, const IPADDR4 j)
{
    return i < j.ip_val;
}
 
inline bool operator==(const IPADDR4 i, const uint32_t j)
{
    return i.ip_val == j;
}
inline bool operator!=(const IPADDR4 i, const uint32_t j)
{
    return i.ip_val != j;
}
inline bool operator>(const IPADDR4 i, const uint32_t j)
{
    return i.ip_val > j;
}
inline bool operator<(const IPADDR4 i, const uint32_t j)
{
    return i.ip_val < j;
}
 
inline IPADDR4 IPV4FromConst(uint32_t d)
{
    IPADDR4 i4;
    i4.ip_val = d;
    return i4;
};
 
inline IPADDR4 LocalBroadCast(IPADDR4 ifip, IPADDR4 ipmask)
{
    return IPV4FromConst(ifip.ip_val | ~(ipmask.ip_val));
};
 
/*
 
 
 *******************************************************************************
 *
 * Data Structures
 *
 *******************************************************************************
 */
 
/*
 * MAC address
 *    octet - address bytes
 */
 
/*
 * Definition for an Ethernet frame
 */
typedef struct
{
    MACADR dest_addr;
    MACADR src_addr;
    beuint16_t eType;
    uint8_t pData[];
} EFRAME;
 
typedef EFRAME *PEFRAME;
 
typedef struct
{
    MACADR dest_addr;
    MACADR src_addr;
    beuint16_t eVlType;
    beuint16_t eTag;
    beuint16_t eType;
    uint8_t pData[];
} VLEFRAME;
 
typedef VLEFRAME *PVLEFRAME;
 
#ifdef IPV6
#ifdef IPV4ONLY
#error Must select IPV4ONLY or IPV6 but not both
#endif
#endif
 
 
 
#ifdef IPV6
#include <ipv6/ipv6_addr.h>
 
typedef IPADDR6 IPADDR;
 
#define GetNullIP() IPADDR::NullIP()
 
#else
 
#ifndef IPV4ONLY
#error Got to pick an IP version
#endif
typedef IPADDR4 IPADDR;
#define GetNullIP() IPADDR4::NullIP()
#endif
 
 
/* Any address */
#define INADDR_ANY4 IPADDR4::NullIP()
 
#ifdef IPV6
#define INADDR_ANY IPADDR::NullIP()
#else
#define INADDR_ANY INADDR_ANY4
#endif
 
#endif   // #ifndef NB_NET_TYPES_H