INetAddressing.hh

Go to the documentation of this file.

// $Id: INetAddressing.hh 1742 2010-11-04 14:51:56Z g0dil $
//
// Copyright (C) 2006
// Fraunhofer (FOKUS)
// Competence Center NETwork research (NET), St. Augustin, GERMANY
//     Stefan Bund <g0dil@berlios.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

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