path: root/rpc/json.go

// Copyright 2015 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package rpc

import (
    "encoding/json"
    "fmt"
    "io"
    "reflect"
    "strconv"
    "strings"
    "sync"

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

const (
    JSONRPCVersion         = "2.0"
    serviceMethodSeparator = "_"
    subscribeMethod        = "eth_subscribe"
    unsubscribeMethod      = "eth_unsubscribe"
    notificationMethod     = "eth_subscription"
)

// JSON-RPC request
type JSONRequest struct {
    Method  string          `json:"method"`
    Version string          `json:"jsonrpc"`
    Id      json.RawMessage `json:"id,omitempty"`
    Payload json.RawMessage `json:"params,omitempty"`
}

// JSON-RPC response
type JSONSuccessResponse struct {
    Version string      `json:"jsonrpc"`
    Id      interface{} `json:"id,omitempty"`
    Result  interface{} `json:"result"`
}

// JSON-RPC error object
type JSONError struct {
    Code    int         `json:"code"`
    Message string      `json:"message"`
    Data    interface{} `json:"data,omitempty"`
}

// JSON-RPC error response
type JSONErrResponse struct {
    Version string      `json:"jsonrpc"`
    Id      interface{} `json:"id,omitempty"`
    Error   JSONError   `json:"error"`
}

// JSON-RPC notification payload
type jsonSubscription struct {
    Subscription string      `json:"subscription"`
    Result       interface{} `json:"result,omitempty"`
}

// JSON-RPC notification
type jsonNotification struct {
    Version string           `json:"jsonrpc"`
    Method  string           `json:"method"`
    Params  jsonSubscription `json:"params"`
}

// jsonCodec reads and writes JSON-RPC messages to the underlying connection. It
// also has support for parsing arguments and serializing (result) objects.
type jsonCodec struct {
    closer sync.Once          // close closed channel once
    closed chan interface{}   // closed on Close
    decMu  sync.Mutex         // guards d
    d      *json.Decoder      // decodes incoming requests
    encMu  sync.Mutex         // guards e
    e      *json.Encoder      // encodes responses
    rw     io.ReadWriteCloser // connection
}

// NewJSONCodec creates a new RPC server codec with support for JSON-RPC 2.0
func NewJSONCodec(rwc io.ReadWriteCloser) ServerCodec {
    d := json.NewDecoder(rwc)
    d.UseNumber()
    return &jsonCodec{closed: make(chan interface{}), d: d, e: json.NewEncoder(rwc), rw: rwc}
}

// isBatch returns true when the first non-whitespace characters is '['
func isBatch(msg json.RawMessage) bool {
    for _, c := range msg {
        // skip insignificant whitespace (http://www.ietf.org/rfc/rfc4627.txt)
        if c == 0x20 || c == 0x09 || c == 0x0a || c == 0x0d {
            continue
        }
        return c == '['
    }
    return false
}

// ReadRequestHeaders will read new requests without parsing the arguments. It will
// return a collection of requests, an indication if these requests are in batch
// form or an error when the incoming message could not be read/parsed.
func (c *jsonCodec) ReadRequestHeaders() ([]rpcRequest, bool, RPCError) {
    c.decMu.Lock()
    defer c.decMu.Unlock()

    var incomingMsg json.RawMessage
    if err := c.d.Decode(&incomingMsg); err != nil {
        return nil, false, &invalidRequestError{err.Error()}
    }

    if isBatch(incomingMsg) {
        return parseBatchRequest(incomingMsg)
    }

    return parseRequest(incomingMsg)
}

// checkReqId returns an error when the given reqId isn't valid for RPC method calls.
// valid id's are strings, numbers or null
func checkReqId(reqId json.RawMessage) error {
    if len(reqId) == 0 {
        return fmt.Errorf("missing request id")
    }
    if _, err := strconv.ParseFloat(string(reqId), 64); err == nil {
        return nil
    }
    var str string
    if err := json.Unmarshal(reqId, &str); err == nil {
        return nil
    }
    return fmt.Errorf("invalid request id")
}

// parseRequest will parse a single request from the given RawMessage. It will return
// the parsed request, an indication if the request was a batch or an error when
// the request could not be parsed.
func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, RPCError) {
    var in JSONRequest
    if err := json.Unmarshal(incomingMsg, &in); err != nil {
        return nil, false, &invalidMessageError{err.Error()}
    }

    if err := checkReqId(in.Id); err != nil {
        return nil, false, &invalidMessageError{err.Error()}
    }

    // subscribe are special, they will always use `subscribeMethod` as first param in the payload
    if in.Method == subscribeMethod {
        reqs := []rpcRequest{rpcRequest{id: &in.Id, isPubSub: true}}
        if len(in.Payload) > 0 {
            // first param must be subscription name
            var subscribeMethod [1]string
            if err := json.Unmarshal(in.Payload, &subscribeMethod); err != nil {
                glog.V(logger.Debug).Infof("Unable to parse subscription method: %v\n", err)
                return nil, false, &invalidRequestError{"Unable to parse subscription request"}
            }

            // all subscriptions are made on the eth service
            reqs[0].service, reqs[0].method = "eth", subscribeMethod[0]
            reqs[0].params = in.Payload
            return reqs, false, nil
        }
        return nil, false, &invalidRequestError{"Unable to parse subscription request"}
    }

    if in.Method == unsubscribeMethod {
        return []rpcRequest{rpcRequest{id: &in.Id, isPubSub: true,
            method: unsubscribeMethod, params: in.Payload}}, false, nil
    }

    elems := strings.Split(in.Method, serviceMethodSeparator)
    if len(elems) != 2 {
        return nil, false, &methodNotFoundError{in.Method, ""}
    }

    // regular RPC call
    if len(in.Payload) == 0 {
        return []rpcRequest{rpcRequest{service: elems[0], method: elems[1], id: &in.Id}}, false, nil
    }

    return []rpcRequest{rpcRequest{service: elems[0], method: elems[1], id: &in.Id, params: in.Payload}}, false, nil
}

