BSDSocketAddress.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 BSDSocketAddress inline non-template implementation */

//#include "BSDSocketAddress.ih"

// Custom includes
#include <string.h>
#include <algorithm>
#include <typeinfo>

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

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::BSDSocketAddress

prefix_ struct sockaddr const * senf::BSDSocketAddress::sockaddr_p()
    const
{
    return static_cast<GenericBSDSocketAddress const *>(this)->sockaddr_p();
}

prefix_ short senf::BSDSocketAddress::family()
    const
{
    return sockaddr_p()->sa_family;
}

prefix_ socklen_t senf::BSDSocketAddress::socklen()
    const
{
    return len_;
}

prefix_ socklen_t const * senf::BSDSocketAddress::socklen_p()
    const
{
    return & len_;
}

prefix_ void senf::BSDSocketAddress::socklen(socklen_t len)
{
    len_ = len;
}

prefix_ bool senf::BSDSocketAddress::operator==(BSDSocketAddress const & other)
    const
{
    return socklen()==other.socklen() && memcmp(sockaddr_p(), other.sockaddr_p(), socklen())==0;
}

prefix_ bool senf::BSDSocketAddress::operator<(BSDSocketAddress const & other)
    const
{
    if (socklen() < other.socklen()) return true;
    else if (socklen() > other.socklen()) return false;
    else return memcmp(sockaddr_p(), other.sockaddr_p(), socklen()) < 0;
}

prefix_ bool senf::BSDSocketAddress::boolean_test()
    const
{
    return socklen() > sizeof(short) && family() != AF_UNSPEC &&
        unsigned(std::count(reinterpret_cast<unsigned char const *>(sockaddr_p())+sizeof(short),
                            reinterpret_cast<unsigned char const *>(sockaddr_p())+socklen(),
                   0u)) < socklen()-2;
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// protected members

prefix_ senf::BSDSocketAddress::BSDSocketAddress(socklen_t len, short family)
    : len_ (len)
{
    ::memset(sockaddr_p(), 0u, len_);
    sockaddr_p()->sa_family = family;
}

// WARNING: THIS COPY CONSTRUCTOR IS NOT GENERALLY SAFE !!!!!!
// It is only safe if:
// a) source and target class are identical derived classes (e.g. Both INet4)
// b) target is GenericBSDSocketAddress (sockaddr_storage).
//
// In these cases, the storage space available for the target is at least as large as that
// available for the source ant the copy is ok.
//
// To ensure this behavior, the copy constructor is protected here and is made accessible only
// via the corresponding derived classes.
//
// The same holds for the copy-assignment operator
prefix_ senf::BSDSocketAddress::BSDSocketAddress(BSDSocketAddress const & other)
    : len_ (other.socklen())
{
    ::memcpy(sockaddr_p(), other.sockaddr_p(), len_);
}

prefix_ senf::BSDSocketAddress &
senf::BSDSocketAddress::operator=(BSDSocketAddress const & other)
{
    len_ = other.socklen();
    ::memmove(sockaddr_p(), other.sockaddr_p(), len_);
    return *this;
}


prefix_ struct sockaddr * senf::BSDSocketAddress::sockaddr_p()
{
    return static_cast<GenericBSDSocketAddress *>(this)->sockaddr_p();
}

prefix_ socklen_t * senf::BSDSocketAddress::socklen_p()
{
    return & len_;
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// related

template <class Target>
prefix_ Target & senf::sockaddr_cast(BSDSocketAddress & source)
{
    if (source.family() != Target::addressFamily)
        throw std::bad_cast();
    return static_cast<Target &>(source);
}

template <class Target>
prefix_ Target const & senf::sockaddr_cast(BSDSocketAddress const & source)
{
    if (source.family() != Target::addressFamily)
        throw std::bad_cast();
    return static_cast<Target const &>(source);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::GenericBSDSocketAddress

prefix_ senf::GenericBSDSocketAddress::GenericBSDSocketAddress()
    : BSDSocketAddress(sizeof(sockaddr_storage), AF_UNSPEC)
{}

prefix_ senf::GenericBSDSocketAddress::GenericBSDSocketAddress(BSDSocketAddress const & other)
    : BSDSocketAddress(other)
{}

prefix_ senf::GenericBSDSocketAddress&
senf::GenericBSDSocketAddress::operator=(const BSDSocketAddress & other)
{
    BSDSocketAddress::operator=(other);
    return *this;
}

prefix_
senf::GenericBSDSocketAddress::GenericBSDSocketAddress(const GenericBSDSocketAddress& other)
    : BSDSocketAddress(other)
{}

prefix_ senf::GenericBSDSocketAddress&
senf::GenericBSDSocketAddress::operator=(const GenericBSDSocketAddress& other)
{
    BSDSocketAddress::operator=(other);
    return *this;
}

prefix_ struct sockaddr const * senf::GenericBSDSocketAddress::sockaddr_p()
    const
{
    return static_cast<struct sockaddr const *>(static_cast<void const *>(& addr_));
}

prefix_ struct sockaddr * senf::GenericBSDSocketAddress::sockaddr_p()
{
    return static_cast<struct sockaddr *>(static_cast<void *>(& addr_));
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#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: