INetAddressing.hh

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


#ifndef HH_SENF_Socket_Protocols_INet_INetAddressing_
#define HH_SENF_Socket_Protocols_INet_INetAddressing_ 1

// Custom includes
#include <string>
#include <netinet/in.h>
#include <senf/Socket/Protocols/BSDAddressingPolicy.hh>
#include <senf/Socket/Protocols/BSDSocketAddress.hh>
#include "INet4Address.hh"
#include "INet6Address.hh"

//#include "INetAddressing.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    class INet4SocketAddress
        : public BSDSocketAddress
    {
    public:
        static short const addressFamily = AF_INET;

        //-////////////////////////////////////////////////////////////////////////
        //\{

        INet4SocketAddress();
        explicit INet4SocketAddress(std::string const & addr); 

        INet4SocketAddress(INet4Address const & addr, unsigned port);

        explicit INet4SocketAddress(unsigned port);

        INet4SocketAddress(const INet4SocketAddress& other);
        INet4SocketAddress& operator=(const INet4SocketAddress& other);

        //\}
        //-////////////////////////////////////////////////////////////////////////

        INet4Address address() const;   
        unsigned port() const;          

        void address(INet4Address const & addr); 
        void port(unsigned p);          

        using BSDSocketAddress::sockaddr_p;
        using BSDSocketAddress::socklen_p;

    private:
        struct ::sockaddr_in addr_;
    };

    std::ostream & operator<<(std::ostream & os, INet4SocketAddress const & addr);
    std::istream & operator>>(std::istream & is, INet4SocketAddress & addr);

    class INet6SocketAddress
        : public BSDSocketAddress
    {
    public:
        static short const addressFamily = AF_INET6;

        //-////////////////////////////////////////////////////////////////////////
        //\{

        INet6SocketAddress();           
        explicit INet6SocketAddress(std::string const & addr,
                                    INet6Address::Resolve_t resolve = INet6Address::ResolveINet6);

        INet6SocketAddress(INet6Address const & addr, unsigned port);
        INet6SocketAddress(INet6Address const & addr, unsigned port, std::string const & iface);

        explicit INet6SocketAddress(unsigned port);

        INet6SocketAddress(const INet6SocketAddress& other);
        INet6SocketAddress& operator=(const INet6SocketAddress& other);

        //\}
        //-////////////////////////////////////////////////////////////////////////

        INet6Address address() const;    
        void address(INet6Address const & addr); 

        unsigned port() const;          
        void port(unsigned port);       

        std::string iface() const;      
        void iface(std::string const & iface); 

        using BSDSocketAddress::sockaddr_p;
        using BSDSocketAddress::socklen_p;

    protected:

    private:
        void assignIface(std::string const & iface);

        struct sockaddr_in6 sockaddr_;
    };

    std::ostream & operator<<(std::ostream & os, INet6SocketAddress const & addr);
    std::istream & operator>>(std::istream & is, INet6SocketAddress & addr);

    //\{

    struct INet4AddressingPolicy
        : public BSDAddressingPolicy,
          private BSDAddressingPolicyMixin<INet4SocketAddress>
    {
        typedef INet4SocketAddress Address;

        using BSDAddressingPolicyMixin<INet4SocketAddress>::peer;
        using BSDAddressingPolicyMixin<INet4SocketAddress>::local;
        using BSDAddressingPolicyMixin<INet4SocketAddress>::connect;
        using BSDAddressingPolicyMixin<INet4SocketAddress>::bind;
    };

    struct INet6AddressingPolicy
        : public BSDAddressingPolicy,
          private BSDAddressingPolicyMixin<INet6SocketAddress>
    {
        typedef INet6SocketAddress Address;

        using BSDAddressingPolicyMixin<INet6SocketAddress>::peer;
        using BSDAddressingPolicyMixin<INet6SocketAddress>::local;
        using BSDAddressingPolicyMixin<INet6SocketAddress>::connect;
        using BSDAddressingPolicyMixin<INet6SocketAddress>::bind;
    };

    //\}

}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "INetAddressing.cci"
//#include "INetAddressing.ct"
//#include "INetAddressing.cti"
//#include "INetAddressing.mpp"
#endif

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