ip.hpp

Go to the documentation of this file.

#pragma once
#include <fc/string.hpp>
#include <fc/crypto/sha1.hpp>
#include <fc/io/raw_fwd.hpp>
#include <fc/crypto/city.hpp>
#include <fc/reflect/reflect.hpp>
 
namespace fc {
 
  namespace ip {
    class address {
      public:
        address( uint32_t _ip = 0 );
        address( const fc::string& s );
 
        address& operator=( const fc::string& s );
        operator fc::string()const;
        operator uint32_t()const;
 
        friend bool operator==( const address& a, const address& b );
        friend bool operator!=( const address& a, const address& b );
 
        bool is_private_address()const;
        bool is_multicast_address()const;
 
        bool is_public_address()const;
      private:
        uint32_t _ip;
    };
    
    class endpoint {
      public:
        endpoint();
        endpoint( const address& i, uint16_t p = 0);
 
        static endpoint from_string( const string& s );
        operator string()const;
 
        void           set_port(uint16_t p ) { _port = p; }
        uint16_t       port()const;
        const address& get_address()const;
 
        friend bool operator==( const endpoint& a, const endpoint& b );
        friend bool operator!=( const endpoint& a, const endpoint& b );
        friend bool operator< ( const endpoint& a, const endpoint& b );
    
      private:
        uint32_t _port; 
        address  _ip;
    };
 
  }
  class variant;
  void to_variant( const ip::endpoint& var,  variant& vo );
  void from_variant( const variant& var,  ip::endpoint& vo );
 
  void to_variant( const ip::address& var,  variant& vo );
  void from_variant( const variant& var,  ip::address& vo );
 
 
  namespace raw 
  {
    template<typename Stream> 
    inline void pack( Stream& s, const ip::address& v )
    {
       fc::raw::pack( s, uint32_t(v) );
    }
    template<typename Stream> 
    inline void unpack( Stream& s, ip::address& v )
    {
       uint32_t _ip;
       fc::raw::unpack( s, _ip );
       v = ip::address(_ip);
    }
 
    template<typename Stream> 
    inline void pack( Stream& s, const ip::endpoint& v )
    {
       fc::raw::pack( s, v.get_address() );
       fc::raw::pack( s, v.port() );
    }
    template<typename Stream> 
    inline void unpack( Stream& s, ip::endpoint& v )
    {
       ip::address a;
       uint16_t p;
       fc::raw::unpack( s, a );
       fc::raw::unpack( s, p );
       v = ip::endpoint(a,p);
    }
 
  }
} // namespace fc
FC_REFLECT_TYPENAME( fc::ip::address ) 
FC_REFLECT_TYPENAME( fc::ip::endpoint ) 
namespace std
{
    template<>
    struct hash<fc::ip::endpoint>
    {
       size_t operator()( const fc::ip::endpoint& e )const
       {
           return fc::city_hash_size_t( (char*)&e, sizeof(e) );
       }
    };
}