sbgNetwork.h

Go to the documentation of this file.

#ifndef __SBG_NETWORK_H__
#define __SBG_NETWORK_H__

//----------------------------------------------------------------------//
//- Header (open extern C block)                                       -//
//----------------------------------------------------------------------//
#ifdef __cplusplus
extern "C" {
#endif

#include <sbgCommon.h>

//----------------------------------------------------------------------//
//- Common IPv4 definitions                                            -//
//----------------------------------------------------------------------//
#define SBG_IPV4_UNSPECIFIED_ADDR       sbgIpAddr(0, 0, 0, 0)                           
#define SBG_IPV4_BROADCAST_ADDR         sbgIpAddr(255, 255, 255, 255)           
//----------------------------------------------------------------------//
//- IP setters / getters                                               -//
//----------------------------------------------------------------------//

SBG_INLINE sbgIpAddress sbgIpAddr(uint8 a, uint8 b, uint8 c, uint8 d)
{
#if SBG_CONFIG_BIG_ENDIAN == 1
        return (a << 24) | (b << 16) | (c << 8) | d;
#else
        return a | (b << 8) | (c << 16) | (d << 24);
#endif
}

SBG_INLINE uint8 sbgIpAddrGetA(sbgIpAddress ipAddr)
{
#if SBG_CONFIG_BIG_ENDIAN == 1
        return (uint8)((ipAddr & 0xFF000000) >> 24);
#else
        return (uint8)((ipAddr & 0x000000FF));
#endif
}

SBG_INLINE uint8 sbgIpAddrGetB(sbgIpAddress ipAddr)
{
#if SBG_CONFIG_BIG_ENDIAN == 1
        return (uint8)((ipAddr & 0x00FF0000) >> 16);
#else
        return (uint8)((ipAddr & 0x0000FF00) >> 8);
#endif
}

SBG_INLINE uint8 sbgIpAddrGetC(sbgIpAddress ipAddr)
{
#if SBG_CONFIG_BIG_ENDIAN == 1
        return (uint8)((ipAddr & 0x0000FF00) >> 8);
#else
        return (uint8)((ipAddr & 0x00FF0000) >> 16);
#endif
}

SBG_INLINE uint8 sbgIpAddrGetD(sbgIpAddress ipAddr)
{
#if SBG_CONFIG_BIG_ENDIAN == 1
        return (uint8)((ipAddr & 0x000000FF));
#else
        return (uint8)((ipAddr & 0xFF000000) >> 24);
#endif
}

//----------------------------------------------------------------------//
//- IP manipulation methods                                            -//
//----------------------------------------------------------------------//

void sbgNetworkIpToString(sbgIpAddress ipAddr, char *pBuffer, size_t maxSize);

sbgIpAddress sbgNetworkIpFromString(const char *pBuffer);

//----------------------------------------------------------------------//
//- IP operations                                                      -//
//----------------------------------------------------------------------//

SBG_INLINE sbgIpAddress sbgIpGetNetworkAddr(sbgIpAddress ipAddress, sbgIpAddress netmask)
{
        return (ipAddress & netmask);
}

SBG_INLINE sbgIpAddress sbgIpGetHostAddr(sbgIpAddress ipAddress, sbgIpAddress netmask)
{
        return (ipAddress & ~netmask);
}

//----------------------------------------------------------------------//
//- IP validation methods                                              -//
//----------------------------------------------------------------------//

SBG_INLINE bool sbgIpAddressIsUnspecified(sbgIpAddress ipAddress)
{
        if (ipAddress == 0)
        {
                return true;
        }
        else
        {
                return false;
        }
}

SBG_INLINE bool sbgIpAddressValid(sbgIpAddress ipAddress)
{
        //
        // Check the if A part of the ip address is within 1 and 223
        //
        if ((sbgIpAddrGetA(ipAddress) > 0) && (sbgIpAddrGetA(ipAddress) < 224))
        {
                //
                // The ip address is valid
                //
                return true;
        }
        else
        {
                //
                // The ip address is not valid
                //
                return false;
        }
}

SBG_INLINE sbgIpAddress sbgIpAddrWithinSubnet(sbgIpAddress ipAddress, sbgIpAddress netmask)
{
        //
        // Just check if the host part is equals to zero
        //
        if (sbgIpGetHostAddr(ipAddress, netmask) == 0)
        {
                return false;
        }
        else
        {
                return true;
        }
}

SBG_INLINE bool sbgIpAddrIsSameNetwork(sbgIpAddress firstIpAddr, sbgIpAddress secondIpAddr, sbgIpAddress netmask)
{
        if ((firstIpAddr & netmask) == (secondIpAddr & netmask))
        {
                return true;
        }
        else
        {
                return false;
        }
}

bool sbgIpNetMaskValid(sbgIpAddress netmask);

//----------------------------------------------------------------------//
//- Footer (close extern C block)                                      -//
//----------------------------------------------------------------------//
#ifdef __cplusplus
}
#endif

#endif /* __SBG_NETWORK_H__ */