oc_net.h

Go to the documentation of this file.

#ifndef SYSTEM_CORE_INC_NET_OC_NET_H_
#define SYSTEM_CORE_INC_NET_OC_NET_H_

#include <oc_memory.h>
#include <oc_stdio.h>
#include <oc_baudrate.h>
#include <oc_compiler.h>
#include <oc_string.h>
#include <oc_stdlib.h>
#include <oc_array.h>
#include <oc_debug.h>
#include <oc_memman.h>
#include <oc_math.h>

#define _________________________________________DEFINITIONS_SECTION________________________________________________________________________

// +----------------------------------------------------------------+
// |                            IEEE 802.3                          |
// +----------------------------------------------------------------+
#define IEEE_802_3_MAC_ADDRESS_LENGTH           6
#define IEEE_802_3_ETHERNET_MTU                 1500
#define IEEE_802_3_MINIMUM_PAYLOAD              42

// +----------------------------------------------------------------+
// |                            SELECTED STD                        |
// +----------------------------------------------------------------+
#define MAC_ADDRESS_LENGTH                      IEEE_802_3_MAC_ADDRESS_LENGTH
#define NETWORK_MTU                             IEEE_802_3_ETHERNET_MTU
#define MINIMUM_PAYLOAD                         IEEE_802_3_MINIMUM_PAYLOAD
#define IPv4_MAXIMUM_DATA_LENGTH                (NETWORK_MTU - sizeof(oC_Net_Ipv4PacketHeader_t))
#define IPv6_MAXIMUM_DATA_LENGTH                (NETWORK_MTU - sizeof(oC_Net_Ipv6PacketHeader_t))

// +----------------------------------------------------------------+
// |                      OTHER NET DEFINITIONS                     |
// +----------------------------------------------------------------+
#define IFNAMSIZ                                64
#define MAXIMUM_NETWORK_INTERFACES              0xFFFFFFFF
#define MAXIMUM_FRIENDLY_INTERFACE_NAME         100
#define DHCP_SERVER_NAME_LENGTH                 64
#define MAXIMUM_PACKET_SIZE                     UINT16_MAX

#undef  _________________________________________DEFINITIONS_SECTION________________________________________________________________________

#define _________________________________________FUNCTION_LIKE_MACROS_SECTION_______________________________________________________________

#define IP(A,B,C,D)             ( ( (D) << 0 ) | ( (C) << 8 ) | ( (B) << 16 ) | ( (A) << 24 ))

#undef  _________________________________________FUNCTION_LIKE_MACROS_SECTION_______________________________________________________________


#define _________________________________________TYPES_SECTION______________________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
typedef uint8_t oC_Net_MacAddress_t[MAC_ADDRESS_LENGTH];

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct
{
    union
    {
        uint8_t                 Address;        
        oC_Net_MacAddress_t     MacAddress;     
    };
    bool                    Filled;         
} oC_Net_HardwareAddress_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef uint32_t oC_Net_Ipv4_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct PACKED
{
    uint64_t    LowPart;        
    uint64_t    HighPart;       
} oC_Net_Ipv6_t ;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
    oC_Net_Protocol_ICMP    = 1 ,  
    oC_Net_Protocol_IGMP    = 2 ,  
    oC_Net_Protocol_TCP     = 6 ,  
    oC_Net_Protocol_UDP     = 17 , 
    oC_Net_Protocol_ENCAP   = 41 , 
    oC_Net_Protocol_OSPF    = 89 , 
    oC_Net_Protocol_SCTP    = 132 ,
} oC_Net_Protocol_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
    oC_Net_PacketType_Invalid   = 0,    
    oC_Net_PacketType_IPv4      = 4,    
    oC_Net_PacketType_IPv6      = 6,    
} oC_Net_PacketType_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
    oC_Net_FrameType_IPv4       = 0x0800 , 
    oC_Net_FrameType_IPv6       = 0x86DD , 
    oC_Net_FrameType_ARP        = 0x0806 , 
} oC_Net_FrameType_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
    oC_Net_HardwareType_Invalid  = 0 ,  
    oC_Net_HardwareType_Ethernet = 1 ,  
} oC_Net_HardwareType_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct PACKED
{
#ifdef LITTLE_ENDIAN
    uint32_t            Version:4;                  
    uint32_t            IHL:4;                      
    uint32_t            QoS:8;                      
    uint32_t            Length:16;                  
    uint32_t            ID:16;                      
    uint32_t            FragmentOffset:13;          
    uint32_t            MF:1;                       
    uint32_t            DF:1;                       
    uint32_t            Reserved:1;                 
    uint32_t            TTL:8;                      
    uint32_t            Protocol:8;                 
    uint32_t            Checksum:16;                
    oC_Net_Ipv4_t       SourceIp;                   
    oC_Net_Ipv4_t       DestinationIp;              
#elif defined(BIG_ENDIAN)
#   error The structure is not defined for BIG_ENDIAN
#else
#   error Endianess is not defined
#endif
} oC_Net_Ipv4PacketHeader_t ;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct PACKED
{
#ifdef LITTLE_ENDIAN
    uint32_t            Version:4;                  
    uint32_t            TrafficClass:8;             
    uint32_t            FlowLabel:20;               
    uint32_t            PayloadLength:16;           
    uint32_t            NextHeader:8;               
    uint32_t            HopLimit:8;                 
    oC_Net_Ipv6_t       Source;                     
    oC_Net_Ipv6_t       Destination;                
#elif defined(BIG_ENDIAN)
#   error The structure is not defined for BIG_ENDIAN
#else
#   error Endianess is not defined
#endif
} oC_Net_Ipv6PacketHeader_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct PACKED
{
    oC_Net_Ipv4PacketHeader_t   Header;                             
    uint8_t                     Data[IPv4_MAXIMUM_DATA_LENGTH];     
} oC_Net_Ipv4Packet_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct PACKED
{
    oC_Net_Ipv6PacketHeader_t   Header;                             
    uint8_t                     Data[IPv6_MAXIMUM_DATA_LENGTH];     
} oC_Net_Ipv6Packet_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef union
{
    oC_Net_Ipv4Packet_t         IPv4;   
    oC_Net_Ipv6Packet_t         IPv6;   
} oC_Net_Packet_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct
{
    oC_Net_HardwareAddress_t     Destination;           
    oC_Net_HardwareAddress_t     Source;                
    union
    {
        oC_Net_Packet_t*             Packet;                
        const oC_Net_Packet_t*       ConstPacket;           
    };
    uint16_t                     Size;                  
    oC_Net_FrameType_t           FrameType;             
} oC_Net_Frame_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
    oC_Net_Layer_Physical       = 1 << 4,                      
    oC_Net_Layer_DataLink       = 2 << 4,                      
    oC_Net_Layer_Network        = 3 << 4,                      
    oC_Net_Layer_Transport      = 4 << 4,                      
    oC_Net_Layer_Session        = 5 << 4,                      
    oC_Net_Layer_Presentation   = 6 << 4,                      
    oC_Net_Layer_Application    = 7 << 4,                      

    oC_Net_Layer_MainLayerMask  = 0xF << 4 ,                   
    oC_Net_Layer_SubLayerMask   = 0xF ,                        

    oC_Net_Layer_PHY            = oC_Net_Layer_Physical | 0x0 ,

    oC_Net_Layer_LLC            = oC_Net_Layer_DataLink | 0x0 ,
    oC_Net_Layer_MAC            = oC_Net_Layer_DataLink | 0x1 ,

    oC_Net_Layer_Netif          = oC_Net_Layer_Network  | 0x0 ,
} oC_Net_Layer_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
    oC_Net_LinkStatus_Down ,
    oC_Net_LinkStatus_Up    
} oC_Net_LinkStatus_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef uint32_t oC_Net_InterfaceIndex_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef char oC_Net_InterfaceName_t[IFNAMSIZ];

