rpcprotocol.h

#ifndef RPCPROTOCOL_H
#define RPCPROTOCOL_H

#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/stream.hpp>

#include <json_spirit/json_spirit.h>

#ifdef WIN32
#include <SDKDDKVer.h>
#endif
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>


enum HTTPStatusCode
{
    HTTP_OK                    = 200,
    HTTP_BAD_REQUEST           = 400,
    HTTP_UNAUTHORIZED          = 401,
    HTTP_FORBIDDEN             = 403,
    HTTP_NOT_FOUND             = 404,
    HTTP_INTERNAL_SERVER_ERROR = 500,
    HTTP_SERVICE_UNAVAILABLE   = 503,
};

enum RPCErrorCode
{
    RPC_INVALID_REQUEST  = -32600,
    RPC_METHOD_NOT_FOUND = -32601,
    RPC_INVALID_PARAMS   = -32602,
    RPC_INTERNAL_ERROR   = -32603,
    RPC_PARSE_ERROR      = -32700,

    RPC_MISC_ERROR                  = -1,  
    RPC_FORBIDDEN_BY_SAFE_MODE      = -2,  
    RPC_TYPE_ERROR                  = -3,  
    RPC_INVALID_ADDRESS_OR_KEY      = -5,  
    RPC_OUT_OF_MEMORY               = -7,  
    RPC_INVALID_PARAMETER           = -8,  
    RPC_DATABASE_ERROR              = -20, 
    RPC_DESERIALIZATION_ERROR       = -22, 
    RPC_VERIFY_ERROR                = -25, 
    RPC_VERIFY_REJECTED             = -26, 
    RPC_VERIFY_ALREADY_IN_CHAIN     = -27, 
    RPC_IN_WARMUP                   = -28, 

    RPC_TRANSACTION_ERROR           = RPC_VERIFY_ERROR,
    RPC_TRANSACTION_REJECTED        = RPC_VERIFY_REJECTED,
    RPC_TRANSACTION_ALREADY_IN_CHAIN= RPC_VERIFY_ALREADY_IN_CHAIN,

    RPC_CLIENT_NOT_CONNECTED        = -9,  
    RPC_CLIENT_IN_INITIAL_DOWNLOAD  = -10, 
    RPC_CLIENT_NODE_ALREADY_ADDED   = -23, 
    RPC_CLIENT_NODE_NOT_ADDED       = -24, 

    RPC_WALLET_ERROR                = -4,  
    RPC_WALLET_INSUFFICIENT_FUNDS   = -6,  
    RPC_WALLET_INVALID_ACCOUNT_NAME = -11, 
    RPC_WALLET_KEYPOOL_RAN_OUT      = -12, 
    RPC_WALLET_UNLOCK_NEEDED        = -13, 
    RPC_WALLET_PASSPHRASE_INCORRECT = -14, 
    RPC_WALLET_WRONG_ENC_STATE      = -15, 
    RPC_WALLET_ENCRYPTION_FAILED    = -16, 
    RPC_WALLET_ALREADY_UNLOCKED     = -17, 


    RPC_NOT_ALLOWED                 = -701,  
    RPC_NOT_SUPPORTED               = -702,  
    RPC_NOT_SUBSCRIBED              = -703,  
    RPC_INSUFFICIENT_PERMISSIONS    = -704,  
    RPC_DUPLICATE_NAME              = -705,  
    RPC_UNCONFIRMED_ENTITY          = -706,  
    RPC_EXCHANGE_ERROR              = -707,  
    RPC_ENTITY_NOT_FOUND            = -708,  
    RPC_WALLET_ADDRESS_NOT_FOUND    = -709,  
    RPC_TX_NOT_FOUND                = -710,  
    RPC_BLOCK_NOT_FOUND             = -711,  
    RPC_OUTPUT_NOT_FOUND            = -712,  
    RPC_OUTPUT_NOT_DATA             = -713,  
    RPC_INPUTS_NOT_MINE             = -714,  
    RPC_WALLET_OUTPUT_NOT_FOUND     = -715,  
    RPC_WALLET_NO_UNSPENT_OUTPUTS   = -716,  
    RPC_GENERAL_FILE_ERROR          = -717,  
    RPC_UPGRADE_REQUIRED            = -718,  

};

template <typename Protocol>
class SSLIOStreamDevice : public boost::iostreams::device<boost::iostreams::bidirectional> {
public:
    SSLIOStreamDevice(boost::asio::ssl::stream<typename Protocol::socket> &streamIn, bool fUseSSLIn) : stream(streamIn)
    {
        fUseSSL = fUseSSLIn;
        fNeedHandshake = fUseSSLIn;
    }

    void handshake(boost::asio::ssl::stream_base::handshake_type role)
    {
        if (!fNeedHandshake) return;
        fNeedHandshake = false;
        stream.handshake(role);
    }
    std::streamsize read(char* s, std::streamsize n)
    {
        handshake(boost::asio::ssl::stream_base::server); // HTTPS servers read first
        if (fUseSSL) return stream.read_some(boost::asio::buffer(s, n));
        return stream.next_layer().read_some(boost::asio::buffer(s, n));
    }
    std::streamsize write(const char* s, std::streamsize n)
    {
        handshake(boost::asio::ssl::stream_base::client); // HTTPS clients write first
        if (fUseSSL) return boost::asio::write(stream, boost::asio::buffer(s, n));
        return boost::asio::write(stream.next_layer(), boost::asio::buffer(s, n));
    }
    bool connect(const std::string& server, const std::string& port)
    {
        using namespace boost::asio::ip;
        tcp::resolver resolver(stream.get_io_service());
        tcp::resolver::iterator endpoint_iterator;
#if BOOST_VERSION >= 104300
        try {
#endif
            // The default query (flags address_configured) tries IPv6 if
            // non-localhost IPv6 configured, and IPv4 if non-localhost IPv4
            // configured.
            tcp::resolver::query query(server.c_str(), port.c_str());
            endpoint_iterator = resolver.resolve(query);
#if BOOST_VERSION >= 104300
        } catch(boost::system::system_error &)
        {
            // If we at first don't succeed, try blanket lookup (IPv4+IPv6 independent of configured interfaces)
            tcp::resolver::query query(server.c_str(), port.c_str(), resolver_query_base::flags());
            endpoint_iterator = resolver.resolve(query);
        }
#endif
        boost::system::error_code error = boost::asio::error::host_not_found;
        tcp::resolver::iterator end;
        while (error && endpoint_iterator != end)
        {
            stream.lowest_layer().close();
            stream.lowest_layer().connect(*endpoint_iterator++, error);
        }
        if (error)
            return false;
        return true;
    }

private:
    bool fNeedHandshake;
    bool fUseSSL;
    boost::asio::ssl::stream<typename Protocol::socket>& stream;
};

std::string JSONRPCRequest(const std::string& strMethod, const json_spirit::Array& params, const json_spirit::Value& id, const std::string &chaninName = "hdac");
std::string HTTPPost(const std::string& strMsg, const std::map<std::string,std::string>& mapRequestHeaders);
int ReadHTTPStatus(std::basic_istream<char>& stream, int &proto);
int ReadHTTPMessage(std::basic_istream<char>& stream, std::map<std::string, std::string>& mapHeadersRet,
                    std::string& strMessageRet, int nProto, size_t max_size);
#endif // RPCPROTOCOL_H