net/http/httputil

var (
        // Deprecated: No longer used.
        ErrPersistEOF = &http.ProtocolError{ErrorString: "persistent connection closed"}

        // Deprecated: No longer used.
        ErrClosed = &http.ProtocolError{ErrorString: "connection closed by user"}

        // Deprecated: No longer used.
        ErrPipeline = &http.ProtocolError{ErrorString: "pipeline error"}
)

var ErrLineTooLong = internal.ErrLineTooLong

func DumpRequest(req *http.Request, body bool) ([]byte, error)

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"net/http/httptest"
	"net/http/httputil"
	"strings"
)

func main() {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		dump, err := httputil.DumpRequest(r, true)
		if err != nil {
			http.Error(w, fmt.Sprint(err), http.StatusInternalServerError)
			return
		}

		fmt.Fprintf(w, "%q", dump)
	}))
	defer ts.Close()

	const body = "Go is a general-purpose language designed with systems programming in mind."
	req, err := http.NewRequest("POST", ts.URL, strings.NewReader(body))
	if err != nil {
		log.Fatal(err)
	}
	req.Host = "www.example.org"
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	b, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%s", b)

}

func DumpRequestOut(req *http.Request, body bool) ([]byte, error)

package main

import (
	"fmt"
	"log"
	"net/http"
	"net/http/httputil"
	"strings"
)

func main() {
	const body = "Go is a general-purpose language designed with systems programming in mind."
	req, err := http.NewRequest("PUT", "http://www.example.org", strings.NewReader(body))
	if err != nil {
		log.Fatal(err)
	}

	dump, err := httputil.DumpRequestOut(req, true)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%q", dump)

}

func DumpResponse(resp *http.Response, body bool) ([]byte, error)

package main

import (
	"fmt"
	"log"
	"net/http"
	"net/http/httptest"
	"net/http/httputil"
)

func main() {
	const body = "Go is a general-purpose language designed with systems programming in mind."
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Date", "Wed, 19 Jul 1972 19:00:00 GMT")
		fmt.Fprintln(w, body)
	}))
	defer ts.Close()

	resp, err := http.Get(ts.URL)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	dump, err := httputil.DumpResponse(resp, true)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%q", dump)

}

func NewChunkedReader(r io.Reader) io.Reader

func NewChunkedWriter(w io.Writer) io.WriteCloser

type BufferPool interface {
        Get() []byte
        Put([]byte)
}

type ClientConn struct {
        // contains filtered or unexported fields
}

func NewClientConn(c net.Conn, r *bufio.Reader) *ClientConn

func NewProxyClientConn(c net.Conn, r *bufio.Reader) *ClientConn

func (cc *ClientConn) Close() error

func (cc *ClientConn) Do(req *http.Request) (*http.Response, error)

func (cc *ClientConn) Hijack() (c net.Conn, r *bufio.Reader)

func (cc *ClientConn) Pending() int

func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error)

func (cc *ClientConn) Write(req *http.Request) error

type ReverseProxy struct {
        // Director must be a function which modifies
        // the request into a new request to be sent
        // using Transport. Its response is then copied
        // back to the original client unmodified.
        // Director must not access the provided Request
        // after returning.
        Director func(*http.Request)

        // The transport used to perform proxy requests.
        // If nil, http.DefaultTransport is used.
        Transport http.RoundTripper

        // FlushInterval specifies the flush interval
        // to flush to the client while copying the
        // response body.
        // If zero, no periodic flushing is done.
        FlushInterval time.Duration

        // ErrorLog specifies an optional logger for errors
        // that occur when attempting to proxy the request.
        // If nil, logging goes to os.Stderr via the log package's
        // standard logger.
        ErrorLog *log.Logger

        // BufferPool optionally specifies a buffer pool to
        // get byte slices for use by io.CopyBuffer when
        // copying HTTP response bodies.
        BufferPool BufferPool

        // ModifyResponse is an optional function that
        // modifies the Response from the backend.
        // If it returns an error, the proxy returns a StatusBadGateway error.
        ModifyResponse func(*http.Response) error
}

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"net/http/httptest"
	"net/http/httputil"
	"net/url"
)

func main() {
	backendServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "this call was relayed by the reverse proxy")
	}))
	defer backendServer.Close()

	rpURL, err := url.Parse(backendServer.URL)
	if err != nil {
		log.Fatal(err)
	}
	frontendProxy := httptest.NewServer(httputil.NewSingleHostReverseProxy(rpURL))
	defer frontendProxy.Close()

	resp, err := http.Get(frontendProxy.URL)
	if err != nil {
		log.Fatal(err)
	}

	b, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%s", b)

}

func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy

func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request)

type ServerConn struct {
        // contains filtered or unexported fields
}

func NewServerConn(c net.Conn, r *bufio.Reader) *ServerConn

func (sc *ServerConn) Close() error

func (sc *ServerConn) Hijack() (net.Conn, *bufio.Reader)

func (sc *ServerConn) Pending() int

func (sc *ServerConn) Read() (*http.Request, error)

func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error