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.
206 lines
5.9 KiB
206 lines
5.9 KiB
package server
|
|
|
|
import (
|
|
"context"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/tendermint/tendermint/libs/log"
|
|
"github.com/tendermint/tendermint/rpc/coretypes"
|
|
rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
|
|
)
|
|
|
|
// HTTP + URI handler
|
|
|
|
// convert from a function name to the http handler
|
|
func makeHTTPHandler(rpcFunc *RPCFunc, logger log.Logger) func(http.ResponseWriter, *http.Request) {
|
|
// Always return -1 as there's no ID here.
|
|
dummyID := rpctypes.JSONRPCIntID(-1) // URIClientRequestID
|
|
|
|
// Exception for websocket endpoints
|
|
//
|
|
// TODO(creachadair): Rather than reporting errors for these, we should
|
|
// remove them from the routing list entirely on this endpoint.
|
|
if rpcFunc.ws {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
}
|
|
}
|
|
|
|
// All other endpoints
|
|
return func(w http.ResponseWriter, req *http.Request) {
|
|
ctx := rpctypes.WithCallInfo(req.Context(), &rpctypes.CallInfo{
|
|
HTTPRequest: req,
|
|
})
|
|
args, err := parseURLParams(ctx, rpcFunc, req)
|
|
if err != nil {
|
|
w.Header().Set("Content-Type", "text/plain")
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
fmt.Fprintln(w, err.Error())
|
|
return
|
|
}
|
|
outs := rpcFunc.f.Call(args)
|
|
|
|
logger.Debug("HTTPRestRPC", "method", req.URL.Path, "args", args, "returns", outs)
|
|
result, err := unreflectResult(outs)
|
|
switch e := err.(type) {
|
|
// if no error then return a success response
|
|
case nil:
|
|
writeHTTPResponse(w, logger, rpctypes.NewRPCSuccessResponse(dummyID, result))
|
|
|
|
// if this already of type RPC error then forward that error.
|
|
case *rpctypes.RPCError:
|
|
writeHTTPResponse(w, logger, rpctypes.NewRPCErrorResponse(dummyID, e.Code, e.Message, e.Data))
|
|
|
|
default: // we need to unwrap the error and parse it accordingly
|
|
switch errors.Unwrap(err) {
|
|
case coretypes.ErrZeroOrNegativeHeight,
|
|
coretypes.ErrZeroOrNegativePerPage,
|
|
coretypes.ErrPageOutOfRange,
|
|
coretypes.ErrInvalidRequest:
|
|
writeHTTPResponse(w, logger, rpctypes.RPCInvalidRequestError(dummyID, err))
|
|
default: // ctypes.ErrHeightNotAvailable, ctypes.ErrHeightExceedsChainHead:
|
|
writeHTTPResponse(w, logger, rpctypes.RPCInternalError(dummyID, err))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseURLParams(ctx context.Context, rf *RPCFunc, req *http.Request) ([]reflect.Value, error) {
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, fmt.Errorf("invalid HTTP request: %w", err)
|
|
}
|
|
getArg := func(name string) (string, bool) {
|
|
if req.Form.Has(name) {
|
|
return req.Form.Get(name), true
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
vals := make([]reflect.Value, len(rf.argNames)+1)
|
|
vals[0] = reflect.ValueOf(ctx)
|
|
for i, name := range rf.argNames {
|
|
atype := rf.args[i+1]
|
|
|
|
text, ok := getArg(name)
|
|
if !ok {
|
|
vals[i+1] = reflect.Zero(atype)
|
|
continue
|
|
}
|
|
|
|
val, err := parseArgValue(atype, text)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("decoding parameter %q: %w", name, err)
|
|
}
|
|
vals[i+1] = val
|
|
}
|
|
return vals, nil
|
|
}
|
|
|
|
func parseArgValue(atype reflect.Type, text string) (reflect.Value, error) {
|
|
// Regardless whether the argument is a pointer type, allocate a pointer so
|
|
// we can set the computed value.
|
|
var out reflect.Value
|
|
isPtr := atype.Kind() == reflect.Ptr
|
|
if isPtr {
|
|
out = reflect.New(atype.Elem())
|
|
} else {
|
|
out = reflect.New(atype)
|
|
}
|
|
|
|
baseType := out.Type().Elem()
|
|
if isIntType(baseType) {
|
|
// Integral type: Require a base-10 digit string. For compatibility with
|
|
// existing use allow quotation marks.
|
|
v, err := decodeInteger(text)
|
|
if err != nil {
|
|
return reflect.Value{}, fmt.Errorf("invalid integer: %w", err)
|
|
}
|
|
out.Elem().Set(reflect.ValueOf(v).Convert(baseType))
|
|
} else if isStringOrBytes(baseType) {
|
|
// String or byte slice: Check for quotes, hex encoding.
|
|
dec, err := decodeString(text)
|
|
if err != nil {
|
|
return reflect.Value{}, err
|
|
}
|
|
out.Elem().Set(reflect.ValueOf(dec).Convert(baseType))
|
|
|
|
} else if baseType.Kind() == reflect.Bool {
|
|
b, err := strconv.ParseBool(text)
|
|
if err != nil {
|
|
return reflect.Value{}, fmt.Errorf("invalid boolean: %w", err)
|
|
}
|
|
out.Elem().Set(reflect.ValueOf(b))
|
|
|
|
} else {
|
|
// We don't know how to represent other types.
|
|
return reflect.Value{}, fmt.Errorf("unsupported argument type %v", baseType)
|
|
}
|
|
|
|
// If the argument wants a pointer, return the value as-is, otherwise
|
|
// indirect the pointer back off.
|
|
if isPtr {
|
|
return out, nil
|
|
}
|
|
return out.Elem(), nil
|
|
}
|
|
|
|
var uint64Type = reflect.TypeOf(uint64(0))
|
|
|
|
// isIntType reports whether atype is an integer-shaped type.
|
|
func isIntType(atype reflect.Type) bool {
|
|
switch atype.Kind() {
|
|
case reflect.Float32, reflect.Float64:
|
|
return false
|
|
default:
|
|
return atype.ConvertibleTo(uint64Type)
|
|
}
|
|
}
|
|
|
|
// isStringOrBytes reports whether atype is a string or []byte.
|
|
func isStringOrBytes(atype reflect.Type) bool {
|
|
switch atype.Kind() {
|
|
case reflect.String:
|
|
return true
|
|
case reflect.Slice:
|
|
return atype.Elem().Kind() == reflect.Uint8
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// isQuotedString reports whether s is enclosed in double quotes.
|
|
func isQuotedString(s string) bool {
|
|
return len(s) >= 2 && strings.HasPrefix(s, `"`) && strings.HasSuffix(s, `"`)
|
|
}
|
|
|
|
// decodeInteger decodes s into an int64. If s is "double quoted" the quotes
|
|
// are removed; otherwise s must be a base-10 digit string.
|
|
func decodeInteger(s string) (int64, error) {
|
|
if isQuotedString(s) {
|
|
s = s[1 : len(s)-1]
|
|
}
|
|
return strconv.ParseInt(s, 10, 64)
|
|
}
|
|
|
|
// decodeString decodes s into a byte slice. If s has an 0x prefix, it is
|
|
// treated as a hex-encoded string. If it is "double quoted" it is treated as a
|
|
// JSON string value. Otherwise, s is converted to bytes directly.
|
|
func decodeString(s string) ([]byte, error) {
|
|
if lc := strings.ToLower(s); strings.HasPrefix(lc, "0x") {
|
|
return hex.DecodeString(lc[2:])
|
|
} else if isQuotedString(s) {
|
|
var dec string
|
|
if err := json.Unmarshal([]byte(s), &dec); err != nil {
|
|
return nil, fmt.Errorf("invalid quoted string: %w", err)
|
|
}
|
|
return []byte(dec), nil
|
|
}
|
|
return []byte(s), nil
|
|
}
|