// parseBatchRequest will parse a batch request into a collection of requests from the given RawMessage, an indication
// if the request was a batch or an error when the request could not be read.
func parseBatchRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, RPCError) {
    var in []JSONRequest
    if err := json.Unmarshal(incomingMsg, &in); err != nil {
        return nil, false, &invalidMessageError{err.Error()}
    }

    requests := make([]rpcRequest, len(in))
    for i, r := range in {
        if err := checkReqId(r.Id); err != nil {
            return nil, false, &invalidMessageError{err.Error()}
        }

        id := &in[i].Id

        // subscribe are special, they will always use `subscribeMethod` as first param in the payload
        if r.Method == subscribeMethod {
            requests[i] = rpcRequest{id: id, isPubSub: true}
            if len(r.Payload) > 0 {
                // first param must be subscription name
                var subscribeMethod [1]string
                if err := json.Unmarshal(r.Payload, &subscribeMethod); err != nil {
                    glog.V(logger.Debug).Infof("Unable to parse subscription method: %v\n", err)
                    return nil, false, &invalidRequestError{"Unable to parse subscription request"}
                }

                // all subscriptions are made on the eth service
                requests[i].service, requests[i].method = "eth", subscribeMethod[0]
                requests[i].params = r.Payload
                continue
            }

            return nil, true, &invalidRequestError{"Unable to parse (un)subscribe request arguments"}
        }

        if r.Method == unsubscribeMethod {
            requests[i] = rpcRequest{id: id, isPubSub: true, method: unsubscribeMethod, params: r.Payload}
            continue
        }

        if len(r.Payload) == 0 {
            requests[i] = rpcRequest{id: id, params: nil}
        } else {
            requests[i] = rpcRequest{id: id, params: r.Payload}
        }
        if elem := strings.Split(r.Method, serviceMethodSeparator); len(elem) == 2 {
            requests[i].service, requests[i].method = elem[0], elem[1]
        } else {
            requests[i].err = &methodNotFoundError{r.Method, ""}
        }
    }

    return requests, true, nil
}