//==========================================================================================================================================
//==========================================================================================================================================
typedef char oC_Net_FriendlyInterfaceName_t[MAXIMUM_FRIENDLY_INTERFACE_NAME];

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct
{
    uint32_t        NumberOfElementsInTxQueue;  
    uint32_t        NumberOfElementsInRxQueue;  
} oC_Net_QueueStatus_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef uint16_t oC_Net_Port_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef enum
{
    oC_Net_AddressType_IPv4 = oC_Net_PacketType_IPv4 ,   
    oC_Net_AddressType_IPv6 = oC_Net_PacketType_IPv6 ,   
} oC_Net_AddressType_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct
{
    oC_Net_AddressType_t    Type;       
    union
    {
        oC_Net_Ipv4_t   IPv4;           
        oC_Net_Ipv6_t   IPv6;           
    };
    oC_Net_Protocol_t   Protocol;           
    oC_Net_Port_t       Port;               
} oC_Net_Address_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef uint32_t oC_Net_Cost_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct
{
    oC_Net_Ipv4_t              IP;                                          
    oC_Net_Ipv4_t              NetIP;                                       
    oC_Net_Ipv4_t              Netmask;                                     
    oC_Net_Ipv4_t              DhcpIP;                                      
    char                       DhcpServerName[DHCP_SERVER_NAME_LENGTH];     
    oC_Net_Ipv4_t              GatewayIP;                                   
    oC_Net_Ipv4_t              DnsIP;                                       
    oC_MemorySize_t            MTU;                                         
    oC_Net_Ipv4_t              BroadcastIP;                                 
    uint8_t                    DefaultTTL;                                  
    oC_Net_Ipv4_t              NtpIP;                                       
    oC_Time_t                  LeaseTime;                                   
    oC_Timestamp_t             IpExpiredTimestamp;                          
    oC_Net_HardwareAddress_t   HardwareRouterAddress;                       
} oC_Net_Ipv4Info_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct
{
    oC_Net_Ipv6_t      IPv6;    
} oC_Net_Ipv6Info_t;

//==========================================================================================================================================
//==========================================================================================================================================
typedef struct
{
    oC_Net_InterfaceName_t      InterfaceName;              
    oC_Net_InterfaceIndex_t     InterfaceIndex;             
    const char *                DriverName;                 
    oC_Net_LinkStatus_t         LinkStatus;                 
    oC_MemorySize_t             TransmittedBytes;           
    oC_MemorySize_t             ReceivedBytes;              
    oC_Net_HardwareType_t       HardwareType;               
    oC_Net_HardwareAddress_t    HardwareAddress;            
    oC_Net_HardwareAddress_t    HardwareBroadcastAddress;   
    uint32_t                    HardwareAddressLength;      
    oC_BaudRate_t               BaudRate;                   
    oC_Net_QueueStatus_t        QueueStatus;                

    struct
    {
        oC_Net_Ipv4Info_t       IPv4;   
        oC_Net_Ipv6Info_t       IPv6;   
    } NetworkLayer;                     
} oC_Net_Info_t;

