"HTTP/1.1 200 OK\r\nContent-Length: 76\r\nContent-Type: text/plain; charset=utf-8\r\nDate: Wed, 19 Jul 1972 19:00:00 GMT\r\n\r\nGo is a general-purpose language designed with systems programming in mind.\n"
func NewChunkedReader(r io.Reader) io.Reader
NewChunkedReader returns a new chunkedReader that translates the data read from r
out of HTTP "chunked" format before returning it.
The chunkedReader returns io.EOF when the final 0-length chunk is read.
NewChunkedReader is not needed by normal applications. The http package
automatically decodes chunking when reading response bodies.
func NewChunkedWriter(w io.Writer) io.WriteCloser
NewChunkedWriter returns a new chunkedWriter that translates writes into HTTP
"chunked" format before writing them to w. Closing the returned chunkedWriter
sends the final 0-length chunk that marks the end of the stream but does
not send the final CRLF that appears after trailers; trailers and the last
CRLF must be written separately.
NewChunkedWriter is not needed by normal applications. The http
package adds chunking automatically if handlers don't set a
Content-Length header. Using NewChunkedWriter inside a handler
would result in double chunking or chunking with a Content-Length
length, both of which are wrong.
ClientConn is an artifact of Go's early HTTP implementation.
It is low-level, old, and unused by Go's current HTTP stack.
We should have deleted it before Go 1.
Deprecated: Use Client or Transport in package net/http instead.
func NewClientConn(c net.Conn, r *bufio.Reader) *ClientConn
NewClientConn is an artifact of Go's early HTTP implementation.
It is low-level, old, and unused by Go's current HTTP stack.
We should have deleted it before Go 1.
Deprecated: Use the Client or Transport in package net/http instead.
func NewProxyClientConn(c net.Conn, r *bufio.Reader) *ClientConn
NewProxyClientConn is an artifact of Go's early HTTP implementation.
It is low-level, old, and unused by Go's current HTTP stack.
We should have deleted it before Go 1.
Deprecated: Use the Client or Transport in package net/http instead.
func (cc *ClientConn) Hijack() (c net.Conn, r *bufio.Reader)
Hijack detaches the ClientConn and returns the underlying connection as well
as the read-side bufio which may have some left over data. Hijack may be
called before the user or Read have signaled the end of the keep-alive
logic. The user should not call Hijack while ClientConn.Read or ClientConn.Write is in progress.
func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error)
Read reads the next response from the wire. A valid response might be
returned together with an ErrPersistEOF, which means that the remote
requested that this be the last request serviced. Read can be called
concurrently with ClientConn.Write, but not with another Read.
func (cc *ClientConn) Write(req *http.Request) error
Write writes a request. An ErrPersistEOF error is returned if the connection
has been closed in an HTTP keep-alive sense. If req.Close equals true, the
keep-alive connection is logically closed after this request and the opposing
server is informed. An ErrUnexpectedEOF indicates the remote closed the
underlying TCP connection, which is usually considered as graceful close.
type ProxyRequest struct {
In *http.Request
Out *http.Request
A ProxyRequest contains a request to be rewritten by a ReverseProxy.
func (r *ProxyRequest) SetURL(target *url.URL)
SetURL routes the outbound request to the scheme, host, and base path
provided in target. If the target's path is "/base" and the incoming
request was for "/dir", the target request will be for "/base/dir".
SetURL rewrites the outbound Host header to match the target's host.
To preserve the inbound request's Host header (the default behavior
of NewSingleHostReverseProxy):
rewriteFunc := func(r *httputil.ProxyRequest) {
r.SetURL(url)
r.Out.Host = r.In.Host
func (r *ProxyRequest) SetXForwarded()
SetXForwarded sets the X-Forwarded-For, X-Forwarded-Host, and
X-Forwarded-Proto headers of the outbound request.
The X-Forwarded-For header is set to the client IP address.
The X-Forwarded-Host header is set to the host name requested
by the client.
The X-Forwarded-Proto header is set to "http" or "https", depending
on whether the inbound request was made on a TLS-enabled connection.
If the outbound request contains an existing X-Forwarded-For header,
SetXForwarded appends the client IP address to it. To append to the
inbound request's X-Forwarded-For header (the default behavior of
ReverseProxy when using a Director function), copy the header
from the inbound request before calling SetXForwarded:
rewriteFunc := func(r *httputil.ProxyRequest) {
r.Out.Header["X-Forwarded-For"] = r.In.Header["X-Forwarded-For"]
r.SetXForwarded()
type ReverseProxy struct {
Rewrite func(*ProxyRequest)
Director func(*http.Request)
Transport http.RoundTripper
FlushInterval time.Duration
ErrorLog *log.Logger
BufferPool BufferPool
ModifyResponse func(*http.Response) error
ErrorHandler func(http.ResponseWriter, *http.Request, error)
ReverseProxy is an HTTP Handler that takes an incoming request and
sends it to another server, proxying the response back to the
client.
1xx responses are forwarded to the client if the underlying
transport supports ClientTrace.Got1xxResponse.
package main
import (
"fmt"
"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.ReverseProxy{
Rewrite: func(r *httputil.ProxyRequest) {
r.SetXForwarded()
r.SetURL(rpURL)
defer frontendProxy.Close()
resp, err := http.Get(frontendProxy.URL)
if err != nil {
log.Fatal(err)
b, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
fmt.Printf("%s", b)
Output:
this call was relayed by the reverse proxy
func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy
NewSingleHostReverseProxy returns a new ReverseProxy that routes
URLs to the scheme, host, and base path provided in target. If the
target's path is "/base" and the incoming request was for "/dir",
the target request will be for /base/dir.
NewSingleHostReverseProxy does not rewrite the Host header.
To customize the ReverseProxy behavior beyond what
NewSingleHostReverseProxy provides, use ReverseProxy directly
with a Rewrite function. The ProxyRequest SetURL method
may be used to route the outbound request. (Note that SetURL,
unlike NewSingleHostReverseProxy, rewrites the Host header
of the outbound request by default.)
proxy := &ReverseProxy{
Rewrite: func(r *ProxyRequest) {
r.SetURL(target)
r.Out.Host = r.In.Host // if desired
ServerConn is an artifact of Go's early HTTP implementation.
It is low-level, old, and unused by Go's current HTTP stack.
We should have deleted it before Go 1.
Deprecated: Use the Server in package net/http instead.
func NewServerConn(c net.Conn, r *bufio.Reader) *ServerConn
NewServerConn is an artifact of Go's early HTTP implementation.
It is low-level, old, and unused by Go's current HTTP stack.
We should have deleted it before Go 1.
Deprecated: Use the Server in package net/http instead.
func (sc *ServerConn) Hijack() (net.Conn, *bufio.Reader)
Hijack detaches the ServerConn and returns the underlying connection as well
as the read-side bufio which may have some left over data. Hijack may be
called before Read has signaled the end of the keep-alive logic. The user
should not call Hijack while ServerConn.Read or ServerConn.Write is in progress.
func (sc *ServerConn) Read() (*http.Request, error)
Read returns the next request on the wire. An ErrPersistEOF is returned if
it is gracefully determined that there are no more requests (e.g. after the
first request on an HTTP/1.0 connection, or after a Connection:close on a
HTTP/1.1 connection).
func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error
Write writes resp in response to req. To close the connection gracefully, set the
Response.Close field to true. Write should be considered operational until
it returns an error, regardless of any errors returned on the ServerConn.Read side.
go.dev uses cookies from Google to deliver and enhance the quality of its services and to
analyze traffic.
Learn more.
