ipv4_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_IPV4ADDRESS_H
#define CONEXUS_IPV4ADDRESS_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 IPv6
  {
    class Address;
  }

  namespace IPv4
  {

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

        typedef ConexusPointer<Address> pointer;

        Address( uint32_t host = INADDR_ANY, uint16_t port = 0 );

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

        Address( const struct sockaddr_in& addr );

        Address( const struct sockaddr_storage& addr );

        Address( const struct sockaddr& addr );

        Address( const IPv6::Address& addr );

        static pointer create( uint32_t host = INADDR_ANY, uint16_t port = 0 );

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

        static pointer create( const struct sockaddr_in& addr );

        static pointer create( const struct sockaddr_storage& addr );

        static pointer create( const struct sockaddr& addr );

        static pointer create( const IPv6::Address& ipv6addr );

        virtual ~Address();

        uint32_t host() const;

        std::string host_string() const;

        uint32_t 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;

        uint32_t prefix() const;

        std::string prefix_string() const;

        uint32_t broadcast_address() const;

        std::string broadcast_address_string() const;

        uint32_t local_address() const;

        std::string local_address_string() const;

        uint16_t port() const;

        std::string port_string() const;

        void set_host( uint32_t host );

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

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

        void set_host_subnet_mask( uint32_t host, uint32_t subnet_mask );

        void set_host_prefix_length( uint32_t host, unsigned prefix_length );

        void set_subnet_mask( uint32_t subnet_mask );

        void set_subnet_mask( const std::string& subnet_mask );

        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 );

        bool is_valid_hostname( const std::string& ) const;

        std::string hostname() const;

        std::string servicename() const;

        bool is_private() const;

        bool is_reserved() const;

        bool is_loopback() const;

        bool is_broadcast() const;

        bool is_multicast() const;

        bool is_any() const;

        socklen_t sockaddr_size() const;

        struct sockaddr_in& sockaddr_in();

        struct sockaddr_in* sockaddr_in_ptr();

        operator struct sockaddr_in*();

        Address& operator=( const Address& other );

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

        bool operator==( const Address& other ) const;

        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_prefix_changed( );

        virtual bool is_ipv4();

        virtual bool is_ipv6();

      protected:
        uint32_t m_host;

        uint16_t m_port;

        unsigned m_prefix_length;

        sigc::signal<void> m_signal_host_changed;

        sigc::signal<void> m_signal_port_changed;

        sigc::signal<void> m_signal_prefix_changed;

        sigc::signal<void> m_signal_changed;

    };

    std::string host_to_string( uint32_t );

    uint32_t string_to_host( const std::string& );

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

    bool is_valid_hostname( const std::string& );

    std::string host_to_hostname( uint32_t host ) throw ( address_exception );

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

    uint32_t 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( uint32_t subnet_mask ) throw();

    uint32_t create_subnet_mask( unsigned prefix_length );

    unsigned subnet_mask_length( uint32_t subnet_mask ) throw();

  }

}

#endif