Merge remote-tracking branch 'upstream/phoenix' into http-server-improvements

include/fc/io/datastream.hpp

@@ -7,7 +7,7 @@ namespace fc {
 
 namespace detail 
 {
-  NO_RETURN void throw_datastream_range_error( const char* file, size_t len, size_t over );
+  NO_RETURN void throw_datastream_range_error( const char* file, size_t len, int64_t over );
 }
 
 /**

include/fc/io/enum_type.hpp

@@ -50,7 +50,7 @@ namespace fc
   template<typename IntType, typename EnumType>
   void to_variant( const enum_type<IntType,EnumType>& var,  variant& vo )
   {
-    vo = var.value;
+    vo = (EnumType)var.value;
   }
   template<typename IntType, typename EnumType>
   void from_variant( const variant& var,  enum_type<IntType,EnumType>& vo )

include/fc/io/json.hpp

@@ -26,6 +26,8 @@ namespace fc
          static string   to_string( const variant& v );
          static string   to_pretty_string( const variant& v );
 
+         static bool     is_valid( const std::string& json_str );
+
          template<typename T>
          static void     save_to_file( const T& v, const fc::path& fi, bool pretty = true )
          {

include/fc/io/varint.hpp

@@ -33,10 +33,12 @@ struct unsigned_int {
  *  Uses the google protobuf algorithm for seralizing signed numbers
  */
 struct signed_int {
-    signed_int( int32_t v = 0 ):value(v){}
+    signed_int( int64_t v = 0 ):value(v){}
     operator int32_t()const { return value; }
     template<typename T>
     signed_int& operator=( const T& v ) { value = v; return *this; }
+    signed_int& operator++(int){ ++value; return *this; }
+    signed_int& operator++(){ ++value; return *this; }
 
     int32_t value;
 };
@@ -50,4 +52,16 @@ void from_variant( const variant& var,  unsigned_int& vo );
 
 }  // namespace fc
 
-
+#include <unordered_map>
+namespace std
+{
+   template<>
+   struct hash<fc::signed_int>
+   {
+       public:
+         size_t operator()(const fc::signed_int &a) const 
+         {
+            return std::hash<int32_t>()(a.value);
+         }
+   };
+}

include/fc/reflect/typename.hpp

@@ -21,4 +21,9 @@ namespace fc {
   template<> struct get_typename<value>   { static const char* name()   { return "value";   } };
   template<> struct get_typename<std::vector<char>>   { static const char* name()   { return "std::vector<char>";   } };
 
+  struct signed_int;
+  struct unsigned_int;
+  template<> struct get_typename<signed_int>   { static const char* name()   { return "signed_int";   } };
+  template<> struct get_typename<unsigned_int>   { static const char* name()   { return "unsigned_int";   } };
+
 }

src/io/datastream.cpp

@@ -1,7 +1,7 @@
 #include <fc/io/datastream.hpp>
 #include <fc/exception/exception.hpp>
 
-NO_RETURN void fc::detail::throw_datastream_range_error(char const* method, size_t len, size_t over)
+NO_RETURN void fc::detail::throw_datastream_range_error(char const* method, size_t len, int64_t over)
 {
   FC_THROW_EXCEPTION( out_of_range_exception, "${method} datastream of length ${len} over by ${over}", ("method",fc::string(method))("len",len)("over",over) );
 }

src/io/json.cpp

@@ -640,4 +640,14 @@ namespace fc
       return out;
    }
 
+   bool     json::is_valid( const std::string& utf8_str )
+   {
+      if( utf8_str.size() == 0 ) return false;
+      fc::stringstream in( utf8_str );
+      variant_from_stream( in );
+      try { in.peek(); } catch ( const eof_exception& e ) { return true; }
+      return false;
+   }
+
+
 } // fc

src/network/tcp_socket.cpp

@@ -110,19 +110,19 @@ namespace fc {
       // This should work for modern Linuxes and for OSX >= Mountain Lion
       int timeout_sec = interval.count() / fc::seconds(1).count();
       if (setsockopt(my->_sock.native(), IPPROTO_TCP, 
-       #if defined( __APPLE__ )
+      #if defined( __APPLE__ )
                      TCP_KEEPALIVE,
        #else
                      TCP_KEEPIDLE, 
        #endif
                      (char*)&timeout_sec, sizeof(timeout_sec)) < 0)
         wlog("Error setting TCP keepalive idle time");
-      #ifndef __APPLE__ // TCP_KEEPINTVL does not seem to work on 10.8.4
+# if !defined(__APPLE__) || defined(TCP_KEEPINTVL) // TCP_KEEPINTVL not defined before 10.9
       if (setsockopt(my->_sock.native(), IPPROTO_TCP, TCP_KEEPINTVL, 
                      (char*)&timeout_sec, sizeof(timeout_sec)) < 0)
         wlog("Error setting TCP keepalive interval");
-      #endif // !__APPLE__
-#endif
+# endif // !__APPLE__ || TCP_KEEPINTVL
+#endif // !WIN32
     }
     else
     {

src/rpc/json_connection.cpp

@@ -35,7 +35,7 @@ namespace fc { namespace rpc {
 
             void send_result( variant id, variant result )
             {
-               ilog( "send ${i} ${r}", ("i",id)("r",result) );
+               ilog( "send: {\"id\": ${i}, \"result\": ${r}}", ("i",id)("r",result) );
                {
                  fc::scoped_lock<fc::mutex> lock(_write_mutex);
                  *_out << "{\"id\":";
@@ -48,6 +48,8 @@ namespace fc { namespace rpc {
             }
             void send_error( variant id, fc::exception& e )
             {
+               ilog( "send: {\"id\": ${i}, \"error\":{\"message\": ${what},\"code\":0,\"data\":${data}}}",
+                     ("i",id)("what",e.what())("data", e) );
                {
                  fc::scoped_lock<fc::mutex> lock(_write_mutex);
                  *_out << "{\"id\":";