#undef  _________________________________________TYPES_SECTION______________________________________________________________________________

#define _________________________________________INLINE_SECTION_____________________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Net_ConvertUint16ToNetworkEndianess(uint16_t v)
{
#if defined(LITTLE_ENDIAN)
  return (v >> 8) | (v << 8);
#elif defined(BIG_ENDIAN)
  return v;
#else
#   error Unknown endianess
#endif
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint32_t oC_Net_ConvertUint32ToNetworkEndianess(uint32_t v)
{
#if defined(LITTLE_ENDIAN)
  return oC_Net_ConvertUint16ToNetworkEndianess(v >> 16) | (oC_Net_ConvertUint16ToNetworkEndianess((uint16_t) v) << 16);
#elif defined(BIG_ENDIAN)
  return v;
#else
#   error Unknown endianess
#endif
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Net_ConvertUint16FromNetworkEndianess(uint16_t v)
{
    return oC_Net_ConvertUint16ToNetworkEndianess(v);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint32_t oC_Net_ConvertUint32FromNetworkEndianess(uint32_t v)
{
  return oC_Net_ConvertUint32ToNetworkEndianess(v);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline void oC_Net_ConvertBufferToNetworkEndianess( void * Buffer , uint16_t Size  )
{
    uint16_t * array      = Buffer;
    uint16_t   arraySize  = Size / sizeof(uint16_t);

    if(
        oC_SaveIfFalse("oC_Net_ConvertBufferToNetworkEndianess: "                               , isram(Buffer)                     , oC_ErrorCode_AddressNotInRam    )
     && oC_SaveIfFalse("oC_Net_ConvertBufferToNetworkEndianess: (size is 0)"                    , Size > 0                          , oC_ErrorCode_SizeNotCorrect     )
     && oC_SaveIfFalse("oC_Net_ConvertBufferToNetworkEndianess: (size not aligned to 2 bytes)"  , Size % sizeof(uint16_t) == 0      , oC_ErrorCode_SizeNotAligned     )
        )
    {
        for(uint16_t i = 0 ; i < arraySize ; i++)
        {
            array[i] = oC_Net_ConvertUint16ToNetworkEndianess(array[i]);
        }
    }
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline void oC_Net_ConvertBufferFromNetworkEndianess( void * Buffer , uint16_t Size  )
{
    uint16_t * array      = Buffer;
    uint16_t   arraySize  = Size / sizeof(uint16_t);

    if(
        oC_SaveIfFalse("oC_Net_ConvertBufferFromNetworkEndianess: "                               , isram(Buffer)                     , oC_ErrorCode_AddressNotInRam    )
     && oC_SaveIfFalse("oC_Net_ConvertBufferFromNetworkEndianess: (size is 0)"                    , Size > 0                          , oC_ErrorCode_SizeNotCorrect     )
     && oC_SaveIfFalse("oC_Net_ConvertBufferFromNetworkEndianess: (size not aligned to 2 bytes)"  , Size % sizeof(uint16_t) == 0      , oC_ErrorCode_SizeNotAligned     )
        )
    {
        for(uint16_t i = 0 ; i < arraySize ; i++)
        {
            array[i] = oC_Net_ConvertUint16FromNetworkEndianess(array[i]);
        }
    }
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline int oC_Net_PrepareInterfaceName( oC_Net_InterfaceName_t *outName  , const char * Prefix , oC_Net_InterfaceIndex_t Index )
{
    return sprintf_s( *outName , sizeof(*outName) , "%s#%X" , Prefix , Index);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline int oC_Net_MacAddressFromString( const char * MacAddressString , oC_Net_MacAddress_t outMacAddress )
{
    return sscanf(MacAddressString,"%x:%x:%x:%x:%x:%x" , &outMacAddress[0], &outMacAddress[1], &outMacAddress[2],
                                                         &outMacAddress[3], &outMacAddress[4], &outMacAddress[5]);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline const char * oC_Net_GetProtocolName( oC_Net_Protocol_t Protocol )
{
    const char * name = "unknown";

    switch(Protocol)
    {
        case oC_Net_Protocol_ICMP    : name = "[ICMP ] Internet Control Message Protocol   "; break;
        case oC_Net_Protocol_IGMP    : name = "[IGMP ] Internet Group Management Protocol  "; break;
        case oC_Net_Protocol_TCP     : name = "[TCP  ] Transmission Control Protocol       "; break;
        case oC_Net_Protocol_UDP     : name = "[UDP  ] User Datagram Protocol              "; break;
        case oC_Net_Protocol_ENCAP   : name = "[ENCAP] IPv6 encapsulation protocol         "; break;
        case oC_Net_Protocol_OSPF    : name = "[OSPF ] Open Shortest Path First            "; break;
        case oC_Net_Protocol_SCTP    : name = "[SCTP ] Stream Control Transmission Protocol"; break;
        default:
            break;
    }


    return name;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_ErrorCode_t oC_Net_HardwareAddressToString( const oC_Net_HardwareAddress_t * HardwareAddress , oC_Net_HardwareType_t Type , char * outString , oC_MemorySize_t Size )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        ErrorCondition( isaddresscorrect(HardwareAddress)   , oC_ErrorCode_WrongAddress             )
     && ErrorCondition( HardwareAddress->Filled             , oC_ErrorCode_HardwareAddressIsEmpty   )
     && ErrorCondition( isram(outString)                    , oC_ErrorCode_OutputAddressNotInRAM    )
     && ErrorCondition( Size > 0                            , oC_ErrorCode_SizeNotCorrect           )
        )
    {
        switch(Type)
        {
            case oC_Net_HardwareType_Ethernet:
                sprintf_s(outString,Size,"%02X:%02X:%02X:%02X:%02X:%02X",
                          HardwareAddress->MacAddress[0],
                          HardwareAddress->MacAddress[1],
                          HardwareAddress->MacAddress[2],
                          HardwareAddress->MacAddress[3],
                          HardwareAddress->MacAddress[4],
                          HardwareAddress->MacAddress[5]
                          );
                errorCode = oC_ErrorCode_None;
                break;
            default:
                errorCode = oC_ErrorCode_UnknownHardwareType;
                break;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_ErrorCode_t oC_Net_Ipv4AddressToString( oC_Net_Ipv4_t Address, char * outString , oC_MemorySize_t Size )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        ErrorCondition( isram(outString)                , oC_ErrorCode_OutputAddressNotInRAM        )
     && ErrorCondition( Size > 0                        , oC_ErrorCode_SizeNotCorrect               )
        )
    {
        sprintf_s(outString, Size, "%d.%d.%d.%d",
                  (Address & 0xFF000000) >> 24,
                  (Address & 0x00FF0000) >> 16,
                  (Address & 0x0000FF00) >> 8,
                  (Address & 0x000000FF) >> 0
                  );
        errorCode = oC_ErrorCode_None;
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_ErrorCode_t oC_Net_AddressToString( const oC_Net_Address_t * Address, char * outString , oC_MemorySize_t Size )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        ErrorCondition( isaddresscorrect(Address)       , oC_ErrorCode_WrongAddress                 )
     && ErrorCondition( isram(outString)                , oC_ErrorCode_OutputAddressNotInRAM        )
     && ErrorCondition( Size > 0                        , oC_ErrorCode_SizeNotCorrect               )
        )
    {
        if(Address->Type == oC_Net_AddressType_IPv4)
        {
            errorCode = oC_Net_Ipv4AddressToString(Address->IPv4,outString,Size);
        }
        else if(Address->Type == oC_Net_AddressType_IPv6)
        {
            errorCode = oC_ErrorCode_NotImplemented;
        }
        else
        {
            errorCode = oC_ErrorCode_UnknownAddressType;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_ErrorCode_t oC_Net_AddressFromString( const char * Address , oC_Net_Address_t * outAddress )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        ErrorCondition( isaddresscorrect(Address) , oC_ErrorCode_WrongAddress           )
     && ErrorCondition( isram(outAddress)         , oC_ErrorCode_OutputAddressNotInRAM  )
        )
    {
        uint8_t         bytesArray[16]  = {0};
        oC_Net_Port_t   port            = 0;

        if(
            ErrorCode( sscanf(Address, "%d.%d.%d.%d",    &bytesArray[0], &bytesArray[1], &bytesArray[2], &bytesArray[3]             ) )
         || ErrorCode( sscanf(Address, "%d.%d.%d.%d:%d", &bytesArray[0], &bytesArray[1], &bytesArray[2], &bytesArray[3], &port      ) )
            )
        {
            outAddress->Type    = oC_Net_AddressType_IPv4;
            outAddress->Port    = port;
            outAddress->IPv4    = (bytesArray[0] << 24)
                                | (bytesArray[1] << 16)
                                | (bytesArray[2] <<  8)
                                | (bytesArray[3] <<  0);
            errorCode = oC_ErrorCode_None;
        }
        else if(
            ErrorCode( sscanf(Address, "%x:%x:%x:%x:%x:%x:%x:%x", &bytesArray[0], &bytesArray[1], &bytesArray[2], &bytesArray[3],
                                                                  &bytesArray[4], &bytesArray[5], &bytesArray[6], &bytesArray[7]) )
            )
        {
            outAddress->Type            = oC_Net_AddressType_IPv6;
            outAddress->Port            = port;
            outAddress->IPv6.LowPart    = (((uint64_t)bytesArray[0] ) << 0 )
                                        | (((uint64_t)bytesArray[1] ) << 8 )
                                        | (((uint64_t)bytesArray[2] ) << 16)
                                        | (((uint64_t)bytesArray[3] ) << 24)
                                        | (((uint64_t)bytesArray[4] ) << 32)
                                        | (((uint64_t)bytesArray[5] ) << 40)
                                        | (((uint64_t)bytesArray[6] ) << 48)
                                        | (((uint64_t)bytesArray[7] ) << 56);
            outAddress->IPv6.HighPart   = (((uint64_t)bytesArray[8] ) << 0 )
                                        | (((uint64_t)bytesArray[9] ) << 8 )
                                        | (((uint64_t)bytesArray[10]) << 16)
                                        | (((uint64_t)bytesArray[11]) << 24)
                                        | (((uint64_t)bytesArray[12]) << 32)
                                        | (((uint64_t)bytesArray[13]) << 40)
                                        | (((uint64_t)bytesArray[14]) << 48)
                                        | (((uint64_t)bytesArray[15]) << 56);
            errorCode                   = oC_ErrorCode_None;
        }
        else
        {
            errorCode = oC_ErrorCode_IpAddressNotCorrect;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_IsAddressCorrect( const oC_Net_Address_t * Address )
{
    bool correct = false;

    if(isaddresscorrect(Address))
    {
        if(Address->Type == oC_Net_AddressType_IPv4)
        {
            correct = true;
        }
        else if(Address->Type == oC_Net_AddressType_IPv6)
        {
            correct = true;
        }
    }

    return correct;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_IsAddressEmpty( const oC_Net_Address_t * Address )
{
    bool empty = true;

    if(isaddresscorrect(Address))
    {
        if(Address->Type == oC_Net_AddressType_IPv4)
        {
            empty = Address->IPv4 == 0;
        }
        else if(Address->Type == oC_Net_AddressType_IPv6)
        {
            empty = Address->IPv6.LowPart == 0 && Address->IPv6.HighPart == 0;
        }
    }

    return empty;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_Ipv4_IsAddressInSubnet( oC_Net_Ipv4_t IP , oC_Net_Ipv4_t Subnet , oC_Net_Ipv4_t Mask )
{
    return (IP & Mask) == (Subnet & Mask);
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_IsAddressInSubnet( const oC_Net_Address_t * Address, const oC_Net_Address_t * Subnet , const oC_Net_Address_t * Mask )
{
    bool belong = false;

    if(isaddresscorrect(Address) && isaddresscorrect(Subnet) && isaddresscorrect(Mask) && Address->Type == Subnet->Type)
    {
        if(Address->Type == oC_Net_AddressType_IPv4)
        {
            belong = oC_Net_Ipv4_IsAddressInSubnet(Address->IPv4,Subnet->IPv4,Mask->IPv4);
        }
        else if(Address->Type == oC_Net_AddressType_IPv6)
        {
            oC_SaveError("Net::IsAddressInSubnet - IPv6 version - ", oC_ErrorCode_NotImplemented);
        }
    }

    return belong;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_AreAddressesTheSame( const oC_Net_Address_t * Address1 , const oC_Net_Address_t * Address2 )
{
    bool same = false;

    if(isaddresscorrect(Address1) && isaddresscorrect(Address2) && Address1->Type == Address2->Type)
    {
        if(Address1->Type == oC_Net_AddressType_IPv4)
        {
            same = Address1->IPv4 == Address2->IPv4;
        }
        else if(Address1->Type == oC_Net_AddressType_IPv6)
        {
            same = memcmp(&Address1->IPv6,&Address2->IPv6,sizeof(oC_Net_Ipv6_t)) == 0;
        }
    }

    return same;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Net_GetMaximumPacketDataSize( oC_Net_PacketType_t Type )
{
    return Type == oC_Net_PacketType_IPv4 ? (MAXIMUM_PACKET_SIZE - sizeof(oC_Net_Ipv4PacketHeader_t)) :
           Type == oC_Net_PacketType_IPv6 ? (MAXIMUM_PACKET_SIZE - sizeof(oC_Net_Ipv6PacketHeader_t)) : 0;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Net_GetPacketSize( const oC_Net_Packet_t * Packet , bool WithHeader )
{
    uint16_t size = 0;

    if(isaddresscorrect(Packet))
    {
        if(Packet->IPv4.Header.Version == oC_Net_PacketType_IPv4)
        {
            size = (uint16_t)Packet->IPv4.Header.Length;

            if( WithHeader == false )
            {
                size -= Packet->IPv4.Header.IHL * sizeof(uint32_t);
            }
        }
        else if(Packet->IPv4.Header.Version == oC_Net_PacketType_IPv6)
        {
            size = (uint16_t)Packet->IPv6.Header.PayloadLength + sizeof(oC_Net_Ipv6PacketHeader_t);
            if(WithHeader)
            {
                size += sizeof(oC_Net_Ipv6PacketHeader_t);
            }
        }
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_ConvertHeaderToNetworkEndianess( oC_Net_Packet_t * Packet )
{
    bool success = false;

    if(isaddresscorrect(Packet))
    {
        if(Packet->IPv4.Header.Version == oC_Net_PacketType_IPv4)
        {
            success = true;

            uint32_t   ihl        = Packet->IPv4.Header.IHL;

            Packet->IPv4.Header.IHL     = Packet->IPv4.Header.Version;
            Packet->IPv4.Header.Version = ihl;
            Packet->IPv4.Header.Length  = oC_Net_ConvertUint16ToNetworkEndianess(Packet->IPv4.Header.Length);

            Packet->IPv4.Header.SourceIp        = oC_Net_ConvertUint32FromNetworkEndianess(Packet->IPv4.Header.SourceIp);
            Packet->IPv4.Header.DestinationIp   = oC_Net_ConvertUint32FromNetworkEndianess(Packet->IPv4.Header.DestinationIp);

            uint16_t * word = (void*)Packet;

            word[3] = oC_Net_ConvertUint16FromNetworkEndianess(word[3]); /* Offset & Flags */
        }
        else if(Packet->IPv6.Header.Version == oC_Net_PacketType_IPv6)
        {
            kdebuglog(oC_LogType_Error, "oC_Net_ConvertHeaderToNetworkEndianess: not implemented for IPv6 yet\n");
        }
        else
        {
            kdebuglog(oC_LogType_Error, "oC_Net_ConvertHeaderToNetworkEndianess: incorrect packet type %d\n", Packet->IPv6.Header.Version);
        }
    }

    return success;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_ConvertHeaderFromNetworkEndianess( oC_Net_Packet_t * Packet )
{
    bool success = false;

    if(isaddresscorrect(Packet))
    {
        /* When header is not converted, IHL stores version of the header */
        if(Packet->IPv4.Header.IHL == oC_Net_PacketType_IPv4)
        {
            success = true;

            /* When header is not converted Version stores IHL of the header */
            uint32_t   ihl        = Packet->IPv4.Header.Version;

            Packet->IPv4.Header.Version         = Packet->IPv4.Header.IHL;
            Packet->IPv4.Header.IHL             = ihl;
            Packet->IPv4.Header.Length          = oC_Net_ConvertUint16ToNetworkEndianess(Packet->IPv4.Header.Length);

            Packet->IPv4.Header.SourceIp        = oC_Net_ConvertUint32FromNetworkEndianess(Packet->IPv4.Header.SourceIp);
            Packet->IPv4.Header.DestinationIp   = oC_Net_ConvertUint32FromNetworkEndianess(Packet->IPv4.Header.DestinationIp);

            uint16_t * word = (void*)Packet;

            word[3] = oC_Net_ConvertUint16FromNetworkEndianess(word[3]); /* Offset & Flags */
        }
        /* When header is not converted, IHL stores version of the header */
        else if(Packet->IPv4.Header.IHL == oC_Net_PacketType_IPv6)
        {
            kdebuglog(oC_LogType_Error, "not implemented for IPv6 yet\n");
        }
        else
        {
            kdebuglog(oC_LogType_Error, "oC_Net_ConvertHeaderFromNetworkEndianess: incorrect packet type %d\n", Packet->IPv4.Header.IHL);
        }
    }

    return success;
}



//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_MemorySize_t oC_Net_GetHardwareAddressSize( oC_Net_HardwareType_t Type )
{
    oC_MemorySize_t size = 0;

    switch(Type)
    {
        case oC_Net_HardwareType_Ethernet: size = sizeof(oC_Net_MacAddress_t); break;
        default: size = 0; break;
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_MemorySize_t oC_Net_GetAddressSize( const oC_Net_Address_t * Address )
{
    oC_MemorySize_t size = 0;

    if(isaddresscorrect(Address))
    {
        switch(Address->Type)
        {
            case oC_Net_AddressType_IPv4: size = sizeof(oC_Net_Ipv4_t); break;
            case oC_Net_AddressType_IPv6: size = sizeof(oC_Net_Ipv6_t); break;
        }
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline const char * oC_Net_GetHardwareTypeName( oC_Net_HardwareType_t Type )
{
    const char * name = "unknown";

    switch(Type)
    {
        case oC_Net_HardwareType_Ethernet: name = "ethernet"; break;
        default: name = "unhandled in oC_Net_GetHardwareTypeName";
    }

    return name;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_ErrorCode_t oC_Net_ReadLayerName( oC_Net_Layer_t Layer , char * outName, oC_MemorySize_t Size )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(ErrorCondition(isram(outName), oC_ErrorCode_OutputAddressNotInRAM))
    {
        oC_Net_Layer_t mainLayer = Layer & oC_Net_Layer_MainLayerMask;
        oC_Net_Layer_t subLayer  = Layer & oC_Net_Layer_SubLayerMask;

        const char * mainLayerName = "unknownMainLayer";

        switch(mainLayer)
        {
            default:    break;
            case oC_Net_Layer_Physical    : mainLayerName = "Physical";     break;
            case oC_Net_Layer_DataLink    : mainLayerName = "DataLink";     break;
            case oC_Net_Layer_Network     : mainLayerName = "Network";      break;
            case oC_Net_Layer_Transport   : mainLayerName = "Transport";    break;
            case oC_Net_Layer_Session     : mainLayerName = "Session";      break;
            case oC_Net_Layer_Presentation: mainLayerName = "Presentation"; break;
            case oC_Net_Layer_Application : mainLayerName = "Application";  break;
        }

        errorCode = sprintf_s(outName,Size,"%s:%d", mainLayerName, subLayer);
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_ErrorCode_t oC_Net_ReadLayerByName( oC_Net_Layer_t * outLayer, const char * Name )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        ErrorCondition( isram(outLayer)         , oC_ErrorCode_OutputAddressNotInRAM )
     && ErrorCondition( isaddresscorrect(Name)  , oC_ErrorCode_WrongAddress          )
        )
    {
        uint32_t     subLayer = 0;
        static const struct
        {
                const char *    Name;
                oC_Net_Layer_t  Layer;
        } layerStrings[] = {
                        { .Name = "PHY"          , .Layer = oC_Net_Layer_PHY          } ,
                        { .Name = "LLC"          , .Layer = oC_Net_Layer_LLC          } ,
                        { .Name = "MAC"          , .Layer = oC_Net_Layer_MAC          } ,
                        { .Name = "Netif"        , .Layer = oC_Net_Layer_Netif        } ,
                        { .Name = "Physical"     , .Layer = oC_Net_Layer_Physical     } ,
                        { .Name = "DataLink"     , .Layer = oC_Net_Layer_DataLink     } ,
                        { .Name = "Network"      , .Layer = oC_Net_Layer_Network      } ,
                        { .Name = "Transport"    , .Layer = oC_Net_Layer_Transport    } ,
                        { .Name = "Session"      , .Layer = oC_Net_Layer_Session      } ,
                        { .Name = "Presentation" , .Layer = oC_Net_Layer_Presentation } ,
                        { .Name = "Application"  , .Layer = oC_Net_Layer_Application  } ,
        };


        errorCode = oC_ErrorCode_UnknownLayer;

        oC_ARRAY_FOREACH_IN_ARRAY(layerStrings,layer)
        {
            if(string_contains(Name,layer->Name,false))
            {
                *outLayer = layer->Layer;
                errorCode = oC_ErrorCode_None;
            }
        }

        if(
            string_contains(Name,":",true)
         && ErrorCode(sscanf(Name,"%*s:%u", &subLayer))
            )
        {
            *outLayer |= subLayer;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_IsMainLayer( oC_Net_Layer_t Layer , oC_Net_Layer_t MainLayer )
{
    return (Layer & oC_Net_Layer_MainLayerMask) == MainLayer;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_Net_PacketType_t oC_Net_Packet_GetType( const oC_Net_Packet_t * Packet )
{
    oC_Net_PacketType_t type = oC_Net_PacketType_Invalid;

    if(isaddresscorrect(Packet))
    {
        type = (oC_Net_PacketType_t)Packet->IPv4.Header.Version;
    }

    return type;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_Packet_SetSize( oC_Net_Packet_t * Packet , uint16_t Size )
{
    bool success = false;

    if(isram(Packet) && Size > 0 && Size <= oC_Net_GetMaximumPacketDataSize(oC_Net_Packet_GetType(Packet)))
    {
        if(Packet->IPv4.Header.Version == oC_Net_PacketType_IPv4)
        {
            Packet->IPv4.Header.Length = Size + (Packet->IPv4.Header.IHL * sizeof(uint32_t));
            success                    = true;
        }
        else if(Packet->IPv4.Header.Version == oC_Net_PacketType_IPv6)
        {

            kdebuglog(oC_LogType_Error, "oC_Net_SetPacketSize:: IPv6 is not ready yet\n", Packet->IPv4.Header.Version);
        }
        else
        {
            kdebuglog(oC_LogType_Error, "oC_Net_SetPacketSize:: incorrect packet version: %d\n", Packet->IPv4.Header.Version);
        }
    }

    return success;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline void * oC_Net_Packet_GetDataReference( oC_Net_Packet_t * Packet )
{
    void * data = NULL;

    if(isaddresscorrect(Packet))
    {
        oC_Net_PacketType_t type = oC_Net_Packet_GetType(Packet);

        if(type == oC_Net_PacketType_IPv4)
        {
            data = Packet->IPv4.Data;
        }
        else if(type == oC_Net_PacketType_IPv6)
        {
            data = Packet->IPv6.Data;
        }
    }

    return data;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline void oC_Net_Packet_SetAddress( oC_Net_Packet_t * Packet, const oC_Net_Address_t * Source, const oC_Net_Address_t * Destination )
{
    if(isram(Packet))
    {
        if(Packet->IPv4.Header.Version == oC_Net_PacketType_IPv4)
        {
            Packet->IPv4.Header.Protocol = Source->Protocol;

            if(isaddresscorrect(Source) && Source->Type == oC_Net_AddressType_IPv4)
            {
                Packet->IPv4.Header.SourceIp = Source->IPv4;
            }
            if(isaddresscorrect(Destination) && Destination->Type == oC_Net_AddressType_IPv4)
            {
                Packet->IPv4.Header.DestinationIp = Destination->IPv4;
            }
        }
        else if(Packet->IPv4.Header.Version == oC_Net_PacketType_IPv6)
        {
            if(isaddresscorrect(Source) && Source->Type == oC_Net_AddressType_IPv6)
            {
                Packet->IPv6.Header.Source.HighPart = Source->IPv6.HighPart;
                Packet->IPv6.Header.Source.LowPart  = Source->IPv6.LowPart;
            }
            if(isaddresscorrect(Destination) && Destination->Type == oC_Net_AddressType_IPv6)
            {
                Packet->IPv6.Header.Destination.HighPart = Destination->IPv6.HighPart;
                Packet->IPv6.Header.Destination.LowPart  = Destination->IPv6.LowPart;
            }
        }
    }
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline void oC_Net_Packet_SetData( oC_Net_Packet_t * Packet , const void * Data , uint16_t Size )
{
    oC_Net_PacketType_t type = oC_Net_Packet_GetType(Packet);

    if(isram(Packet) && isaddresscorrect(Data) && Size > 0 && Size <= oC_Net_GetMaximumPacketDataSize(type))
    {
        if(type == oC_Net_PacketType_IPv4)
        {
            oC_Net_Packet_SetSize(Packet,Size);
            memcpy( Packet->IPv4.Data, Data, Size );
        }
        else if(type == oC_Net_PacketType_IPv6)
        {
            Packet->IPv6.Header.PayloadLength = Size;
            memcpy( Packet->IPv6.Data, Data, Size );
        }

    }
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline oC_Net_Packet_t* oC_Net_Packet_New( Allocator_t Allocator , oC_Net_PacketType_t Type , void * Data , uint16_t Size )
{
    oC_Net_Packet_t * packet = NULL;

    if(
        oC_SaveIfFalse( "Net::New-Packet - Allocator is not correct - "    , isaddresscorrect(Allocator)                    , oC_ErrorCode_WrongAddress     )
     && oC_SaveIfFalse( "Net::New-Packet - Type is not correct - "         ,    Type == oC_Net_PacketType_IPv4
                                                                             || Type == oC_Net_PacketType_IPv6              , oC_ErrorCode_TypeNotCorrect   )
     && oC_SaveIfFalse( "Net::New-Packet - Size is not correct - "         , Size > 0                                       , oC_ErrorCode_SizeNotCorrect   )
     && oC_SaveIfFalse( "Net::New-Packet - Size is not correct - "         , Size <= oC_Net_GetMaximumPacketDataSize(Type)  , oC_ErrorCode_SizeTooBig       )
     && oC_SaveIfFalse( "Net::New-Packet - Data address is not correct - " , Data == NULL || isaddresscorrect(Data)         , oC_ErrorCode_SizeNotCorrect   )
        )
    {
        uint16_t headerSize = Type == oC_Net_PacketType_IPv4 ? sizeof(oC_Net_Ipv4PacketHeader_t) :
                              Type == oC_Net_PacketType_IPv6 ? sizeof(oC_Net_Ipv6PacketHeader_t) : 0;
        uint16_t packetSize = oC_MAX(headerSize + Size, sizeof(oC_Net_Packet_t));

        if(oC_SaveIfFalse("Net::New-Packet - Fatal error - ", packetSize > Size , oC_ErrorCode_SizeTooBig))
        {
            packet = kmalloc( packetSize , Allocator, AllocationFlags_ZeroFill );

            if(oC_SaveIfFalse("Net::New-Packet - cannot allocate memory for a packet - ", packet != NULL , oC_ErrorCode_AllocationError ))
            {
                packet->IPv4.Header.Version = Type;

                if(Type == oC_Net_PacketType_IPv4)
                {
                    packet->IPv4.Header.IHL = 5;
                }

                oC_Net_Packet_SetSize(packet,Size);

                if(Data != NULL)
                {
                    oC_Net_Packet_SetData(packet,Data,Size);
                }
            }

        }
    }

    return packet;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline bool oC_Net_Packet_Delete( oC_Net_Packet_t ** Packet )
{
    bool success = false;

    if(isram(Packet) && isram(*Packet))
    {
        success = kfree(*Packet,AllocationFlags_Default);
        *Packet = NULL;
    }

    return success;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Net_CalculateChecksum( const void * Buffer , uint16_t Size , uint16_t InitialValue , bool ConvertEndianess , bool PrepareChecksumToSend )
{
    uint32_t checksum = InitialValue;

    if(isaddresscorrect(Buffer) && Size > 0)
    {
        const uint16_t * array = Buffer;
        uint16_t         count = Size / sizeof(uint16_t);

        for(uint16_t i = 0 ; i < count ; i++)
        {
            uint16_t valueInNetworkEndianess = ConvertEndianess ? oC_Net_ConvertUint16ToNetworkEndianess( array[i] ) : array[i];

            checksum += valueInNetworkEndianess;

            while(checksum >> 16)
            {
                checksum = (checksum & 0xFFFF) + (checksum >> 16);
            }
        }

        if(Size % sizeof(uint16_t))
        {
            if(ConvertEndianess)
            {
                checksum += (((uint8_t*)Buffer)[Size-1]) << 8;
            }
            else
            {
                checksum += ((uint8_t*)Buffer)[Size-1];
            }
        }

        while(checksum >> 16)
        {
            checksum = (checksum & 0xFFFF) + (checksum >> 16);
        }

        if(PrepareChecksumToSend)
        {
            checksum = (~checksum) & 0xFFFF;

            if(checksum == 0)
            {
                checksum = 0xFFFF;
            }
        }
    }

    return (uint16_t)checksum;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline uint16_t oC_Net_Packet_CalculateChecksum( oC_Net_Packet_t * Packet )
{
    uint16_t checksum = 0;

    if(isaddresscorrect(Packet))
    {
        oC_Net_PacketType_t type = oC_Net_Packet_GetType(Packet);

        if(type == oC_Net_PacketType_IPv4)
        {
            uint16_t storedChecksum = Packet->IPv4.Header.Checksum;
            uint16_t headerSize     = Packet->IPv4.Header.IHL * sizeof(uint32_t);
            Packet->IPv4.Header.Checksum = 0;

            oC_Net_ConvertHeaderToNetworkEndianess(Packet);
            checksum = oC_Net_CalculateChecksum(Packet, headerSize, 0, false, true);
            oC_Net_ConvertHeaderFromNetworkEndianess(Packet);

            Packet->IPv4.Header.Checksum = storedChecksum;

        }
    }

    return checksum;
}

#undef  _________________________________________INLINE_SECTION_____________________________________________________________________________


#endif /* SYSTEM_CORE_INC_NET_OC_NET_H_ */