MACAddress.cci

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


/** \file
    \brief MACAddress inline non-template implementation */

// Custom includes
//#include <algorithm>
#include <endian.h>
#include <boost/functional/hash.hpp>
#include "EUI64.hh"

#define prefix_ inline
//-/////////////////////////////////////////////////////////////////////////////////////////////////

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::MACAddress

prefix_ senf::MACAddress::MACAddress()
{
    fill(0u);
}

prefix_ senf::MACAddress::MACAddress(senf::NoInit_t)
{}

prefix_ senf::MACAddress::MACAddress(std::uint64_t const & v)
{
    (*this)[0] = std::uint8_t( v >> 40 );
    (*this)[1] = std::uint8_t( v >> 32 );
    (*this)[2] = std::uint8_t( v >> 24 );
    (*this)[3] = std::uint8_t( v >> 16 );
    (*this)[4] = std::uint8_t( v >>  8 );
    (*this)[5] = std::uint8_t( v       );
}

prefix_ void senf::MACAddress::local(bool flag)
{
    if (flag) (*this)[0] |= 0x02;
    else      (*this)[0] &= ~0x02;
}

prefix_ void senf::MACAddress::multicast(bool flag)
{
    if (flag) (*this)[0] |= 0x01;
    else      (*this)[0] &= ~0x01;
}

prefix_ bool senf::MACAddress::local()
    const
{
    return (*this)[0] & 0x02;
}

prefix_ bool senf::MACAddress::multicast()
    const
{
    return (*this)[0] & 0x01;
}

prefix_ bool senf::MACAddress::broadcast()
    const
{
    return (*reinterpret_cast<std::uint32_t const *>(&(*this)[0]) == 0xffffffff) and (*reinterpret_cast<std::uint16_t const *>(&(*this)[4]) == 0xffff);
}

prefix_ senf::MACAddress::operator bool()
    const
{
    return (*reinterpret_cast<std::uint32_t const *>(&(*this)[0]) || *reinterpret_cast<std::uint16_t const *>(&(*this)[4]));
}

prefix_ std::uint32_t senf::MACAddress::oui()
    const
{
    return
        (std::uint32_t((*this)[0]) << 16) |
        (std::uint32_t((*this)[1]) <<  8) |
        (*this)[2];
}

prefix_ void senf::MACAddress::oui(std::uint32_t v)
{
    (*this)[0] = (v >> 16) & 0xff;
    (*this)[1] = (v >>  8) & 0xff;
    (*this)[2] = (v >>  0) & 0xff;
}

prefix_ std::uint32_t senf::MACAddress::nic()
    const
{
    return
        (std::uint32_t((*this)[3]) << 16) |
        (std::uint32_t((*this)[4]) <<  8) |
        (*this)[5];
}

prefix_ void senf::MACAddress::nic(std::uint32_t v)
{
    (*this)[3] = (v >> 16) & 0xff;
    (*this)[4] = (v >>  8) & 0xff;
    (*this)[5] = (v >>  0) & 0xff;
}

prefix_ std::uint64_t senf::MACAddress::eui64()
    const
{
    return
        (std::uint64_t( (*this)[0] ) << 56) |
        (std::uint64_t( (*this)[1] ) << 48) |
        (std::uint64_t( (*this)[2] ) << 40) |
        (std::uint64_t( 0xfffe     ) << 24) |
        (std::uint64_t( (*this)[3] ) << 16) |
        (std::uint64_t( (*this)[4] ) <<  8) |
        (std::uint64_t( (*this)[5] )      );
}

prefix_ std::uint64_t senf::MACAddress::uint64()
    const
{
    std::uint64_t t;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    std::reverse_copy(begin(), end(), (std::uint8_t*)&t);
    *(((std::uint16_t*)&t)+3) = 0;
#else
    std::copy(begin(), end(), ((std::uint8_t*)&t) + 2);
    *(((std::uint16_t*)&t)) = 0;
#endif
    return t;
}


prefix_ void senf::MACAddress::hash(std::uint64_t * hash, std::uint16_t const & otherKey)
    const
{ 
    std::copy(begin(), end(), (std::uint8_t*)hash);
    *(((std::uint16_t*)hash) + 3) = otherKey;
}

prefix_ std::uint32_t const & senf::MACAddress::hash32()
    const
{
    return *(reinterpret_cast<std::uint32_t const *> (&(*this)[2]));
}

prefix_ bool senf::MACAddress::operator==(EUI64 const & eui64)
    const
{
    return eui64.isMACCompatible()
        && std::equal(eui64.begin(), eui64.begin()+3, begin())
        && std::equal(eui64.begin()+5, eui64.end(), begin()+3);
}

prefix_ bool senf::operator==(EUI64 const & eui64, MACAddress const & mac)
{
    return mac == eui64;
}

prefix_ bool senf::MACAddress::operator<(MACAddress const & other)
    const
{
    return memcmp(&((*this)[0]), &other[0], 6) < 0;
}

# if __SIZEOF_SIZE_T__ == 8
prefix_ std::size_t senf::hash_value(senf::MACAddress const & mac) noexcept
{
    return boost::hash<std::uint64_t>().operator()(mac.uint64());
}
#elif __SIZEOF_SIZE_T__ == 4
prefix_ std::size_t const & senf::hash_value(senf::MACAddress const & mac) noexcept
{
    return mac.hash32();
}
#else
prefix_ std::size_t senf::hash_value(senf::MACAddress const & mac) noexcept
{
    BOOST_STATIC_ASSERT_MSG(true, "unknown sizeof(std::size_t)");
}
#endif



//-/////////////////////////////////////////////////////////////////////////////////////////////////
#undef prefix_


// Local Variables:
// mode: c++
// fill-column: 100
// comment-column: 40
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// End: