1func Handle(pattern string, handler Handler)

1func HandleFunc(pattern string, handler func(ResponseWriter, *Request))

1func ListenAndServe(addr string, handler Handler) error

1func NewRequest(method, url string, body io.Reader) (*Request, error)

1func PostForm(url string, data url.Values) (resp *Response, err error)

1func Serve(l net.Listener, handler Handler) error

1func SetCookie(w ResponseWriter, cookie *Cookie)

1func NewServeMux() *ServeMux

 1type Client struct {
 2	// Transport specifies the mechanism by which individual
 3	// HTTP requests are made.
 4	// If nil, DefaultTransport is used.
 5	Transport	RoundTripper
 6
 7	// CheckRedirect specifies the policy for handling redirects.
 8	// If CheckRedirect is not nil, the client calls it before
 9	// following an HTTP redirect. The arguments req and via are
10	// the upcoming request and the requests made already, oldest
11	// first. If CheckRedirect returns an error, the Client's Get
12	// method returns both the previous Response (with its Body
13	// closed) and CheckRedirect's error (wrapped in a url.Error)
14	// instead of issuing the Request req.
15	// As a special case, if CheckRedirect returns ErrUseLastResponse,
16	// then the most recent response is returned with its body
17	// unclosed, along with a nil error.
18	//
19	// If CheckRedirect is nil, the Client uses its default policy,
20	// which is to stop after 10 consecutive requests.
21	CheckRedirect	func(req *Request, via []*Request) error
22
23	// Jar specifies the cookie jar.
24	//
25	// The Jar is used to insert relevant cookies into every
26	// outbound Request and is updated with the cookie values
27	// of every inbound Response. The Jar is consulted for every
28	// redirect that the Client follows.
29	//
30	// If Jar is nil, cookies are only sent if they are explicitly
31	// set on the Request.
32	Jar	CookieJar
33
34	// Timeout specifies a time limit for requests made by this
35	// Client. The timeout includes connection time, any
36	// redirects, and reading the response body. The timer remains
37	// running after Get, Head, Post, or Do return and will
38	// interrupt reading of the Response.Body.
39	//
40	// A Timeout of zero means no timeout.
41	//
42	// The Client cancels requests to the underlying Transport
43	// as if the Request's Context ended.
44	//
45	// For compatibility, the Client will also use the deprecated
46	// CancelRequest method on Transport if found. New
47	// RoundTripper implementations should use the Request's Context
48	// for cancellation instead of implementing CancelRequest.
49	Timeout	time.Duration
50}

 1type CloseNotifier interface {
 2	// CloseNotify returns a channel that receives at most a
 3	// single value (true) when the client connection has gone
 4	// away.
 5	//
 6	// CloseNotify may wait to notify until Request.Body has been
 7	// fully read.
 8	//
 9	// After the Handler has returned, there is no guarantee
10	// that the channel receives a value.
11	//
12	// If the protocol is HTTP/1.1 and CloseNotify is called while
13	// processing an idempotent request (such as GET) while
14	// HTTP/1.1 pipelining is in use, the arrival of a subsequent
15	// pipelined request may cause a value to be sent on the
16	// returned channel. In practice HTTP/1.1 pipelining is not
17	// enabled in browsers and not seen often in the wild. If this
18	// is a problem, use HTTP/2 or only use CloseNotify on methods
19	// such as POST.
20	CloseNotify() <-chan bool
21}

 1type Cookie struct {
 2	Name	string
 3	Value	string
 4	Quoted	bool	// indicates whether the Value was originally quoted
 5
 6	Path		string		// optional
 7	Domain		string		// optional
 8	Expires		time.Time	// optional
 9	RawExpires	string		// for reading cookies only
10
11	// MaxAge=0 means no 'Max-Age' attribute specified.
12	// MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
13	// MaxAge>0 means Max-Age attribute present and given in seconds
14	MaxAge		int
15	Secure		bool
16	HttpOnly	bool
17	SameSite	SameSite
18	Partitioned	bool
19	Raw		string
20	Unparsed	[]string	// Raw text of unparsed attribute-value pairs
21}

 1type CookieJar interface {
 2	// SetCookies handles the receipt of the cookies in a reply for the
 3	// given URL.  It may or may not choose to save the cookies, depending
 4	// on the jar's policy and implementation.
 5	SetCookies(u *url.URL, cookies []*Cookie)
 6
 7	// Cookies returns the cookies to send in a request for the given URL.
 8	// It is up to the implementation to honor the standard cookie use
 9	// restrictions such as in RFC 6265.
10	Cookies(u *url.URL) []*Cookie
11}

