ipv6_address.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2001 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the conexus library.                             *
 *                                                                         *
 *   The conexus library is free software; you can redistribute it and/or  *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The conexus library 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 software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef CONEXUS_IPV6ADDRESS_H
#define CONEXUS_IPV6ADDRESS_H

#include <string>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <conexus/address.h>
#include <conexus/ipaddress_interface.h>
#include <conexus/except.h>

namespace Conexus
  {

    namespace IPv4 {
      class Address;
    }

  namespace IPv6
    {

      typedef enum IPV4_EMBEDDED_TYPE { IPV4_COMPATIBLE, IPV4_MAPPED } IPV4_EMBEDDED_TYPE;

      struct in6_addr operator&( const struct in6_addr& first, const struct in6_addr& second );

      struct in6_addr operator|( const struct in6_addr& first, const struct in6_addr& second );

      struct in6_addr operator^( const struct in6_addr& first, const struct in6_addr& second );

      struct in6_addr operator~( const struct in6_addr& addr );

      struct in6_addr& operator&=( struct in6_addr& first, const struct in6_addr& second );

      struct in6_addr& operator|=( struct in6_addr& first, const struct in6_addr& second );

      struct in6_addr& operator^=( struct in6_addr& first, const struct in6_addr& second );

      bool operator==( const struct in6_addr&, const struct in6_addr& );

      bool operator<( const struct in6_addr&, const struct in6_addr& );

      bool operator!=( const struct in6_addr&, const struct in6_addr& );

      class Address: public Conexus::Address, public virtual IPAddressInterface
      {
      public:

        static const struct in6_addr LOOPBACK;

        static const struct in6_addr IPV4_COMPATIBLE_PREFIX;

        static const struct in6_addr IPV4_MAPPED_PREFIX;

        typedef ConexusPointer<Address> pointer;

        Address(const struct in6_addr& host = in6addr_any, uint16_t port = 0);

        Address(uint32_t host, uint16_t port=0);

        Address(const std::string& host, uint16_t port=0);

        Address(const struct sockaddr_in6& addr);

        Address(const struct sockaddr_storage& addr);

        Address(const IPv4::Address& ipv4addr, IPV4_EMBEDDED_TYPE ipv4type = IPV4_MAPPED);

        static pointer create(const struct in6_addr& host = in6addr_any, uint16_t port = 0);

        static pointer create( uint32_t host, uint16_t port );

        static pointer create( const std::string& host, uint16_t port );

        static pointer create(const struct sockaddr_in6& addr);

        static pointer create(const struct sockaddr_storage& addr);

        static pointer create(const IPv4::Address& ipv4addr, IPV4_EMBEDDED_TYPE ipv4type = IPV4_MAPPED);

        virtual ~Address();

        struct in6_addr host() const;

        std::string host_string() const;

        struct in6_addr subnet_mask() const;

        std::string subnet_mask_string() const;

        unsigned prefix_length() const;

        std::string prefix_length_string() const;

        std::string host_subnet_mask_string() const;

        std::string cidr_host_string() const;

        struct in6_addr prefix() const;

        std::string prefix_string() const;

        struct in6_addr local_address() const;

        std::string local_address_string() const;

        uint16_t port() const;

        std::string port_string() const;

        void set_host(const struct in6_addr& host);

        void set_host(const std::string& host);

        virtual void set_host(const std::string& host, uint16_t port);

        void set_host(uint32_t host, IPV4_EMBEDDED_TYPE type=IPV4_MAPPED);

        void set_host_prefix_length(uint32_t host, unsigned prefix_length, IPV4_EMBEDDED_TYPE type=IPV4_MAPPED);

        void set_prefix_length(unsigned prefix_length);

        void set_prefix_length(const std::string& prefix_length);

        void set_port(uint16_t port);

        void set_port(const std::string& port);

        uint32_t flowinfo();

        void set_flowinfo( uint32_t f );

        uint32_t scope_id();

        void set_scope_id( uint32_t sid );

        std::string hostname() const;

        std::string servicename() const;

        bool is_reserved() const;

        bool is_nsap() const;

        bool is_ipx() const;

        bool is_aggregatable_global() const;

        bool is_link_local() const;

        bool is_site_local() const;

        bool is_multicast() const;

        bool is_multicast_interface_local() const;

        bool is_multicast_link_local() const;

        bool is_multicast_site_local() const;

        bool is_multicast_organization_local() const;

        bool is_multicast_global() const;

        bool is_any() const;

        bool is_loopback() const;

        bool is_ipv4() const;

        bool is_ipv4_compatible() const;

        bool is_ipv4_mapped() const;

        socklen_t sockaddr_size() const;

        struct sockaddr_in6& sockaddr_in();

        struct sockaddr_in6* sockaddr_in_ptr();

        operator struct sockaddr_in6*();

        Address& operator=(const Address& other);

        Address& operator=( const Conexus::Address& other );

        bool operator==(const Address& other);

        virtual bool is_ipv4() { return this->is_ipv4_compatible(); }

        virtual bool is_ipv6() { return true; }

        virtual sigc::signal<void>& signal_changed( );

        virtual sigc::signal<void>& signal_host_changed( );

        virtual sigc::signal<void>& signal_port_changed( );

        virtual sigc::signal<void>& signal_flowinfo_changed( );

        virtual sigc::signal<void>& signal_scope_id_changed( );

        virtual sigc::signal<void>& signal_prefix_changed( );

        protected:
          struct in6_addr m_host;

          uint16_t m_port;

          uint32_t m_flowinfo;

          uint32_t m_scope_id;

          unsigned m_prefix_length;

          sigc::signal<void> m_signal_changed;

          sigc::signal<void> m_signal_host_changed;

          sigc::signal<void> m_signal_port_changed;

          sigc::signal<void> m_signal_flowinfo_changed;

          sigc::signal<void> m_signal_scope_id_changed;

          sigc::signal<void> m_signal_prefix_changed;
      };

      std::string host_to_string(const struct in6_addr&);

      struct in6_addr string_to_host(const std::string&);

      void string_to_host_prefix(const std::string&, struct in6_addr& host, int& prefix);

      bool is_valid_hostname(const std::string&);

      std::string host_to_hostname( const struct in6_addr& host ) throw (address_exception);

      std::string service_to_servicename( uint16_t service ) throw (address_exception);

      struct in6_addr hostname_to_host( const std::string& hostname ) throw (address_exception);

      uint16_t servicename_to_service( const std::string& servicename ) throw (address_exception);

      bool validate_subnet_mask( const struct in6_addr& subnet_mask ) throw();

      struct in6_addr create_subnet_mask(unsigned prefix_length);

  }

}

#endif