path: root/rpc/http.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 (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "io/ioutil"
    "net"
    "net/http"
    "strings"
    "sync"
    "time"

    "github.com/rs/cors"
    "golang.org/x/net/context"
)

const (
    maxHTTPRequestContentLength = 1024 * 128
)

var nullAddr, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:0")

type httpConn struct {
    client    *http.Client
    req       *http.Request
    closeOnce sync.Once
    closed    chan struct{}
}

// httpConn is treated specially by Client.
func (hc *httpConn) LocalAddr() net.Addr              { return nullAddr }
func (hc *httpConn) RemoteAddr() net.Addr             { return nullAddr }
func (hc *httpConn) SetReadDeadline(time.Time) error  { return nil }
func (hc *httpConn) SetWriteDeadline(time.Time) error { return nil }
func (hc *httpConn) SetDeadline(time.Time) error      { return nil }
func (hc *httpConn) Write([]byte) (int, error)        { panic("Write called") }

func (hc *httpConn) Read(b []byte) (int, error) {
    <-hc.closed
    return 0, io.EOF
}

func (hc *httpConn) Close() error {
    hc.closeOnce.Do(func() { close(hc.closed) })
    return nil
}

// DialHTTP creates a new RPC clients that connection to an RPC server over HTTP.
func DialHTTP(endpoint string) (*Client, error) {
    req, err := http.NewRequest("POST", endpoint, nil)
    if err != nil {
        return nil, err
    }
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept", "application/json")

    initctx := context.Background()
    return newClient(initctx, func(context.Context) (net.Conn, error) {
        return &httpConn{client: new(http.Client), req: req, closed: make(chan struct{})}, nil
    })
}

func (c *Client) sendHTTP(ctx context.Context, op *requestOp, msg interface{}) error {
    hc := c.writeConn.(*httpConn)
    respBody, err := hc.doRequest(ctx, msg)
    if err != nil {
        return err
    }
    defer respBody.Close()
    var respmsg jsonrpcMessage
    if err := json.NewDecoder(respBody).Decode(&respmsg); err != nil {
        return err
    }
    op.resp <- &respmsg
    return nil
}

func (c *Client) sendBatchHTTP(ctx context.Context, op *requestOp, msgs []*jsonrpcMessage) error {
    hc := c.writeConn.(*httpConn)
    respBody, err := hc.doRequest(ctx, msgs)
    if err != nil {
        return err
    }
    defer respBody.Close()
    var respmsgs []jsonrpcMessage
    if err := json.NewDecoder(respBody).Decode(&respmsgs); err != nil {
        return err
    }
    for _, respmsg := range respmsgs {
        op.resp <- &respmsg
    }
    return nil
}

func (hc *httpConn) doRequest(ctx context.Context, msg interface{}) (io.ReadCloser, error) {
    body, err := json.Marshal(msg)
    if err != nil {
        return nil, err
    }
    client, req := requestWithContext(hc.client, hc.req, ctx)
    req.Body = ioutil.NopCloser(bytes.NewReader(body))
    req.ContentLength = int64(len(body))

    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    return resp.Body, nil
}

// httpReadWriteNopCloser wraps a io.Reader and io.Writer with a NOP Close method.
type httpReadWriteNopCloser struct {
    io.Reader
    io.Writer
}

// Close does nothing and returns always nil
func (t *httpReadWriteNopCloser) Close() error {
    return nil
}

// NewHTTPServer creates a new HTTP RPC server around an API provider.
//
// Deprecated: Server implements http.Handler
func NewHTTPServer(corsString string, srv *Server) *http.Server {
    return &http.Server{Handler: newCorsHandler(srv, corsString)}
}

// ServeHTTP serves JSON-RPC requests over HTTP.
func (srv *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if r.ContentLength > maxHTTPRequestContentLength {
        http.Error(w,
            fmt.Sprintf("content length too large (%d>%d)", r.ContentLength, maxHTTPRequestContentLength),
            http.StatusRequestEntityTooLarge)
        return
    }
    w.Header().Set("content-type", "application/json")

    // create a codec that reads direct from the request body until
    // EOF and writes the response to w and order the server to process
    // a single request.
    codec := NewJSONCodec(&httpReadWriteNopCloser{r.Body, w})
    defer codec.Close()
    srv.ServeSingleRequest(codec, OptionMethodInvocation)
}

func newCorsHandler(srv *Server, corsString string) http.Handler {
    var allowedOrigins []string
    for _, domain := range strings.Split(corsString, ",") {
        allowedOrigins = append(allowedOrigins, strings.TrimSpace(domain))
    }
    c := cors.New(cors.Options{
        AllowedOrigins: allowedOrigins,
        AllowedMethods: []string{"POST", "GET"},
    })
    return c.Handler(srv)
}