1type File interface {
2	io.Closer
3	io.Reader
4	io.Seeker
5	Readdir(count int) ([]fs.FileInfo, error)
6	Stat() (fs.FileInfo, error)
7}

1type FileSystem interface {
2	Open(name string) (File, error)
3}

1type Flusher interface {
2	// Flush sends any buffered data to the client.
3	Flush()
4}

1type Handler interface {
2	ServeHTTP(ResponseWriter, *Request)
3}

 1type Hijacker interface {
 2	// Hijack lets the caller take over the connection.
 3	// After a call to Hijack the HTTP server library
 4	// will not do anything else with the connection.
 5	//
 6	// It becomes the caller's responsibility to manage
 7	// and close the connection.
 8	//
 9	// The returned net.Conn may have read or write deadlines
10	// already set, depending on the configuration of the
11	// Server. It is the caller's responsibility to set
12	// or clear those deadlines as needed.
13	//
14	// The returned bufio.Reader may contain unprocessed buffered
15	// data from the client.
16	//
17	// After a call to Hijack, the original Request.Body must not
18	// be used. The original Request's Context remains valid and
19	// is not canceled until the Request's ServeHTTP method
20	// returns.
21	Hijack() (net.Conn, *bufio.ReadWriter, error)
22}

 1type Pusher interface {
 2	// Push initiates an HTTP/2 server push. This constructs a synthetic
 3	// request using the given target and options, serializes that request
 4	// into a PUSH_PROMISE frame, then dispatches that request using the
 5	// server's request handler. If opts is nil, default options are used.
 6	//
 7	// The target must either be an absolute path (like "/path") or an absolute
 8	// URL that contains a valid host and the same scheme as the parent request.
 9	// If the target is a path, it will inherit the scheme and host of the
10	// parent request.
11	//
12	// The HTTP/2 spec disallows recursive pushes and cross-authority pushes.
13	// Push may or may not detect these invalid pushes; however, invalid
14	// pushes will be detected and canceled by conforming clients.
15	//
16	// Handlers that wish to push URL X should call Push before sending any
17	// data that may trigger a request for URL X. This avoids a race where the
18	// client issues requests for X before receiving the PUSH_PROMISE for X.
19	//
20	// Push will run in a separate goroutine making the order of arrival
21	// non-deterministic. Any required synchronization needs to be implemented
22	// by the caller.
23	//
24	// Push returns ErrNotSupported if the client has disabled push or if push
25	// is not supported on the underlying connection.
26	Push(target string, opts *PushOptions) error
27}

  1type Request struct {
  2	// Method specifies the HTTP method (GET, POST, PUT, etc.).
  3	// For client requests, an empty string means GET.
  4	Method	string
  5
  6	// URL specifies either the URI being requested (for server
  7	// requests) or the URL to access (for client requests).
  8	//
  9	// For server requests, the URL is parsed from the URI
 10	// supplied on the Request-Line as stored in RequestURI.  For
 11	// most requests, fields other than Path and RawQuery will be
 12	// empty. (See RFC 7230, Section 5.3)
 13	//
 14	// For client requests, the URL's Host specifies the server to
 15	// connect to, while the Request's Host field optionally
 16	// specifies the Host header value to send in the HTTP
 17	// request.
 18	URL	*url.URL
 19
 20	// The protocol version for incoming server requests.
 21	//
 22	// For client requests, these fields are ignored. The HTTP
 23	// client code always uses either HTTP/1.1 or HTTP/2.
 24	// See the docs on Transport for details.
 25	Proto		string	// "HTTP/1.0"
 26	ProtoMajor	int	// 1
 27	ProtoMinor	int	// 0
 28
 29	// Header contains the request header fields either received
 30	// by the server or to be sent by the client.
 31	//
 32	// If a server received a request with header lines,
 33	//
 34	//	Host: example.com
 35	//	accept-encoding: gzip, deflate
 36	//	Accept-Language: en-us
 37	//	fOO: Bar
 38	//	foo: two
 39	//
 40	// then
 41	//
 42	//	Header = map[string][]string{
 43	//		"Accept-Encoding": {"gzip, deflate"},
 44	//		"Accept-Language": {"en-us"},
 45	//		"Foo": {"Bar", "two"},
 46	//	}
 47	//
 48	// For incoming requests, the Host header is promoted to the
 49	// Request.Host field and removed from the Header map.
 50	//
 51	// HTTP defines that header names are case-insensitive. The
 52	// request parser implements this by using CanonicalHeaderKey,
 53	// making the first character and any characters following a
 54	// hyphen uppercase and the rest lowercase.
 55	//
 56	// For client requests, certain headers such as Content-Length
 57	// and Connection are automatically written when needed and
 58	// values in Header may be ignored. See the documentation
 59	// for the Request.Write method.
 60	Header	Header
 61
 62	// Body is the request's body.
 63	//
 64	// For client requests, a nil body means the request has no
 65	// body, such as a GET request. The HTTP Client's Transport
 66	// is responsible for calling the Close method.
 67	//
 68	// For server requests, the Request Body is always non-nil
 69	// but will return EOF immediately when no body is present.
 70	// The Server will close the request body. The ServeHTTP
 71	// Handler does not need to.
 72	//
 73	// Body must allow Read to be called concurrently with Close.
 74	// In particular, calling Close should unblock a Read waiting
 75	// for input.
 76	Body	io.ReadCloser
 77
 78	// GetBody defines an optional func to return a new copy of
 79	// Body. It is used for client requests when a redirect requires
 80	// reading the body more than once. Use of GetBody still
 81	// requires setting Body.
 82	//
 83	// For server requests, it is unused.
 84	GetBody	func() (io.ReadCloser, error)
 85
 86	// ContentLength records the length of the associated content.
 87	// The value -1 indicates that the length is unknown.
 88	// Values >= 0 indicate that the given number of bytes may
 89	// be read from Body.
 90	//
 91	// For client requests, a value of 0 with a non-nil Body is
 92	// also treated as unknown.
 93	ContentLength	int64
 94
 95	// TransferEncoding lists the transfer encodings from outermost to
 96	// innermost. An empty list denotes the "identity" encoding.
 97	// TransferEncoding can usually be ignored; chunked encoding is
 98	// automatically added and removed as necessary when sending and
 99	// receiving requests.
100	TransferEncoding	[]string
101
102	// Close indicates whether to close the connection after
103	// replying to this request (for servers) or after sending this
104	// request and reading its response (for clients).
105	//
106	// For server requests, the HTTP server handles this automatically
107	// and this field is not needed by Handlers.
108	//
109	// For client requests, setting this field prevents re-use of
110	// TCP connections between requests to the same hosts, as if
111	// Transport.DisableKeepAlives were set.
112	Close	bool
113
114	// For server requests, Host specifies the host on which the
115	// URL is sought. For HTTP/1 (per RFC 7230, section 5.4), this
116	// is either the value of the "Host" header or the host name
117	// given in the URL itself. For HTTP/2, it is the value of the
118	// ":authority" pseudo-header field.
119	// It may be of the form "host:port". For international domain
120	// names, Host may be in Punycode or Unicode form. Use
121	// golang.org/x/net/idna to convert it to either format if
122	// needed.
123	// To prevent DNS rebinding attacks, server Handlers should
124	// validate that the Host header has a value for which the
125	// Handler considers itself authoritative. The included
126	// ServeMux supports patterns registered to particular host
127	// names and thus protects its registered Handlers.
128	//
129	// For client requests, Host optionally overrides the Host
130	// header to send. If empty, the Request.Write method uses
131	// the value of URL.Host. Host may contain an international
132	// domain name.
133	Host	string
134
135	// Form contains the parsed form data, including both the URL
136	// field's query parameters and the PATCH, POST, or PUT form data.
137	// This field is only available after ParseForm is called.
138	// The HTTP client ignores Form and uses Body instead.
139	Form	url.Values
140
141	// PostForm contains the parsed form data from PATCH, POST
142	// or PUT body parameters.
143	//
144	// This field is only available after ParseForm is called.
145	// The HTTP client ignores PostForm and uses Body instead.
146	PostForm	url.Values
147
148	// MultipartForm is the parsed multipart form, including file uploads.
149	// This field is only available after ParseMultipartForm is called.
150	// The HTTP client ignores MultipartForm and uses Body instead.
151	MultipartForm	*multipart.Form
152
153	// Trailer specifies additional headers that are sent after the request
154	// body.
155	//
156	// For server requests, the Trailer map initially contains only the
157	// trailer keys, with nil values. (The client declares which trailers it
158	// will later send.)  While the handler is reading from Body, it must
159	// not reference Trailer. After reading from Body returns EOF, Trailer
160	// can be read again and will contain non-nil values, if they were sent
161	// by the client.
162	//
163	// For client requests, Trailer must be initialized to a map containing
164	// the trailer keys to later send. The values may be nil or their final
165	// values. The ContentLength must be 0 or -1, to send a chunked request.
166	// After the HTTP request is sent the map values can be updated while
167	// the request body is read. Once the body returns EOF, the caller must
168	// not mutate Trailer.
169	//
170	// Few HTTP clients, servers, or proxies support HTTP trailers.
171	Trailer	Header
172
173	// RemoteAddr allows HTTP servers and other software to record
174	// the network address that sent the request, usually for
175	// logging. This field is not filled in by ReadRequest and
176	// has no defined format. The HTTP server in this package
177	// sets RemoteAddr to an "IP:port" address before invoking a
178	// handler.
179	// This field is ignored by the HTTP client.
180	RemoteAddr	string
181
182	// RequestURI is the unmodified request-target of the
183	// Request-Line (RFC 7230, Section 3.1.1) as sent by the client
184	// to a server. Usually the URL field should be used instead.
185	// It is an error to set this field in an HTTP client request.
186	RequestURI	string
187
188	// TLS allows HTTP servers and other software to record
189	// information about the TLS connection on which the request
190	// was received. This field is not filled in by ReadRequest.
191	// The HTTP server in this package sets the field for
192	// TLS-enabled connections before invoking a handler;
193	// otherwise it leaves the field nil.
194	// This field is ignored by the HTTP client.
195	TLS	*tls.ConnectionState
196
197	// Cancel is an optional channel whose closure indicates that the client
198	// request should be regarded as canceled. Not all implementations of
199	// RoundTripper may support Cancel.
200	//
201	// For server requests, this field is not applicable.
202	//
203	// Deprecated: Set the Request's context with NewRequestWithContext
204	// instead. If a Request's Cancel field and context are both
205	// set, it is undefined whether Cancel is respected.
206	Cancel	<-chan struct{}
207
208	// Response is the redirect response which caused this request
209	// to be created. This field is only populated during client
210	// redirects.
211	Response	*Response
212
213	// Pattern is the [ServeMux] pattern that matched the request.
214	// It is empty if the request was not matched against a pattern.
215	Pattern	string
216}

 1type Response struct {
 2	Status		string	// e.g. "200 OK"
 3	StatusCode	int	// e.g. 200
 4	Proto		string	// e.g. "HTTP/1.0"
 5	ProtoMajor	int	// e.g. 1
 6	ProtoMinor	int	// e.g. 0
 7
 8	// Header maps header keys to values. If the response had multiple
 9	// headers with the same key, they may be concatenated, with comma
10	// delimiters.  (RFC 7230, section 3.2.2 requires that multiple headers
11	// be semantically equivalent to a comma-delimited sequence.) When
12	// Header values are duplicated by other fields in this struct (e.g.,
13	// ContentLength, TransferEncoding, Trailer), the field values are
14	// authoritative.
15	//
16	// Keys in the map are canonicalized (see CanonicalHeaderKey).
17	Header	Header
18
19	// Body represents the response body.
20	//
21	// The response body is streamed on demand as the Body field
22	// is read. If the network connection fails or the server
23	// terminates the response, Body.Read calls return an error.
24	//
25	// The http Client and Transport guarantee that Body is always
26	// non-nil, even on responses without a body or responses with
27	// a zero-length body. It is the caller's responsibility to
28	// close Body. The default HTTP client's Transport may not
29	// reuse HTTP/1.x "keep-alive" TCP connections if the Body is
30	// not read to completion and closed.
31	//
32	// The Body is automatically dechunked if the server replied
33	// with a "chunked" Transfer-Encoding.
34	//
35	// As of Go 1.12, the Body will also implement io.Writer
36	// on a successful "101 Switching Protocols" response,
37	// as used by WebSockets and HTTP/2's "h2c" mode.
38	Body	io.ReadCloser
39
40	// ContentLength records the length of the associated content. The
41	// value -1 indicates that the length is unknown. Unless Request.Method
42	// is "HEAD", values >= 0 indicate that the given number of bytes may
43	// be read from Body.
44	ContentLength	int64
45
46	// Contains transfer encodings from outer-most to inner-most. Value is
47	// nil, means that "identity" encoding is used.
48	TransferEncoding	[]string
49
50	// Close records whether the header directed that the connection be
51	// closed after reading Body. The value is advice for clients: neither
52	// ReadResponse nor Response.Write ever closes a connection.
53	Close	bool
54
55	// Uncompressed reports whether the response was sent compressed but
56	// was decompressed by the http package. When true, reading from
57	// Body yields the uncompressed content instead of the compressed
58	// content actually set from the server, ContentLength is set to -1,
59	// and the "Content-Length" and "Content-Encoding" fields are deleted
60	// from the responseHeader. To get the original response from
61	// the server, set Transport.DisableCompression to true.
62	Uncompressed	bool
63
64	// Trailer maps trailer keys to values in the same
65	// format as Header.
66	//
67	// The Trailer initially contains only nil values, one for
68	// each key specified in the server's "Trailer" header
69	// value. Those values are not added to Header.
70	//
71	// Trailer must not be accessed concurrently with Read calls
72	// on the Body.
73	//
74	// After Body.Read has returned io.EOF, Trailer will contain
75	// any trailer values sent by the server.
76	Trailer	Header
77
78	// Request is the request that was sent to obtain this Response.
79	// Request's Body is nil (having already been consumed).
80	// This is only populated for Client requests.
81	Request	*Request
82
83	// TLS contains information about the TLS connection on which the
84	// response was received. It is nil for unencrypted responses.
85	// The pointer is shared between responses and should not be
86	// modified.
87	TLS	*tls.ConnectionState
88}

 1type ResponseWriter interface {
 2	// Header returns the header map that will be sent by
 3	// [ResponseWriter.WriteHeader]. The [Header] map also is the mechanism with which
 4	// [Handler] implementations can set HTTP trailers.
 5	//
 6	// Changing the header map after a call to [ResponseWriter.WriteHeader] (or
 7	// [ResponseWriter.Write]) has no effect unless the HTTP status code was of the
 8	// 1xx class or the modified headers are trailers.
 9	//
10	// There are two ways to set Trailers. The preferred way is to
11	// predeclare in the headers which trailers you will later
12	// send by setting the "Trailer" header to the names of the
13	// trailer keys which will come later. In this case, those
14	// keys of the Header map are treated as if they were
15	// trailers. See the example. The second way, for trailer
16	// keys not known to the [Handler] until after the first [ResponseWriter.Write],
17	// is to prefix the [Header] map keys with the [TrailerPrefix]
18	// constant value.
19	//
20	// To suppress automatic response headers (such as "Date"), set
21	// their value to nil.
22	Header() Header
23
24	// Write writes the data to the connection as part of an HTTP reply.
25	//
26	// If [ResponseWriter.WriteHeader] has not yet been called, Write calls
27	// WriteHeader(http.StatusOK) before writing the data. If the Header
28	// does not contain a Content-Type line, Write adds a Content-Type set
29	// to the result of passing the initial 512 bytes of written data to
30	// [DetectContentType]. Additionally, if the total size of all written
31	// data is under a few KB and there are no Flush calls, the
32	// Content-Length header is added automatically.
33	//
34	// Depending on the HTTP protocol version and the client, calling
35	// Write or WriteHeader may prevent future reads on the
36	// Request.Body. For HTTP/1.x requests, handlers should read any
37	// needed request body data before writing the response. Once the
38	// headers have been flushed (due to either an explicit Flusher.Flush
39	// call or writing enough data to trigger a flush), the request body
40	// may be unavailable. For HTTP/2 requests, the Go HTTP server permits
41	// handlers to continue to read the request body while concurrently
42	// writing the response. However, such behavior may not be supported
43	// by all HTTP/2 clients. Handlers should read before writing if
44	// possible to maximize compatibility.
45	Write([]byte) (int, error)
46
47	// WriteHeader sends an HTTP response header with the provided
48	// status code.
49	//
50	// If WriteHeader is not called explicitly, the first call to Write
51	// will trigger an implicit WriteHeader(http.StatusOK).
52	// Thus explicit calls to WriteHeader are mainly used to
53	// send error codes or 1xx informational responses.
54	//
55	// The provided code must be a valid HTTP 1xx-5xx status code.
56	// Any number of 1xx headers may be written, followed by at most
57	// one 2xx-5xx header. 1xx headers are sent immediately, but 2xx-5xx
58	// headers may be buffered. Use the Flusher interface to send
59	// buffered data. The header map is cleared when 2xx-5xx headers are
60	// sent, but not with 1xx headers.
61	//
62	// The server will automatically send a 100 (Continue) header
63	// on the first read from the request body if the request has
64	// an "Expect: 100-continue" header.
65	WriteHeader(statusCode int)
66}

 1type RoundTripper interface {
 2	// RoundTrip executes a single HTTP transaction, returning
 3	// a Response for the provided Request.
 4	//
 5	// RoundTrip should not attempt to interpret the response. In
 6	// particular, RoundTrip must return err == nil if it obtained
 7	// a response, regardless of the response's HTTP status code.
 8	// A non-nil err should be reserved for failure to obtain a
 9	// response. Similarly, RoundTrip should not attempt to
10	// handle higher-level protocol details such as redirects,
11	// authentication, or cookies.
12	//
13	// RoundTrip should not modify the request, except for
14	// consuming and closing the Request's Body. RoundTrip may
15	// read fields of the request in a separate goroutine. Callers
16	// should not mutate or reuse the request until the Response's
17	// Body has been closed.
18	//
19	// RoundTrip must always close the body, including on errors,
20	// but depending on the implementation may do so in a separate
21	// goroutine even after RoundTrip returns. This means that
22	// callers wanting to reuse the body for subsequent requests
23	// must arrange to wait for the Close call before doing so.
24	//
25	// The Request's URL and Header fields must be initialized.
26	RoundTrip(*Request) (*Response, error)
27}