// ParseRequestArguments tries to parse the given params (json.RawMessage) with the given types. It returns the parsed
// values or an error when the parsing failed.
func (c *jsonCodec) ParseRequestArguments(argTypes []reflect.Type, params interface{}) ([]reflect.Value, RPCError) {
    if args, ok := params.(json.RawMessage); !ok {
        return nil, &invalidParamsError{"Invalid params supplied"}
    } else {
        return parsePositionalArguments(args, argTypes)
    }
}

// parsePositionalArguments tries to parse the given args to an array of values with the given types.
// It returns the parsed values or an error when the args could not be parsed. Missing optional arguments
// are returned as reflect.Zero values.
func parsePositionalArguments(args json.RawMessage, callbackArgs []reflect.Type) ([]reflect.Value, RPCError) {
    params := make([]interface{}, 0, len(callbackArgs))
    for _, t := range callbackArgs {
        params = append(params, reflect.New(t).Interface())
    }

    if err := json.Unmarshal(args, &params); err != nil {
        return nil, &invalidParamsError{err.Error()}
    }

    if len(params) > len(callbackArgs) {
        return nil, &invalidParamsError{fmt.Sprintf("too many params, want %d got %d", len(callbackArgs), len(params))}
    }

    // assume missing params are null values
    for i := len(params); i < len(callbackArgs); i++ {
        params = append(params, nil)
    }

    argValues := make([]reflect.Value, len(params))
    for i, p := range params {
        // verify that JSON null values are only supplied for optional arguments (ptr types)
        if p == nil && callbackArgs[i].Kind() != reflect.Ptr {
            return nil, &invalidParamsError{fmt.Sprintf("invalid or missing value for params[%d]", i)}
        }
        if p == nil {
            argValues[i] = reflect.Zero(callbackArgs[i])
        } else { // deref pointers values creates previously with reflect.New
            argValues[i] = reflect.ValueOf(p).Elem()
        }
    }

    return argValues, nil
}

// CreateResponse will create a JSON-RPC success response with the given id and reply as result.
func (c *jsonCodec) CreateResponse(id interface{}, reply interface{}) interface{} {
    if isHexNum(reflect.TypeOf(reply)) {
        return &JSONSuccessResponse{Version: JSONRPCVersion, Id: id, Result: fmt.Sprintf(`%#x`, reply)}
    }
    return &JSONSuccessResponse{Version: JSONRPCVersion, Id: id, Result: reply}
}

// CreateErrorResponse will create a JSON-RPC error response with the given id and error.
func (c *jsonCodec) CreateErrorResponse(id interface{}, err RPCError) interface{} {
    return &JSONErrResponse{Version: JSONRPCVersion, Id: id, Error: JSONError{Code: err.Code(), Message: err.Error()}}
}

// CreateErrorResponseWithInfo will create a JSON-RPC error response with the given id and error.
// info is optional and contains additional information about the error. When an empty string is passed it is ignored.
func (c *jsonCodec) CreateErrorResponseWithInfo(id interface{}, err RPCError, info interface{}) interface{} {
    return &JSONErrResponse{Version: JSONRPCVersion, Id: id,
        Error: JSONError{Code: err.Code(), Message: err.Error(), Data: info}}
}

// CreateNotification will create a JSON-RPC notification with the given subscription id and event as params.
func (c *jsonCodec) CreateNotification(subid string, event interface{}) interface{} {
    if isHexNum(reflect.TypeOf(event)) {
        return &jsonNotification{Version: JSONRPCVersion, Method: notificationMethod,
            Params: jsonSubscription{Subscription: subid, Result: fmt.Sprintf(`%#x`, event)}}
    }

    return &jsonNotification{Version: JSONRPCVersion, Method: notificationMethod,
        Params: jsonSubscription{Subscription: subid, Result: event}}
}

// Write message to client
func (c *jsonCodec) Write(res interface{}) error {
    c.encMu.Lock()
    defer c.encMu.Unlock()

    return c.e.Encode(res)
}

// Close the underlying connection
func (c *jsonCodec) Close() {
    c.closer.Do(func() {
        close(c.closed)
        c.rw.Close()
    })
}

// Closed returns a channel which will be closed when Close is called
func (c *jsonCodec) Closed() <-chan interface{} {
    return c.closed
}