aboutsummaryrefslogtreecommitdiffstats
path: root/rpc/http.go
blob: bf281efc31039e94df36322096f3f35949ddc8a1 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
package rpc

import (
    "encoding/json"
    "io"
    "io/ioutil"
    "net/http"

    "github.com/ethereum/go-ethereum/logger"
    "github.com/ethereum/go-ethereum/xeth"
)

var rpclogger = logger.NewLogger("RPC")

const (
    jsonrpcver       = "2.0"
    maxSizeReqLength = 1024 * 1024 // 1MB
)

// JSONRPC returns a handler that implements the Ethereum JSON-RPC API.
func JSONRPC(pipe *xeth.XEth, dataDir string) http.Handler {
    api := NewEthereumApi(pipe, dataDir)

    return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
        // TODO this needs to be configurable
        w.Header().Set("Access-Control-Allow-Origin", "*")

        // Limit request size to resist DoS
        if req.ContentLength > maxSizeReqLength {
            jsonerr := &RpcErrorObject{-32700, "Request too large"}
            Send(w, &RpcErrorResponse{Jsonrpc: jsonrpcver, Id: nil, Error: jsonerr})
            return
        }

        // Read request body
        defer req.Body.Close()
        body, err := ioutil.ReadAll(req.Body)
        if err != nil {
            jsonerr := &RpcErrorObject{-32700, "Could not read request body"}
            Send(w, &RpcErrorResponse{Jsonrpc: jsonrpcver, Id: nil, Error: jsonerr})
        }

        // Try to parse the request as a single
        var reqSingle RpcRequest
        if err := json.Unmarshal(body, &reqSingle); err == nil {
            response := RpcResponse(api, &reqSingle)
            Send(w, &response)
            return
        }

        // Try to parse the request to batch
        var reqBatch []RpcRequest
        if err := json.Unmarshal(body, &reqBatch); err == nil {
            // Build response batch
            resBatch := make([]*interface{}, len(reqBatch))
            for i, request := range reqBatch {
                response := RpcResponse(api, &request)
                resBatch[i] = response
            }
            Send(w, resBatch)
            return
        }

        // Not a batch or single request, error
        jsonerr := &RpcErrorObject{-32600, "Could not decode request"}
        Send(w, &RpcErrorResponse{Jsonrpc: jsonrpcver, Id: nil, Error: jsonerr})
    })
}

func RpcResponse(api *EthereumApi, request *RpcRequest) *interface{} {
    var reply, response interface{}
    reserr := api.GetRequestReply(request, &reply)
    switch reserr.(type) {
    case nil:
        response = &RpcSuccessResponse{Jsonrpc: jsonrpcver, Id: request.Id, Result: reply}
    case *NotImplementedError:
        jsonerr := &RpcErrorObject{-32601, reserr.Error()}
        response = &RpcErrorResponse{Jsonrpc: jsonrpcver, Id: request.Id, Error: jsonerr}
    case *DecodeParamError, *InsufficientParamsError, *ValidationError:
        jsonerr := &RpcErrorObject{-32602, reserr.Error()}
        response = &RpcErrorResponse{Jsonrpc: jsonrpcver, Id: request.Id, Error: jsonerr}
    default:
        jsonerr := &RpcErrorObject{-32603, reserr.Error()}
        response = &RpcErrorResponse{Jsonrpc: jsonrpcver, Id: request.Id, Error: jsonerr}
    }

    rpclogger.DebugDetailf("Generated response: %T %s", response, response)
    return &response
}

func Send(writer io.Writer, v interface{}) (n int, err error) {
    var payload []byte
    payload, err = json.MarshalIndent(v, "", "\t")
    if err != nil {
        rpclogger.Fatalln("Error marshalling JSON", err)
        return 0, err
    }
    rpclogger.DebugDetailf("Sending payload: %s", payload)

    return writer.Write(payload)
}