aboutsummaryrefslogblamecommitdiffstats
path: root/rpc/http.go
blob: c5bb10c80cb12a7999a889332cd9aff2381d64ee (plain) (tree)
1
2
3
4
5
6
7
8
9
10


           
                       
             
            
                   


                                                
                                                     
                                              
                            

 
                                     
 




                                             
                                                     




                                                                                                                 

         
                                                                                                        
                       
                                                                                                                     

                          
                       







                                                                 
                                                                               
                
                                                                    



                                 


                  
                   


                                  

         


                  
                                                                       

                                            

                                                                                
                                                                  
 
                                                   
                                                         
                                                                               
                                                                                                


                              
                                    



                                                                                         
                                                                                                

                 



                                                                        
                                          
                              










                                                                       
                                         


                              

                                                                              
                                                                                        

          





                                                                      
                                                                                                  
                                                      
                                                                  
                                                                                                 
                                                                                              
                                                                  
                                                                                                 

                                                                  
                                                                                                 

         
                                                                                    

                        
 
                                                               


                                                      
                                                                          

                             
                                                                   


                                    
package rpc

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

    "github.com/ethereum/go-ethereum/logger"
    "github.com/ethereum/go-ethereum/logger/glog"
    "github.com/ethereum/go-ethereum/xeth"
    "github.com/rs/cors"
)

var rpclistener *stoppableTCPListener

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

func Start(pipe *xeth.XEth, config RpcConfig) error {
    if rpclistener != nil {
        if fmt.Sprintf("%s:%d", config.ListenAddress, config.ListenPort) != rpclistener.Addr().String() {
            return fmt.Errorf("RPC service already running on %s ", rpclistener.Addr().String())
        }
        return nil // RPC service already running on given host/port
    }

    l, err := newStoppableTCPListener(fmt.Sprintf("%s:%d", config.ListenAddress, config.ListenPort))
    if err != nil {
        glog.V(logger.Error).Infof("Can't listen on %s:%d: %v", config.ListenAddress, config.ListenPort, err)
        return err
    }
    rpclistener = l

    var handler http.Handler
    if len(config.CorsDomain) > 0 {
        var opts cors.Options
        opts.AllowedMethods = []string{"POST"}
        opts.AllowedOrigins = []string{config.CorsDomain}

        c := cors.New(opts)
        handler = newStoppableHandler(c.Handler(JSONRPC(pipe)), l.stop)
    } else {
        handler = newStoppableHandler(JSONRPC(pipe), l.stop)
    }

    go http.Serve(l, handler)

    return nil
}

func Stop() error {
    if rpclistener != nil {
        rpclistener.Stop()
        rpclistener = nil
    }

    return nil
}

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

    return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
        w.Header().Set("Content-Type", "application/json")

        // 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, *NotAvailableError:
        jsonerr := &RpcErrorObject{-32601, reserr.Error()}
        response = &RpcErrorResponse{Jsonrpc: jsonrpcver, Id: request.Id, Error: jsonerr}
    case *DecodeParamError, *InsufficientParamsError, *ValidationError, *InvalidTypeError:
        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}
    }

    glog.V(logger.Detail).Infof("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 {
        glog.V(logger.Error).Infoln("Error marshalling JSON", err)
        return 0, err
    }
    glog.V(logger.Detail).Infof("Sending payload: %s", payload)

    return writer.Write(payload)
}