1type ServeMux struct {
2}

  1type Transport struct {
  2
  3	// Proxy specifies a function to return a proxy for a given
  4	// Request. If the function returns a non-nil error, the
  5	// request is aborted with the provided error.
  6	//
  7	// The proxy type is determined by the URL scheme. "http",
  8	// "https", "socks5", and "socks5h" are supported. If the scheme is empty,
  9	// "http" is assumed.
 10	// "socks5" is treated the same as "socks5h".
 11	//
 12	// If the proxy URL contains a userinfo subcomponent,
 13	// the proxy request will pass the username and password
 14	// in a Proxy-Authorization header.
 15	//
 16	// If Proxy is nil or returns a nil *URL, no proxy is used.
 17	Proxy	func(*Request) (*url.URL, error)
 18
 19	// OnProxyConnectResponse is called when the Transport gets an HTTP response from
 20	// a proxy for a CONNECT request. It's called before the check for a 200 OK response.
 21	// If it returns an error, the request fails with that error.
 22	OnProxyConnectResponse	func(ctx context.Context, proxyURL *url.URL, connectReq *Request, connectRes *Response) error
 23
 24	// DialContext specifies the dial function for creating unencrypted TCP connections.
 25	// If DialContext is nil (and the deprecated Dial below is also nil),
 26	// then the transport dials using package net.
 27	//
 28	// DialContext runs concurrently with calls to RoundTrip.
 29	// A RoundTrip call that initiates a dial may end up using
 30	// a connection dialed previously when the earlier connection
 31	// becomes idle before the later DialContext completes.
 32	DialContext	func(ctx context.Context, network, addr string) (net.Conn, error)
 33
 34	// Dial specifies the dial function for creating unencrypted TCP connections.
 35	//
 36	// Dial runs concurrently with calls to RoundTrip.
 37	// A RoundTrip call that initiates a dial may end up using
 38	// a connection dialed previously when the earlier connection
 39	// becomes idle before the later Dial completes.
 40	//
 41	// Deprecated: Use DialContext instead, which allows the transport
 42	// to cancel dials as soon as they are no longer needed.
 43	// If both are set, DialContext takes priority.
 44	Dial	func(network, addr string) (net.Conn, error)
 45
 46	// DialTLSContext specifies an optional dial function for creating
 47	// TLS connections for non-proxied HTTPS requests.
 48	//
 49	// If DialTLSContext is nil (and the deprecated DialTLS below is also nil),
 50	// DialContext and TLSClientConfig are used.
 51	//
 52	// If DialTLSContext is set, the Dial and DialContext hooks are not used for HTTPS
 53	// requests and the TLSClientConfig and TLSHandshakeTimeout
 54	// are ignored. The returned net.Conn is assumed to already be
 55	// past the TLS handshake.
 56	DialTLSContext	func(ctx context.Context, network, addr string) (net.Conn, error)
 57
 58	// DialTLS specifies an optional dial function for creating
 59	// TLS connections for non-proxied HTTPS requests.
 60	//
 61	// Deprecated: Use DialTLSContext instead, which allows the transport
 62	// to cancel dials as soon as they are no longer needed.
 63	// If both are set, DialTLSContext takes priority.
 64	DialTLS	func(network, addr string) (net.Conn, error)
 65
 66	// TLSClientConfig specifies the TLS configuration to use with
 67	// tls.Client.
 68	// If nil, the default configuration is used.
 69	// If non-nil, HTTP/2 support may not be enabled by default.
 70	TLSClientConfig	*tls.Config
 71
 72	// TLSHandshakeTimeout specifies the maximum amount of time to
 73	// wait for a TLS handshake. Zero means no timeout.
 74	TLSHandshakeTimeout	time.Duration
 75
 76	// DisableKeepAlives, if true, disables HTTP keep-alives and
 77	// will only use the connection to the server for a single
 78	// HTTP request.
 79	//
 80	// This is unrelated to the similarly named TCP keep-alives.
 81	DisableKeepAlives	bool
 82
 83	// DisableCompression, if true, prevents the Transport from
 84	// requesting compression with an "Accept-Encoding: gzip"
 85	// request header when the Request contains no existing
 86	// Accept-Encoding value. If the Transport requests gzip on
 87	// its own and gets a gzipped response, it's transparently
 88	// decoded in the Response.Body. However, if the user
 89	// explicitly requested gzip it is not automatically
 90	// uncompressed.
 91	DisableCompression	bool
 92
 93	// MaxIdleConns controls the maximum number of idle (keep-alive)
 94	// connections across all hosts. Zero means no limit.
 95	MaxIdleConns	int
 96
 97	// MaxIdleConnsPerHost, if non-zero, controls the maximum idle
 98	// (keep-alive) connections to keep per-host. If zero,
 99	// DefaultMaxIdleConnsPerHost is used.
100	MaxIdleConnsPerHost	int
101
102	// MaxConnsPerHost optionally limits the total number of
103	// connections per host, including connections in the dialing,
104	// active, and idle states. On limit violation, dials will block.
105	//
106	// Zero means no limit.
107	MaxConnsPerHost	int
108
109	// IdleConnTimeout is the maximum amount of time an idle
110	// (keep-alive) connection will remain idle before closing
111	// itself.
112	// Zero means no limit.
113	IdleConnTimeout	time.Duration
114
115	// ResponseHeaderTimeout, if non-zero, specifies the amount of
116	// time to wait for a server's response headers after fully
117	// writing the request (including its body, if any). This
118	// time does not include the time to read the response body.
119	ResponseHeaderTimeout	time.Duration
120
121	// ExpectContinueTimeout, if non-zero, specifies the amount of
122	// time to wait for a server's first response headers after fully
123	// writing the request headers if the request has an
124	// "Expect: 100-continue" header. Zero means no timeout and
125	// causes the body to be sent immediately, without
126	// waiting for the server to approve.
127	// This time does not include the time to send the request header.
128	ExpectContinueTimeout	time.Duration
129
130	// TLSNextProto specifies how the Transport switches to an
131	// alternate protocol (such as HTTP/2) after a TLS ALPN
132	// protocol negotiation. If Transport dials a TLS connection
133	// with a non-empty protocol name and TLSNextProto contains a
134	// map entry for that key (such as "h2"), then the func is
135	// called with the request's authority (such as "example.com"
136	// or "example.com:1234") and the TLS connection. The function
137	// must return a RoundTripper that then handles the request.
138	// If TLSNextProto is not nil, HTTP/2 support is not enabled
139	// automatically.
140	TLSNextProto	map[string]func(authority string, c *tls.Conn) RoundTripper
141
142	// ProxyConnectHeader optionally specifies headers to send to
143	// proxies during CONNECT requests.
144	// To set the header dynamically, see GetProxyConnectHeader.
145	ProxyConnectHeader	Header
146
147	// GetProxyConnectHeader optionally specifies a func to return
148	// headers to send to proxyURL during a CONNECT request to the
149	// ip:port target.
150	// If it returns an error, the Transport's RoundTrip fails with
151	// that error. It can return (nil, nil) to not add headers.
152	// If GetProxyConnectHeader is non-nil, ProxyConnectHeader is
153	// ignored.
154	GetProxyConnectHeader	func(ctx context.Context, proxyURL *url.URL, target string) (Header, error)
155
156	// MaxResponseHeaderBytes specifies a limit on how many
157	// response bytes are allowed in the server's response
158	// header.
159	//
160	// Zero means to use a default limit.
161	MaxResponseHeaderBytes	int64
162
163	// WriteBufferSize specifies the size of the write buffer used
164	// when writing to the transport.
165	// If zero, a default (currently 4KB) is used.
166	WriteBufferSize	int
167
168	// ReadBufferSize specifies the size of the read buffer used
169	// when reading from the transport.
170	// If zero, a default (currently 4KB) is used.
171	ReadBufferSize	int
172
173	// ForceAttemptHTTP2 controls whether HTTP/2 is enabled when a non-zero
174	// Dial, DialTLS, or DialContext func or TLSClientConfig is provided.
175	// By default, use of any those fields conservatively disables HTTP/2.
176	// To use a custom dialer or TLS config and still attempt HTTP/2
177	// upgrades, set this to true.
178	ForceAttemptHTTP2	bool
179}