gaddress.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// 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 3 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, see <http://www.gnu.org/licenses/>.
// ===

#ifndef G_ADDRESS_H
#define G_ADDRESS_H

#include "gdef.h"
#include "gnet.h"
#include "gstrings.h"
#include "gexception.h"
#include <string>

namespace GNet
{
        class Address ;
        class AddressStorage ;
        class AddressImp ;
        class AddressStorageImp ;
}

class GNet::Address 
{
public:
        G_EXCEPTION( Error , "address error" ) ;
        G_EXCEPTION( BadFamily , "unsupported address family" ) ;
        G_EXCEPTION( BadString , "invalid ip address string" ) ;
        class Localhost 
                {} ;
        class Broadcast 
                {} ;

        static int defaultDomain() ;

        Address( const Address & addr ) ;

        explicit Address( const AddressStorage & ) ;

        Address( const sockaddr * addr , socklen_t len ) ;

        Address( const hostent & h , unsigned int port ) ;

        Address( const hostent & h , const servent & s ) ;

        explicit Address( const servent & s ) ;

        explicit Address( unsigned int port ) ;

        Address( unsigned int port , Localhost ) ;

        Address( unsigned int port , Broadcast ) ;

        explicit Address( const std::string & display_string ) ;

        Address( const std::string & ip , unsigned int port ) ;

        ~Address() ;

        static Address invalidAddress() ;

        static Address broadcastAddress( unsigned int port ) ;

        static Address localhost( unsigned int port = 0U ) ;

        void operator=( const Address &addr ) ;

        const sockaddr * address() const ;

        sockaddr * address() ;

        socklen_t length() const;

        std::string displayString( bool with_port = true , bool with_scope_id = false ) const ;

        std::string hostString() const ;

        unsigned int port() const;

        int domain() const ;

        unsigned long scopeId( unsigned long default_ = 0UL ) const ;

        static bool validPort( unsigned int n ) ;

        static bool validString( const std::string & display_string , std::string * reason = NULL ) ;

        bool sameHost( const Address &other ) const ;

        bool isLocal( std::string & reason ) const ;

        bool isLocal( std::string & reason , const Address & local_hint ) const ;

        void setPort( unsigned int port ) ;

        G::Strings wildcards() const ;

        bool operator==( const Address & ) const ;

private:
        void setHost( const hostent & ) ;

private:
        AddressImp * m_imp ;
} ;

class GNet::AddressStorage 
{
public:
        AddressStorage() ;

        ~AddressStorage() ;

        sockaddr * p1() ;

        socklen_t * p2() ;

        const sockaddr * p() const ;

        socklen_t n() const ;

private:
        AddressStorage( const AddressStorage & ) ;
        void operator=( const AddressStorage & ) ;

private:
        AddressStorageImp * m_imp ;
} ;

#endif