You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
273 lines
7.3 KiB
273 lines
7.3 KiB
package server
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"html/template"
|
|
"io"
|
|
"net/http"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/tendermint/tendermint/libs/log"
|
|
rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
|
|
)
|
|
|
|
// HTTP + JSON handler
|
|
|
|
// jsonrpc calls grab the given method's function info and runs reflect.Call
|
|
func makeJSONRPCHandler(funcMap map[string]*RPCFunc, logger log.Logger) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, hreq *http.Request) {
|
|
// For POST requests, reject a non-root URL path. This should not happen
|
|
// in the standard configuration, since the wrapper checks the path.
|
|
if hreq.URL.Path != "/" {
|
|
writeRPCResponse(w, logger, rpctypes.RPCRequest{}.MakeErrorf(
|
|
rpctypes.CodeInvalidRequest, "invalid path: %q", hreq.URL.Path))
|
|
return
|
|
}
|
|
|
|
b, err := io.ReadAll(hreq.Body)
|
|
if err != nil {
|
|
writeRPCResponse(w, logger, rpctypes.RPCRequest{}.MakeErrorf(
|
|
rpctypes.CodeInvalidRequest, "reading request body: %v", err))
|
|
return
|
|
}
|
|
|
|
// if its an empty request (like from a browser), just display a list of
|
|
// functions
|
|
if len(b) == 0 {
|
|
writeListOfEndpoints(w, hreq, funcMap)
|
|
return
|
|
}
|
|
|
|
requests, err := parseRequests(b)
|
|
if err != nil {
|
|
writeRPCResponse(w, logger, rpctypes.RPCRequest{}.MakeErrorf(
|
|
rpctypes.CodeParseError, "decoding request: %v", err))
|
|
return
|
|
}
|
|
|
|
var responses []rpctypes.RPCResponse
|
|
for _, req := range requests {
|
|
// Ignore notifications, which this service does not support.
|
|
if req.IsNotification() {
|
|
logger.Debug("Ignoring notification", "req", req)
|
|
continue
|
|
}
|
|
|
|
rpcFunc, ok := funcMap[req.Method]
|
|
if !ok || rpcFunc.ws {
|
|
responses = append(responses, req.MakeErrorf(rpctypes.CodeMethodNotFound, req.Method))
|
|
continue
|
|
}
|
|
|
|
req := req
|
|
ctx := rpctypes.WithCallInfo(hreq.Context(), &rpctypes.CallInfo{
|
|
RPCRequest: &req,
|
|
HTTPRequest: hreq,
|
|
})
|
|
args, err := parseParams(ctx, rpcFunc, req.Params)
|
|
if err != nil {
|
|
responses = append(responses,
|
|
req.MakeErrorf(rpctypes.CodeInvalidParams, "converting JSON parameters: %v", err))
|
|
continue
|
|
}
|
|
|
|
returns := rpcFunc.f.Call(args)
|
|
result, err := unreflectResult(returns)
|
|
if err == nil {
|
|
responses = append(responses, req.MakeResponse(result))
|
|
} else {
|
|
responses = append(responses, req.MakeError(err))
|
|
}
|
|
}
|
|
|
|
if len(responses) == 0 {
|
|
return
|
|
}
|
|
writeRPCResponse(w, logger, responses...)
|
|
}
|
|
}
|
|
|
|
func handleInvalidJSONRPCPaths(next http.HandlerFunc) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
// Since the pattern "/" matches all paths not matched by other registered patterns,
|
|
// we check whether the path is indeed "/", otherwise return a 404 error
|
|
if r.URL.Path != "/" {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
next(w, r)
|
|
}
|
|
}
|
|
|
|
// parseRequests parses a JSON-RPC request or request batch from data.
|
|
func parseRequests(data []byte) ([]rpctypes.RPCRequest, error) {
|
|
var reqs []rpctypes.RPCRequest
|
|
var err error
|
|
|
|
isArray := bytes.HasPrefix(bytes.TrimSpace(data), []byte("["))
|
|
if isArray {
|
|
err = json.Unmarshal(data, &reqs)
|
|
} else {
|
|
reqs = append(reqs, rpctypes.RPCRequest{})
|
|
err = json.Unmarshal(data, &reqs[0])
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return reqs, nil
|
|
}
|
|
|
|
// parseParams parses the JSON parameters of rpcReq into the arguments of fn,
|
|
// returning the corresponding argument values or an error.
|
|
func parseParams(ctx context.Context, fn *RPCFunc, paramData []byte) ([]reflect.Value, error) {
|
|
params, err := parseJSONParams(fn, paramData)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
args := make([]reflect.Value, 1+len(params))
|
|
args[0] = reflect.ValueOf(ctx)
|
|
for i, param := range params {
|
|
ptype := fn.args[i+1]
|
|
if len(param) == 0 {
|
|
args[i+1] = reflect.Zero(ptype)
|
|
continue
|
|
}
|
|
|
|
var pval reflect.Value
|
|
isPtr := ptype.Kind() == reflect.Ptr
|
|
if isPtr {
|
|
pval = reflect.New(ptype.Elem())
|
|
} else {
|
|
pval = reflect.New(ptype)
|
|
}
|
|
baseType := pval.Type().Elem()
|
|
|
|
if isIntType(baseType) && isStringValue(param) {
|
|
var z int64String
|
|
if err := json.Unmarshal(param, &z); err != nil {
|
|
return nil, fmt.Errorf("decoding string %q: %w", fn.argNames[i], err)
|
|
}
|
|
pval.Elem().Set(reflect.ValueOf(z).Convert(baseType))
|
|
} else if err := json.Unmarshal(param, pval.Interface()); err != nil {
|
|
return nil, fmt.Errorf("decoding %q: %w", fn.argNames[i], err)
|
|
}
|
|
|
|
if isPtr {
|
|
args[i+1] = pval
|
|
} else {
|
|
args[i+1] = pval.Elem()
|
|
}
|
|
}
|
|
return args, nil
|
|
}
|
|
|
|
// parseJSONParams parses data and returns a slice of JSON values matching the
|
|
// positional parameters of fn. It reports an error if data is not "null" and
|
|
// does not encode an object or an array, or if the number of array parameters
|
|
// does not match the argument list of fn (excluding the context).
|
|
func parseJSONParams(fn *RPCFunc, data []byte) ([]json.RawMessage, error) {
|
|
base := bytes.TrimSpace(data)
|
|
if bytes.HasPrefix(base, []byte("{")) {
|
|
var m map[string]json.RawMessage
|
|
if err := json.Unmarshal(base, &m); err != nil {
|
|
return nil, fmt.Errorf("decoding parameter object: %w", err)
|
|
}
|
|
out := make([]json.RawMessage, len(fn.argNames))
|
|
for i, name := range fn.argNames {
|
|
if p, ok := m[name]; ok {
|
|
out[i] = p
|
|
}
|
|
}
|
|
return out, nil
|
|
|
|
} else if bytes.HasPrefix(base, []byte("[")) {
|
|
var m []json.RawMessage
|
|
if err := json.Unmarshal(base, &m); err != nil {
|
|
return nil, fmt.Errorf("decoding parameter array: %w", err)
|
|
}
|
|
if len(m) != len(fn.argNames) {
|
|
return nil, fmt.Errorf("got %d parameters, want %d", len(m), len(fn.argNames))
|
|
}
|
|
return m, nil
|
|
|
|
} else if bytes.Equal(base, []byte("null")) {
|
|
return make([]json.RawMessage, len(fn.argNames)), nil
|
|
}
|
|
|
|
return nil, errors.New("parameters must be an object or an array")
|
|
}
|
|
|
|
// isStringValue reports whether data is a JSON string value.
|
|
func isStringValue(data json.RawMessage) bool {
|
|
return len(data) != 0 && data[0] == '"'
|
|
}
|
|
|
|
type int64String int64
|
|
|
|
func (z *int64String) UnmarshalText(data []byte) error {
|
|
v, err := strconv.ParseInt(string(data), 10, 64)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*z = int64String(v)
|
|
return nil
|
|
}
|
|
|
|
// writes a list of available rpc endpoints as an html page
|
|
func writeListOfEndpoints(w http.ResponseWriter, r *http.Request, funcMap map[string]*RPCFunc) {
|
|
hasArgs := make(map[string]string)
|
|
noArgs := make(map[string]string)
|
|
for name, rf := range funcMap {
|
|
base := fmt.Sprintf("//%s/%s", r.Host, name)
|
|
// N.B. Check argNames, not args, since the type list includes the type
|
|
// of the leading context argument.
|
|
if len(rf.argNames) == 0 {
|
|
noArgs[name] = base
|
|
} else {
|
|
query := append([]string(nil), rf.argNames...)
|
|
for i, arg := range query {
|
|
query[i] = arg + "=_"
|
|
}
|
|
hasArgs[name] = base + "?" + strings.Join(query, "&")
|
|
}
|
|
}
|
|
w.Header().Set("Content-Type", "text/html")
|
|
_ = listOfEndpoints.Execute(w, map[string]map[string]string{
|
|
"NoArgs": noArgs,
|
|
"HasArgs": hasArgs,
|
|
})
|
|
}
|
|
|
|
var listOfEndpoints = template.Must(template.New("list").Parse(`<html>
|
|
<head><title>List of RPC Endpoints</title></head>
|
|
<body>
|
|
|
|
<h1>Available RPC endpoints:</h1>
|
|
|
|
{{if .NoArgs}}
|
|
<hr />
|
|
<h2>Endpoints with no arguments:</h2>
|
|
|
|
<ul>
|
|
{{range $link := .NoArgs}} <li><a href="{{$link}}">{{$link}}</a></li>
|
|
{{end -}}
|
|
</ul>{{end}}
|
|
|
|
{{if .HasArgs}}
|
|
<hr />
|
|
<h2>Endpoints that require arguments:</h2>
|
|
|
|
<ul>
|
|
{{range $link := .HasArgs}} <li><a href="{{$link}}">{{$link}}</a></li>
|
|
{{end -}}
|
|
</ul>{{end}}
|
|
|
|
</body></html>`))
|