ip.hpp

Go to the documentation of this file.

#pragma once
#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:
        explicit address( uint32_t ip = 0 );
        explicit address( const std::string& s );

        address& operator=( const std::string& s );
        address& operator=( uint32_t ip );
        explicit operator std::string()const;
        // Note: there are quite a few places where it is used implicitly, so we haven't marked it as explicit so far.
        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_loopback_address()const;

        bool is_public_address()const;
      private:
        uint32_t _ip;
    };

    class endpoint {
      public:
        endpoint() = default;
        explicit endpoint( const address& i, uint16_t p = 0);
        explicit endpoint( uint32_t i, uint16_t p = 0);

        static endpoint from_string( const string& s );
        explicit 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 = 0;
        address  _ip;
    };

  }
  class variant;
  void to_variant( const ip::endpoint& var,  variant& vo, uint32_t _max_depth = 2 );
  void from_variant( const variant& var,  ip::endpoint& vo, uint32_t _max_depth = 2 );

  void to_variant( const ip::address& var,  variant& vo, uint32_t _max_depth = 1 );
  void from_variant( const variant& var,  ip::address& vo, uint32_t _max_depth = 1 );


  namespace raw
  {
    template<typename Stream>
    void pack( Stream& s, const ip::address& v, uint32_t _max_depth=FC_PACK_MAX_DEPTH )
    {
       FC_ASSERT( _max_depth > 0 );
       fc::raw::pack( s, uint32_t(v), _max_depth - 1 );
    }
    template<typename Stream>
    void unpack( Stream& s, ip::address& v, uint32_t _max_depth=FC_PACK_MAX_DEPTH )
    {
       FC_ASSERT( _max_depth > 0 );
       uint32_t _ip;
       fc::raw::unpack( s, _ip, _max_depth - 1 );
       v = ip::address(_ip);
    }

    template<typename Stream>
    inline void pack( Stream& s, const ip::endpoint& v, uint32_t _max_depth )
    {
       FC_ASSERT( _max_depth > 0 );
       --_max_depth;
       fc::raw::pack( s, v.get_address(), _max_depth );
       fc::raw::pack( s, v.port(), _max_depth );
    }
    template<typename Stream>
    inline void unpack( Stream& s, ip::endpoint& v, uint32_t _max_depth )
    {
       FC_ASSERT( _max_depth > 0 );
       --_max_depth;
       ip::address a;
       uint16_t p;
       fc::raw::unpack( s, a, _max_depth );
       fc::raw::unpack( s, p, _max_depth );
       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) );
       }
    };
}