Documentation

Overview

    Package http provides HTTP client and server implementations.

    Get, Head, Post, and PostForm make HTTP requests:

    resp, err := http.Get("http://example.com/")
    ...
    resp, err := http.Post("http://example.com/upload", "image/jpeg", &buf)
    ...
    resp, err := http.PostForm("http://example.com/form",
    	url.Values{"key": {"Value"}, "id": {"123"}})
    

    The client must close the response body when finished with it:

    resp, err := http.Get("http://example.com/")
    if err != nil {
    	// handle error
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    // ...
    

    For control over HTTP client headers, redirect policy, and other settings, create a Client:

    client := &http.Client{
    	CheckRedirect: redirectPolicyFunc,
    }
    
    resp, err := client.Get("http://example.com")
    // ...
    
    req, err := http.NewRequest("GET", "http://example.com", nil)
    // ...
    req.Header.Add("If-None-Match", `W/"wyzzy"`)
    resp, err := client.Do(req)
    // ...
    

    For control over proxies, TLS configuration, keep-alives, compression, and other settings, create a Transport:

    tr := &http.Transport{
    	TLSClientConfig:    &tls.Config{RootCAs: pool},
    	DisableCompression: true,
    }
    client := &http.Client{Transport: tr}
    resp, err := client.Get("https://example.com")
    

    Clients and Transports are safe for concurrent use by multiple goroutines and for efficiency should only be created once and re-used.

    ListenAndServe starts an HTTP server with a given address and handler. The handler is usually nil, which means to use DefaultServeMux. Handle and HandleFunc add handlers to DefaultServeMux:

    http.Handle("/foo", fooHandler)
    
    http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
    	fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
    })
    
    log.Fatal(http.ListenAndServe(":8080", nil))
    

    More control over the server's behavior is available by creating a custom Server:

    s := &http.Server{
    	Addr:           ":8080",
    	Handler:        myHandler,
    	ReadTimeout:    10 * time.Second,
    	WriteTimeout:   10 * time.Second,
    	MaxHeaderBytes: 1 << 20,
    }
    log.Fatal(s.ListenAndServe())
    

    Index

    Examples

    Constants

    View Source
    const (
    	StatusContinue           = 100
    	StatusSwitchingProtocols = 101
    
    	StatusOK                   = 200
    	StatusCreated              = 201
    	StatusAccepted             = 202
    	StatusNonAuthoritativeInfo = 203
    	StatusNoContent            = 204
    	StatusResetContent         = 205
    	StatusPartialContent       = 206
    
    	StatusMultipleChoices   = 300
    	StatusMovedPermanently  = 301
    	StatusFound             = 302
    	StatusSeeOther          = 303
    	StatusNotModified       = 304
    	StatusUseProxy          = 305
    	StatusTemporaryRedirect = 307
    
    	StatusBadRequest                   = 400
    	StatusUnauthorized                 = 401
    	StatusPaymentRequired              = 402
    	StatusForbidden                    = 403
    	StatusNotFound                     = 404
    	StatusMethodNotAllowed             = 405
    	StatusNotAcceptable                = 406
    	StatusProxyAuthRequired            = 407
    	StatusRequestTimeout               = 408
    	StatusConflict                     = 409
    	StatusGone                         = 410
    	StatusLengthRequired               = 411
    	StatusPreconditionFailed           = 412
    	StatusRequestEntityTooLarge        = 413
    	StatusRequestURITooLong            = 414
    	StatusUnsupportedMediaType         = 415
    	StatusRequestedRangeNotSatisfiable = 416
    	StatusExpectationFailed            = 417
    	StatusTeapot                       = 418
    
    	StatusInternalServerError     = 500
    	StatusNotImplemented          = 501
    	StatusBadGateway              = 502
    	StatusServiceUnavailable      = 503
    	StatusGatewayTimeout          = 504
    	StatusHTTPVersionNotSupported = 505
    )

      HTTP status codes, defined in RFC 2616.

      View Source
      const DefaultMaxHeaderBytes = 1 << 20 // 1 MB
      

        DefaultMaxHeaderBytes is the maximum permitted size of the headers in an HTTP request. This can be overridden by setting Server.MaxHeaderBytes.

        View Source
        const DefaultMaxIdleConnsPerHost = 2

          DefaultMaxIdleConnsPerHost is the default value of Transport's MaxIdleConnsPerHost.

          View Source
          const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"

            TimeFormat is the time format to use with time.Parse and time.Time.Format when parsing or generating times in HTTP headers. It is like time.RFC1123 but hard codes GMT as the time zone.

            Variables

            View Source
            var (
            	ErrHeaderTooLong        = &ProtocolError{"header too long"}
            	ErrShortBody            = &ProtocolError{"entity body too short"}
            	ErrNotSupported         = &ProtocolError{"feature not supported"}
            	ErrUnexpectedTrailer    = &ProtocolError{"trailer header without chunked transfer encoding"}
            	ErrMissingContentLength = &ProtocolError{"missing ContentLength in HEAD response"}
            	ErrNotMultipart         = &ProtocolError{"request Content-Type isn't multipart/form-data"}
            	ErrMissingBoundary      = &ProtocolError{"no multipart boundary param Content-Type"}
            )
            View Source
            var (
            	ErrWriteAfterFlush = errors.New("Conn.Write called after Flush")
            	ErrBodyNotAllowed  = errors.New("http: response status code does not allow body")
            	ErrHijacked        = errors.New("Conn has been hijacked")
            	ErrContentLength   = errors.New("Conn.Write wrote more than the declared Content-Length")
            )

              Errors introduced by the HTTP server.

              View Source
              var DefaultClient = &Client{}

                DefaultClient is the default Client and is used by Get, Head, and Post.

                View Source
                var DefaultServeMux = NewServeMux()

                  DefaultServeMux is the default ServeMux used by Serve.

                  View Source
                  var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed request Body")

                    ErrBodyReadAfterClose is returned when reading a Request Body after the body has been closed. This typically happens when the body is read after an HTTP Handler calls WriteHeader or Write on its ResponseWriter.

                    View Source
                    var ErrHandlerTimeout = errors.New("http: Handler timeout")

                      ErrHandlerTimeout is returned on ResponseWriter Write calls in handlers which have timed out.

                      View Source
                      var ErrLineTooLong = errors.New("header line too long")
                      View Source
                      var ErrMissingFile = errors.New("http: no such file")

                        ErrMissingFile is returned by FormFile when the provided file field name is either not present in the request or not a file field.

                        View Source
                        var ErrNoCookie = errors.New("http: named cookie not present")
                        View Source
                        var ErrNoLocation = errors.New("http: no Location header in response")

                        Functions

                        func CanonicalHeaderKey

                        func CanonicalHeaderKey(s string) string

                          CanonicalHeaderKey returns the canonical format of the header key s. The canonicalization converts the first letter and any letter following a hyphen to upper case; the rest are converted to lowercase. For example, the canonical key for "accept-encoding" is "Accept-Encoding".

                          func DetectContentType

                          func DetectContentType(data []byte) string

                            DetectContentType implements the algorithm described at http://mimesniff.spec.whatwg.org/ to determine the Content-Type of the given data. It considers at most the first 512 bytes of data. DetectContentType always returns a valid MIME type: if it cannot determine a more specific one, it returns "application/octet-stream".

                            func Error

                            func Error(w ResponseWriter, error string, code int)

                              Error replies to the request with the specified error message and HTTP code.

                              func Handle

                              func Handle(pattern string, handler Handler)

                                Handle registers the handler for the given pattern in the DefaultServeMux. The documentation for ServeMux explains how patterns are matched.

                                func HandleFunc

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

                                  HandleFunc registers the handler function for the given pattern in the DefaultServeMux. The documentation for ServeMux explains how patterns are matched.

                                  func ListenAndServe

                                  func ListenAndServe(addr string, handler Handler) error

                                    ListenAndServe listens on the TCP network address addr and then calls Serve with handler to handle requests on incoming connections. Handler is typically nil, in which case the DefaultServeMux is used.

                                    A trivial example server is:

                                    package main
                                    
                                    import (
                                    	"io"
                                    	"net/http"
                                    	"log"
                                    )
                                    
                                    // hello world, the web server
                                    func HelloServer(w http.ResponseWriter, req *http.Request) {
                                    	io.WriteString(w, "hello, world!\n")
                                    }
                                    
                                    func main() {
                                    	http.HandleFunc("/hello", HelloServer)
                                    	err := http.ListenAndServe(":12345", nil)
                                    	if err != nil {
                                    		log.Fatal("ListenAndServe: ", err)
                                    	}
                                    }
                                    

                                    func ListenAndServeTLS

                                    func ListenAndServeTLS(addr string, certFile string, keyFile string, handler Handler) error

                                      ListenAndServeTLS acts identically to ListenAndServe, except that it expects HTTPS connections. Additionally, files containing a certificate and matching private key for the server must be provided. If the certificate is signed by a certificate authority, the certFile should be the concatenation of the server's certificate followed by the CA's certificate.

                                      A trivial example server is:

                                      import (
                                      	"log"
                                      	"net/http"
                                      )
                                      
                                      func handler(w http.ResponseWriter, req *http.Request) {
                                      	w.Header().Set("Content-Type", "text/plain")
                                      	w.Write([]byte("This is an example server.\n"))
                                      }
                                      
                                      func main() {
                                      	http.HandleFunc("/", handler)
                                      	log.Printf("About to listen on 10443. Go to https://127.0.0.1:10443/")
                                      	err := http.ListenAndServeTLS(":10443", "cert.pem", "key.pem", nil)
                                      	if err != nil {
                                      		log.Fatal(err)
                                      	}
                                      }
                                      

                                      One can use generate_cert.go in crypto/tls to generate cert.pem and key.pem.

                                      func MaxBytesReader

                                      func MaxBytesReader(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser

                                        MaxBytesReader is similar to io.LimitReader but is intended for limiting the size of incoming request bodies. In contrast to io.LimitReader, MaxBytesReader's result is a ReadCloser, returns a non-EOF error for a Read beyond the limit, and Closes the underlying reader when its Close method is called.

                                        MaxBytesReader prevents clients from accidentally or maliciously sending a large request and wasting server resources.

                                        func NotFound

                                        func NotFound(w ResponseWriter, r *Request)

                                          NotFound replies to the request with an HTTP 404 not found error.

                                          func ParseHTTPVersion

                                          func ParseHTTPVersion(vers string) (major, minor int, ok bool)

                                            ParseHTTPVersion parses a HTTP version string. "HTTP/1.0" returns (1, 0, true).

                                            func ProxyFromEnvironment

                                            func ProxyFromEnvironment(req *Request) (*url.URL, error)

                                              ProxyFromEnvironment returns the URL of the proxy to use for a given request, as indicated by the environment variables $HTTP_PROXY and $NO_PROXY (or $http_proxy and $no_proxy). An error is returned if the proxy environment is invalid. A nil URL and nil error are returned if no proxy is defined in the environment, or a proxy should not be used for the given request.

                                              func ProxyURL

                                              func ProxyURL(fixedURL *url.URL) func(*Request) (*url.URL, error)

                                                ProxyURL returns a proxy function (for use in a Transport) that always returns the same URL.

                                                func Redirect

                                                func Redirect(w ResponseWriter, r *Request, urlStr string, code int)

                                                  Redirect replies to the request with a redirect to url, which may be a path relative to the request path.

                                                  func Serve

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

                                                    Serve accepts incoming HTTP connections on the listener l, creating a new service thread for each. The service threads read requests and then call handler to reply to them. Handler is typically nil, in which case the DefaultServeMux is used.

                                                    func ServeContent

                                                    func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker)

                                                      ServeContent replies to the request using the content in the provided ReadSeeker. The main benefit of ServeContent over io.Copy is that it handles Range requests properly, sets the MIME type, and handles If-Modified-Since requests.

                                                      If the response's Content-Type header is not set, ServeContent first tries to deduce the type from name's file extension and, if that fails, falls back to reading the first block of the content and passing it to DetectContentType. The name is otherwise unused; in particular it can be empty and is never sent in the response.

                                                      If modtime is not the zero time, ServeContent includes it in a Last-Modified header in the response. If the request includes an If-Modified-Since header, ServeContent uses modtime to decide whether the content needs to be sent at all.

                                                      The content's Seek method must work: ServeContent uses a seek to the end of the content to determine its size.

                                                      Note that *os.File implements the io.ReadSeeker interface.

                                                      func ServeFile

                                                      func ServeFile(w ResponseWriter, r *Request, name string)

                                                        ServeFile replies to the request with the contents of the named file or directory.

                                                        func SetCookie

                                                        func SetCookie(w ResponseWriter, cookie *Cookie)

                                                          SetCookie adds a Set-Cookie header to the provided ResponseWriter's headers.

                                                          func StatusText

                                                          func StatusText(code int) string

                                                            StatusText returns a text for the HTTP status code. It returns the empty string if the code is unknown.

                                                            Types

                                                            type Client

                                                            type Client struct {
                                                            	// Transport specifies the mechanism by which individual
                                                            	// HTTP requests are made.
                                                            	// If nil, DefaultTransport is used.
                                                            	Transport RoundTripper
                                                            
                                                            	// CheckRedirect specifies the policy for handling redirects.
                                                            	// If CheckRedirect is not nil, the client calls it before
                                                            	// following an HTTP redirect. The arguments req and via
                                                            	// are the upcoming request and the requests made already,
                                                            	// oldest first. If CheckRedirect returns an error, the client
                                                            	// returns that error instead of issue the Request req.
                                                            	//
                                                            	// If CheckRedirect is nil, the Client uses its default policy,
                                                            	// which is to stop after 10 consecutive requests.
                                                            	CheckRedirect func(req *Request, via []*Request) error
                                                            
                                                            	// Jar specifies the cookie jar.
                                                            	// If Jar is nil, cookies are not sent in requests and ignored
                                                            	// in responses.
                                                            	Jar CookieJar
                                                            }

                                                              A Client is an HTTP client. Its zero value (DefaultClient) is a usable client that uses DefaultTransport.

                                                              The Client's Transport typically has internal state (cached TCP connections), so Clients should be reused instead of created as needed. Clients are safe for concurrent use by multiple goroutines.

                                                              func (*Client) Do

                                                              func (c *Client) Do(req *Request) (resp *Response, err error)

                                                                Do sends an HTTP request and returns an HTTP response, following policy (e.g. redirects, cookies, auth) as configured on the client.

                                                                A non-nil response always contains a non-nil resp.Body.

                                                                Callers should close resp.Body when done reading from it. If resp.Body is not closed, the Client's underlying RoundTripper (typically Transport) may not be able to re-use a persistent TCP connection to the server for a subsequent "keep-alive" request.

                                                                Generally Get, Post, or PostForm will be used instead of Do.

                                                                func (*Client) Get

                                                                func (c *Client) Get(url string) (r *Response, err error)

                                                                  Get issues a GET to the specified URL. If the response is one of the following redirect codes, Get follows the redirect after calling the Client's CheckRedirect function.

                                                                  301 (Moved Permanently)
                                                                  302 (Found)
                                                                  303 (See Other)
                                                                  307 (Temporary Redirect)
                                                                  

                                                                  Caller should close r.Body when done reading from it.

                                                                  func (*Client) Head

                                                                  func (c *Client) Head(url string) (r *Response, err error)

                                                                    Head issues a HEAD to the specified URL. If the response is one of the following redirect codes, Head follows the redirect after calling the Client's CheckRedirect function.

                                                                    301 (Moved Permanently)
                                                                    302 (Found)
                                                                    303 (See Other)
                                                                    307 (Temporary Redirect)
                                                                    

                                                                    func (*Client) Post

                                                                    func (c *Client) Post(url string, bodyType string, body io.Reader) (r *Response, err error)

                                                                      Post issues a POST to the specified URL.

                                                                      Caller should close r.Body when done reading from it.

                                                                      func (*Client) PostForm

                                                                      func (c *Client) PostForm(url string, data url.Values) (r *Response, err error)

                                                                        PostForm issues a POST to the specified URL, with data's keys and values urlencoded as the request body.

                                                                        Caller should close r.Body when done reading from it.

                                                                        type Cookie struct {
                                                                        	Name       string
                                                                        	Value      string
                                                                        	Path       string
                                                                        	Domain     string
                                                                        	Expires    time.Time
                                                                        	RawExpires string
                                                                        
                                                                        	// MaxAge=0 means no 'Max-Age' attribute specified.
                                                                        	// MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
                                                                        	// MaxAge>0 means Max-Age attribute present and given in seconds
                                                                        	MaxAge   int
                                                                        	Secure   bool
                                                                        	HttpOnly bool
                                                                        	Raw      string
                                                                        	Unparsed []string // Raw text of unparsed attribute-value pairs
                                                                        }

                                                                          A Cookie represents an HTTP cookie as sent in the Set-Cookie header of an HTTP response or the Cookie header of an HTTP request.

                                                                          func (*Cookie) String

                                                                          func (c *Cookie) String() string

                                                                            String returns the serialization of the cookie for use in a Cookie header (if only Name and Value are set) or a Set-Cookie response header (if other fields are set).

                                                                            type CookieJar

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

                                                                              A CookieJar manages storage and use of cookies in HTTP requests.

                                                                              Implementations of CookieJar must be safe for concurrent use by multiple goroutines.

                                                                              type Dir

                                                                              type Dir string

                                                                                A Dir implements http.FileSystem using the native file system restricted to a specific directory tree.

                                                                                An empty Dir is treated as ".".

                                                                                func (Dir) Open

                                                                                func (d Dir) Open(name string) (File, error)

                                                                                type File

                                                                                type File interface {
                                                                                	Close() error
                                                                                	Stat() (os.FileInfo, error)
                                                                                	Readdir(count int) ([]os.FileInfo, error)
                                                                                	Read([]byte) (int, error)
                                                                                	Seek(offset int64, whence int) (int64, error)
                                                                                }

                                                                                  A File is returned by a FileSystem's Open method and can be served by the FileServer implementation.

                                                                                  type FileSystem

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

                                                                                    A FileSystem implements access to a collection of named files. The elements in a file path are separated by slash ('/', U+002F) characters, regardless of host operating system convention.

                                                                                    type Flusher

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

                                                                                      The Flusher interface is implemented by ResponseWriters that allow an HTTP handler to flush buffered data to the client.

                                                                                      Note that even for ResponseWriters that support Flush, if the client is connected through an HTTP proxy, the buffered data may not reach the client until the response completes.

                                                                                      type Handler

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

                                                                                        Objects implementing the Handler interface can be registered to serve a particular path or subtree in the HTTP server.

                                                                                        ServeHTTP should write reply headers and data to the ResponseWriter and then return. Returning signals that the request is finished and that the HTTP server can move on to the next request on the connection.

                                                                                        func FileServer

                                                                                        func FileServer(root FileSystem) Handler

                                                                                          FileServer returns a handler that serves HTTP requests with the contents of the file system rooted at root.

                                                                                          To use the operating system's file system implementation, use http.Dir:

                                                                                          http.Handle("/", http.FileServer(http.Dir("/tmp")))
                                                                                          
                                                                                          Example
                                                                                          Output:
                                                                                          
                                                                                          

                                                                                          func NotFoundHandler

                                                                                          func NotFoundHandler() Handler

                                                                                            NotFoundHandler returns a simple request handler that replies to each request with a “404 page not found” reply.

                                                                                            func RedirectHandler

                                                                                            func RedirectHandler(url string, code int) Handler

                                                                                              RedirectHandler returns a request handler that redirects each request it receives to the given url using the given status code.

                                                                                              func StripPrefix

                                                                                              func StripPrefix(prefix string, h Handler) Handler

                                                                                                StripPrefix returns a handler that serves HTTP requests by removing the given prefix from the request URL's Path and invoking the handler h. StripPrefix handles a request for a path that doesn't begin with prefix by replying with an HTTP 404 not found error.

                                                                                                func TimeoutHandler

                                                                                                func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler

                                                                                                  TimeoutHandler returns a Handler that runs h with the given time limit.

                                                                                                  The new Handler calls h.ServeHTTP to handle each request, but if a call runs for more than ns nanoseconds, the handler responds with a 503 Service Unavailable error and the given message in its body. (If msg is empty, a suitable default message will be sent.) After such a timeout, writes by h to its ResponseWriter will return ErrHandlerTimeout.

                                                                                                  type HandlerFunc

                                                                                                  type HandlerFunc func(ResponseWriter, *Request)

                                                                                                    The HandlerFunc type is an adapter to allow the use of ordinary functions as HTTP handlers. If f is a function with the appropriate signature, HandlerFunc(f) is a Handler object that calls f.

                                                                                                    func (HandlerFunc) ServeHTTP

                                                                                                    func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request)

                                                                                                      ServeHTTP calls f(w, r).

                                                                                                      type Header map[string][]string

                                                                                                        A Header represents the key-value pairs in an HTTP header.

                                                                                                        func (Header) Add

                                                                                                        func (h Header) Add(key, value string)

                                                                                                          Add adds the key, value pair to the header. It appends to any existing values associated with key.

                                                                                                          func (Header) Del

                                                                                                          func (h Header) Del(key string)

                                                                                                            Del deletes the values associated with key.

                                                                                                            func (Header) Get

                                                                                                            func (h Header) Get(key string) string

                                                                                                              Get gets the first value associated with the given key. If there are no values associated with the key, Get returns "". To access multiple values of a key, access the map directly with CanonicalHeaderKey.

                                                                                                              func (Header) Set

                                                                                                              func (h Header) Set(key, value string)

                                                                                                                Set sets the header entries associated with key to the single element value. It replaces any existing values associated with key.

                                                                                                                func (Header) Write

                                                                                                                func (h Header) Write(w io.Writer) error

                                                                                                                  Write writes a header in wire format.

                                                                                                                  func (Header) WriteSubset

                                                                                                                  func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error

                                                                                                                    WriteSubset writes a header in wire format. If exclude is not nil, keys where exclude[key] == true are not written.

                                                                                                                    type Hijacker

                                                                                                                    type Hijacker interface {
                                                                                                                    	// Hijack lets the caller take over the connection.
                                                                                                                    	// After a call to Hijack(), the HTTP server library
                                                                                                                    	// will not do anything else with the connection.
                                                                                                                    	// It becomes the caller's responsibility to manage
                                                                                                                    	// and close the connection.
                                                                                                                    	Hijack() (net.Conn, *bufio.ReadWriter, error)
                                                                                                                    }

                                                                                                                      The Hijacker interface is implemented by ResponseWriters that allow an HTTP handler to take over the connection.

                                                                                                                      Example
                                                                                                                      Output:
                                                                                                                      
                                                                                                                      

                                                                                                                      type ProtocolError

                                                                                                                      type ProtocolError struct {
                                                                                                                      	ErrorString string
                                                                                                                      }

                                                                                                                        HTTP request parsing errors.

                                                                                                                        func (*ProtocolError) Error

                                                                                                                        func (err *ProtocolError) Error() string

                                                                                                                        type Request

                                                                                                                        type Request struct {
                                                                                                                        	Method string // GET, POST, PUT, etc.
                                                                                                                        	URL    *url.URL
                                                                                                                        
                                                                                                                        	// The protocol version for incoming requests.
                                                                                                                        	// Outgoing requests always use HTTP/1.1.
                                                                                                                        	Proto      string // "HTTP/1.0"
                                                                                                                        	ProtoMajor int    // 1
                                                                                                                        	ProtoMinor int    // 0
                                                                                                                        
                                                                                                                        	// A header maps request lines to their values.
                                                                                                                        	// If the header says
                                                                                                                        	//
                                                                                                                        	//	accept-encoding: gzip, deflate
                                                                                                                        	//	Accept-Language: en-us
                                                                                                                        	//	Connection: keep-alive
                                                                                                                        	//
                                                                                                                        	// then
                                                                                                                        	//
                                                                                                                        	//	Header = map[string][]string{
                                                                                                                        	//		"Accept-Encoding": {"gzip, deflate"},
                                                                                                                        	//		"Accept-Language": {"en-us"},
                                                                                                                        	//		"Connection": {"keep-alive"},
                                                                                                                        	//	}
                                                                                                                        	//
                                                                                                                        	// HTTP defines that header names are case-insensitive.
                                                                                                                        	// The request parser implements this by canonicalizing the
                                                                                                                        	// name, making the first character and any characters
                                                                                                                        	// following a hyphen uppercase and the rest lowercase.
                                                                                                                        	Header Header
                                                                                                                        
                                                                                                                        	// The message body.
                                                                                                                        	Body io.ReadCloser
                                                                                                                        
                                                                                                                        	// ContentLength records the length of the associated content.
                                                                                                                        	// The value -1 indicates that the length is unknown.
                                                                                                                        	// Values >= 0 indicate that the given number of bytes may
                                                                                                                        	// be read from Body.
                                                                                                                        	// For outgoing requests, a value of 0 means unknown if Body is not nil.
                                                                                                                        	ContentLength int64
                                                                                                                        
                                                                                                                        	// TransferEncoding lists the transfer encodings from outermost to
                                                                                                                        	// innermost. An empty list denotes the "identity" encoding.
                                                                                                                        	// TransferEncoding can usually be ignored; chunked encoding is
                                                                                                                        	// automatically added and removed as necessary when sending and
                                                                                                                        	// receiving requests.
                                                                                                                        	TransferEncoding []string
                                                                                                                        
                                                                                                                        	// Close indicates whether to close the connection after
                                                                                                                        	// replying to this request.
                                                                                                                        	Close bool
                                                                                                                        
                                                                                                                        	// The host on which the URL is sought.
                                                                                                                        	// Per RFC 2616, this is either the value of the Host: header
                                                                                                                        	// or the host name given in the URL itself.
                                                                                                                        	Host string
                                                                                                                        
                                                                                                                        	// Form contains the parsed form data, including both the URL
                                                                                                                        	// field's query parameters and the POST or PUT form data.
                                                                                                                        	// This field is only available after ParseForm is called.
                                                                                                                        	// The HTTP client ignores Form and uses Body instead.
                                                                                                                        	Form url.Values
                                                                                                                        
                                                                                                                        	// MultipartForm is the parsed multipart form, including file uploads.
                                                                                                                        	// This field is only available after ParseMultipartForm is called.
                                                                                                                        	// The HTTP client ignores MultipartForm and uses Body instead.
                                                                                                                        	MultipartForm *multipart.Form
                                                                                                                        
                                                                                                                        	// Trailer maps trailer keys to values.  Like for Header, if the
                                                                                                                        	// response has multiple trailer lines with the same key, they will be
                                                                                                                        	// concatenated, delimited by commas.
                                                                                                                        	// For server requests, Trailer is only populated after Body has been
                                                                                                                        	// closed or fully consumed.
                                                                                                                        	// Trailer support is only partially complete.
                                                                                                                        	Trailer Header
                                                                                                                        
                                                                                                                        	// RemoteAddr allows HTTP servers and other software to record
                                                                                                                        	// the network address that sent the request, usually for
                                                                                                                        	// logging. This field is not filled in by ReadRequest and
                                                                                                                        	// has no defined format. The HTTP server in this package
                                                                                                                        	// sets RemoteAddr to an "IP:port" address before invoking a
                                                                                                                        	// handler.
                                                                                                                        	// This field is ignored by the HTTP client.
                                                                                                                        	RemoteAddr string
                                                                                                                        
                                                                                                                        	// RequestURI is the unmodified Request-URI of the
                                                                                                                        	// Request-Line (RFC 2616, Section 5.1) as sent by the client
                                                                                                                        	// to a server. Usually the URL field should be used instead.
                                                                                                                        	// It is an error to set this field in an HTTP client request.
                                                                                                                        	RequestURI string
                                                                                                                        
                                                                                                                        	// TLS allows HTTP servers and other software to record
                                                                                                                        	// information about the TLS connection on which the request
                                                                                                                        	// was received. This field is not filled in by ReadRequest.
                                                                                                                        	// The HTTP server in this package sets the field for
                                                                                                                        	// TLS-enabled connections before invoking a handler;
                                                                                                                        	// otherwise it leaves the field nil.
                                                                                                                        	// This field is ignored by the HTTP client.
                                                                                                                        	TLS *tls.ConnectionState
                                                                                                                        }

                                                                                                                          A Request represents an HTTP request received by a server or to be sent by a client.

                                                                                                                          func NewRequest

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

                                                                                                                            NewRequest returns a new Request given a method, URL, and optional body.

                                                                                                                            func ReadRequest

                                                                                                                            func ReadRequest(b *bufio.Reader) (req *Request, err error)

                                                                                                                              ReadRequest reads and parses a request from b.

                                                                                                                              func (*Request) AddCookie

                                                                                                                              func (r *Request) AddCookie(c *Cookie)

                                                                                                                                AddCookie adds a cookie to the request. Per RFC 6265 section 5.4, AddCookie does not attach more than one Cookie header field. That means all cookies, if any, are written into the same line, separated by semicolon.

                                                                                                                                func (*Request) Cookie

                                                                                                                                func (r *Request) Cookie(name string) (*Cookie, error)

                                                                                                                                  Cookie returns the named cookie provided in the request or ErrNoCookie if not found.

                                                                                                                                  func (*Request) Cookies

                                                                                                                                  func (r *Request) Cookies() []*Cookie

                                                                                                                                    Cookies parses and returns the HTTP cookies sent with the request.

                                                                                                                                    func (*Request) FormFile

                                                                                                                                    func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error)

                                                                                                                                      FormFile returns the first file for the provided form key. FormFile calls ParseMultipartForm and ParseForm if necessary.

                                                                                                                                      func (*Request) FormValue

                                                                                                                                      func (r *Request) FormValue(key string) string

                                                                                                                                        FormValue returns the first value for the named component of the query. FormValue calls ParseMultipartForm and ParseForm if necessary.

                                                                                                                                        func (*Request) MultipartReader

                                                                                                                                        func (r *Request) MultipartReader() (*multipart.Reader, error)

                                                                                                                                          MultipartReader returns a MIME multipart reader if this is a multipart/form-data POST request, else returns nil and an error. Use this function instead of ParseMultipartForm to process the request body as a stream.

                                                                                                                                          func (*Request) ParseForm

                                                                                                                                          func (r *Request) ParseForm() (err error)

                                                                                                                                            ParseForm parses the raw query from the URL.

                                                                                                                                            For POST or PUT requests, it also parses the request body as a form. If the request Body's size has not already been limited by MaxBytesReader, the size is capped at 10MB.

                                                                                                                                            ParseMultipartForm calls ParseForm automatically. It is idempotent.

                                                                                                                                            func (*Request) ParseMultipartForm

                                                                                                                                            func (r *Request) ParseMultipartForm(maxMemory int64) error

                                                                                                                                              ParseMultipartForm parses a request body as multipart/form-data. The whole request body is parsed and up to a total of maxMemory bytes of its file parts are stored in memory, with the remainder stored on disk in temporary files. ParseMultipartForm calls ParseForm if necessary. After one call to ParseMultipartForm, subsequent calls have no effect.

                                                                                                                                              func (*Request) ProtoAtLeast

                                                                                                                                              func (r *Request) ProtoAtLeast(major, minor int) bool

                                                                                                                                                ProtoAtLeast returns whether the HTTP protocol used in the request is at least major.minor.

                                                                                                                                                func (*Request) Referer

                                                                                                                                                func (r *Request) Referer() string

                                                                                                                                                  Referer returns the referring URL, if sent in the request.

                                                                                                                                                  Referer is misspelled as in the request itself, a mistake from the earliest days of HTTP. This value can also be fetched from the Header map as Header["Referer"]; the benefit of making it available as a method is that the compiler can diagnose programs that use the alternate (correct English) spelling req.Referrer() but cannot diagnose programs that use Header["Referrer"].

                                                                                                                                                  func (*Request) SetBasicAuth

                                                                                                                                                  func (r *Request) SetBasicAuth(username, password string)

                                                                                                                                                    SetBasicAuth sets the request's Authorization header to use HTTP Basic Authentication with the provided username and password.

                                                                                                                                                    With HTTP Basic Authentication the provided username and password are not encrypted.

                                                                                                                                                    func (*Request) UserAgent

                                                                                                                                                    func (r *Request) UserAgent() string

                                                                                                                                                      UserAgent returns the client's User-Agent, if sent in the request.

                                                                                                                                                      func (*Request) Write

                                                                                                                                                      func (r *Request) Write(w io.Writer) error

                                                                                                                                                        Write writes an HTTP/1.1 request -- header and body -- in wire format. This method consults the following fields of the request:

                                                                                                                                                        Host
                                                                                                                                                        URL
                                                                                                                                                        Method (defaults to "GET")
                                                                                                                                                        Header
                                                                                                                                                        ContentLength
                                                                                                                                                        TransferEncoding
                                                                                                                                                        Body
                                                                                                                                                        

                                                                                                                                                        If Body is present, Content-Length is <= 0 and TransferEncoding hasn't been set to "identity", Write adds "Transfer-Encoding: chunked" to the header. Body is closed after it is sent.

                                                                                                                                                        func (*Request) WriteProxy

                                                                                                                                                        func (r *Request) WriteProxy(w io.Writer) error

                                                                                                                                                          WriteProxy is like Write but writes the request in the form expected by an HTTP proxy. In particular, WriteProxy writes the initial Request-URI line of the request with an absolute URI, per section 5.1.2 of RFC 2616, including the scheme and host. In either case, WriteProxy also writes a Host header, using either r.Host or r.URL.Host.

                                                                                                                                                          type Response

                                                                                                                                                          type Response struct {
                                                                                                                                                          	Status     string // e.g. "200 OK"
                                                                                                                                                          	StatusCode int    // e.g. 200
                                                                                                                                                          	Proto      string // e.g. "HTTP/1.0"
                                                                                                                                                          	ProtoMajor int    // e.g. 1
                                                                                                                                                          	ProtoMinor int    // e.g. 0
                                                                                                                                                          
                                                                                                                                                          	// Header maps header keys to values.  If the response had multiple
                                                                                                                                                          	// headers with the same key, they will be concatenated, with comma
                                                                                                                                                          	// delimiters.  (Section 4.2 of RFC 2616 requires that multiple headers
                                                                                                                                                          	// be semantically equivalent to a comma-delimited sequence.) Values
                                                                                                                                                          	// duplicated by other fields in this struct (e.g., ContentLength) are
                                                                                                                                                          	// omitted from Header.
                                                                                                                                                          	//
                                                                                                                                                          	// Keys in the map are canonicalized (see CanonicalHeaderKey).
                                                                                                                                                          	Header Header
                                                                                                                                                          
                                                                                                                                                          	// Body represents the response body.
                                                                                                                                                          	//
                                                                                                                                                          	// The http Client and Transport guarantee that Body is always
                                                                                                                                                          	// non-nil, even on responses without a body or responses with
                                                                                                                                                          	// a zero-lengthed body.
                                                                                                                                                          	Body io.ReadCloser
                                                                                                                                                          
                                                                                                                                                          	// ContentLength records the length of the associated content.  The
                                                                                                                                                          	// value -1 indicates that the length is unknown.  Unless RequestMethod
                                                                                                                                                          	// is "HEAD", values >= 0 indicate that the given number of bytes may
                                                                                                                                                          	// be read from Body.
                                                                                                                                                          	ContentLength int64
                                                                                                                                                          
                                                                                                                                                          	// Contains transfer encodings from outer-most to inner-most. Value is
                                                                                                                                                          	// nil, means that "identity" encoding is used.
                                                                                                                                                          	TransferEncoding []string
                                                                                                                                                          
                                                                                                                                                          	// Close records whether the header directed that the connection be
                                                                                                                                                          	// closed after reading Body.  The value is advice for clients: neither
                                                                                                                                                          	// ReadResponse nor Response.Write ever closes a connection.
                                                                                                                                                          	Close bool
                                                                                                                                                          
                                                                                                                                                          	// Trailer maps trailer keys to values, in the same
                                                                                                                                                          	// format as the header.
                                                                                                                                                          	Trailer Header
                                                                                                                                                          
                                                                                                                                                          	// The Request that was sent to obtain this Response.
                                                                                                                                                          	// Request's Body is nil (having already been consumed).
                                                                                                                                                          	// This is only populated for Client requests.
                                                                                                                                                          	Request *Request
                                                                                                                                                          }

                                                                                                                                                            Response represents the response from an HTTP request.

                                                                                                                                                            func Get

                                                                                                                                                            func Get(url string) (r *Response, err error)

                                                                                                                                                              Get issues a GET to the specified URL. If the response is one of the following redirect codes, Get follows the redirect, up to a maximum of 10 redirects:

                                                                                                                                                              301 (Moved Permanently)
                                                                                                                                                              302 (Found)
                                                                                                                                                              303 (See Other)
                                                                                                                                                              307 (Temporary Redirect)
                                                                                                                                                              

                                                                                                                                                              Caller should close r.Body when done reading from it.

                                                                                                                                                              Get is a wrapper around DefaultClient.Get.

                                                                                                                                                              Example
                                                                                                                                                              Output:
                                                                                                                                                              
                                                                                                                                                              
                                                                                                                                                              func Head(url string) (r *Response, err error)

                                                                                                                                                                Head issues a HEAD to the specified URL. If the response is one of the following redirect codes, Head follows the redirect after calling the Client's CheckRedirect function.

                                                                                                                                                                301 (Moved Permanently)
                                                                                                                                                                302 (Found)
                                                                                                                                                                303 (See Other)
                                                                                                                                                                307 (Temporary Redirect)
                                                                                                                                                                

                                                                                                                                                                Head is a wrapper around DefaultClient.Head

                                                                                                                                                                func Post

                                                                                                                                                                func Post(url string, bodyType string, body io.Reader) (r *Response, err error)

                                                                                                                                                                  Post issues a POST to the specified URL.

                                                                                                                                                                  Caller should close r.Body when done reading from it.

                                                                                                                                                                  Post is a wrapper around DefaultClient.Post

                                                                                                                                                                  func PostForm

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

                                                                                                                                                                    PostForm issues a POST to the specified URL, with data's keys and values urlencoded as the request body.

                                                                                                                                                                    Caller should close r.Body when done reading from it.

                                                                                                                                                                    PostForm is a wrapper around DefaultClient.PostForm

                                                                                                                                                                    func ReadResponse

                                                                                                                                                                    func ReadResponse(r *bufio.Reader, req *Request) (resp *Response, err error)

                                                                                                                                                                      ReadResponse reads and returns an HTTP response from r. The req parameter specifies the Request that corresponds to this Response. Clients must call resp.Body.Close when finished reading resp.Body. After that call, clients can inspect resp.Trailer to find key/value pairs included in the response trailer.

                                                                                                                                                                      func (*Response) Cookies

                                                                                                                                                                      func (r *Response) Cookies() []*Cookie

                                                                                                                                                                        Cookies parses and returns the cookies set in the Set-Cookie headers.

                                                                                                                                                                        func (*Response) Location

                                                                                                                                                                        func (r *Response) Location() (*url.URL, error)

                                                                                                                                                                          Location returns the URL of the response's "Location" header, if present. Relative redirects are resolved relative to the Response's Request. ErrNoLocation is returned if no Location header is present.

                                                                                                                                                                          func (*Response) ProtoAtLeast

                                                                                                                                                                          func (r *Response) ProtoAtLeast(major, minor int) bool

                                                                                                                                                                            ProtoAtLeast returns whether the HTTP protocol used in the response is at least major.minor.

                                                                                                                                                                            func (*Response) Write

                                                                                                                                                                            func (r *Response) Write(w io.Writer) error

                                                                                                                                                                              Writes the response (header, body and trailer) in wire format. This method consults the following fields of the response:

                                                                                                                                                                              StatusCode
                                                                                                                                                                              ProtoMajor
                                                                                                                                                                              ProtoMinor
                                                                                                                                                                              RequestMethod
                                                                                                                                                                              TransferEncoding
                                                                                                                                                                              Trailer
                                                                                                                                                                              Body
                                                                                                                                                                              ContentLength
                                                                                                                                                                              Header, values for non-canonical keys will have unpredictable behavior
                                                                                                                                                                              

                                                                                                                                                                              type ResponseWriter

                                                                                                                                                                              type ResponseWriter interface {
                                                                                                                                                                              	// Header returns the header map that will be sent by WriteHeader.
                                                                                                                                                                              	// Changing the header after a call to WriteHeader (or Write) has
                                                                                                                                                                              	// no effect.
                                                                                                                                                                              	Header() Header
                                                                                                                                                                              
                                                                                                                                                                              	// Write writes the data to the connection as part of an HTTP reply.
                                                                                                                                                                              	// If WriteHeader has not yet been called, Write calls WriteHeader(http.StatusOK)
                                                                                                                                                                              	// before writing the data.  If the Header does not contain a
                                                                                                                                                                              	// Content-Type line, Write adds a Content-Type set to the result of passing
                                                                                                                                                                              	// the initial 512 bytes of written data to DetectContentType.
                                                                                                                                                                              	Write([]byte) (int, error)
                                                                                                                                                                              
                                                                                                                                                                              	// WriteHeader sends an HTTP response header with status code.
                                                                                                                                                                              	// If WriteHeader is not called explicitly, the first call to Write
                                                                                                                                                                              	// will trigger an implicit WriteHeader(http.StatusOK).
                                                                                                                                                                              	// Thus explicit calls to WriteHeader are mainly used to
                                                                                                                                                                              	// send error codes.
                                                                                                                                                                              	WriteHeader(int)
                                                                                                                                                                              }

                                                                                                                                                                                A ResponseWriter interface is used by an HTTP handler to construct an HTTP response.

                                                                                                                                                                                type RoundTripper

                                                                                                                                                                                type RoundTripper interface {
                                                                                                                                                                                	// RoundTrip executes a single HTTP transaction, returning
                                                                                                                                                                                	// the Response for the request req.  RoundTrip should not
                                                                                                                                                                                	// attempt to interpret the response.  In particular,
                                                                                                                                                                                	// RoundTrip must return err == nil if it obtained a response,
                                                                                                                                                                                	// regardless of the response's HTTP status code.  A non-nil
                                                                                                                                                                                	// err should be reserved for failure to obtain a response.
                                                                                                                                                                                	// Similarly, RoundTrip should not attempt to handle
                                                                                                                                                                                	// higher-level protocol details such as redirects,
                                                                                                                                                                                	// authentication, or cookies.
                                                                                                                                                                                	//
                                                                                                                                                                                	// RoundTrip should not modify the request, except for
                                                                                                                                                                                	// consuming the Body.  The request's URL and Header fields
                                                                                                                                                                                	// are guaranteed to be initialized.
                                                                                                                                                                                	RoundTrip(*Request) (*Response, error)
                                                                                                                                                                                }

                                                                                                                                                                                  RoundTripper is an interface representing the ability to execute a single HTTP transaction, obtaining the Response for a given Request.

                                                                                                                                                                                  A RoundTripper must be safe for concurrent use by multiple goroutines.

                                                                                                                                                                                  var DefaultTransport RoundTripper = &Transport{Proxy: ProxyFromEnvironment}

                                                                                                                                                                                    DefaultTransport is the default implementation of Transport and is used by DefaultClient. It establishes a new network connection for each call to Do and uses HTTP proxies as directed by the $HTTP_PROXY and $NO_PROXY (or $http_proxy and $no_proxy) environment variables.

                                                                                                                                                                                    func NewFileTransport

                                                                                                                                                                                    func NewFileTransport(fs FileSystem) RoundTripper

                                                                                                                                                                                      NewFileTransport returns a new RoundTripper, serving the provided FileSystem. The returned RoundTripper ignores the URL host in its incoming requests, as well as most other properties of the request.

                                                                                                                                                                                      The typical use case for NewFileTransport is to register the "file" protocol with a Transport, as in:

                                                                                                                                                                                      t := &http.Transport{}
                                                                                                                                                                                      t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
                                                                                                                                                                                      c := &http.Client{Transport: t}
                                                                                                                                                                                      res, err := c.Get("file:///etc/passwd")
                                                                                                                                                                                      ...
                                                                                                                                                                                      

                                                                                                                                                                                      type ServeMux

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

                                                                                                                                                                                        ServeMux is an HTTP request multiplexer. It matches the URL of each incoming request against a list of registered patterns and calls the handler for the pattern that most closely matches the URL.

                                                                                                                                                                                        Patterns named fixed, rooted paths, like "/favicon.ico", or rooted subtrees, like "/images/" (note the trailing slash). Longer patterns take precedence over shorter ones, so that if there are handlers registered for both "/images/" and "/images/thumbnails/", the latter handler will be called for paths beginning "/images/thumbnails/" and the former will receiver requests for any other paths in the "/images/" subtree.

                                                                                                                                                                                        Patterns may optionally begin with a host name, restricting matches to URLs on that host only. Host-specific patterns take precedence over general patterns, so that a handler might register for the two patterns "/codesearch" and "codesearch.google.com/" without also taking over requests for "http://www.google.com/".

                                                                                                                                                                                        ServeMux also takes care of sanitizing the URL request path, redirecting any request containing . or .. elements to an equivalent .- and ..-free URL.

                                                                                                                                                                                        func NewServeMux

                                                                                                                                                                                        func NewServeMux() *ServeMux

                                                                                                                                                                                          NewServeMux allocates and returns a new ServeMux.

                                                                                                                                                                                          func (*ServeMux) Handle

                                                                                                                                                                                          func (mux *ServeMux) Handle(pattern string, handler Handler)

                                                                                                                                                                                            Handle registers the handler for the given pattern. If a handler already exists for pattern, Handle panics.

                                                                                                                                                                                            func (*ServeMux) HandleFunc

                                                                                                                                                                                            func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))

                                                                                                                                                                                              HandleFunc registers the handler function for the given pattern.

                                                                                                                                                                                              func (*ServeMux) ServeHTTP

                                                                                                                                                                                              func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)

                                                                                                                                                                                                ServeHTTP dispatches the request to the handler whose pattern most closely matches the request URL.

                                                                                                                                                                                                type Server

                                                                                                                                                                                                type Server struct {
                                                                                                                                                                                                	Addr           string        // TCP address to listen on, ":http" if empty
                                                                                                                                                                                                	Handler        Handler       // handler to invoke, http.DefaultServeMux if nil
                                                                                                                                                                                                	ReadTimeout    time.Duration // maximum duration before timing out read of the request
                                                                                                                                                                                                	WriteTimeout   time.Duration // maximum duration before timing out write of the response
                                                                                                                                                                                                	MaxHeaderBytes int           // maximum size of request headers, DefaultMaxHeaderBytes if 0
                                                                                                                                                                                                	TLSConfig      *tls.Config   // optional TLS config, used by ListenAndServeTLS
                                                                                                                                                                                                }

                                                                                                                                                                                                  A Server defines parameters for running an HTTP server.

                                                                                                                                                                                                  func (*Server) ListenAndServe

                                                                                                                                                                                                  func (srv *Server) ListenAndServe() error

                                                                                                                                                                                                    ListenAndServe listens on the TCP network address srv.Addr and then calls Serve to handle requests on incoming connections. If srv.Addr is blank, ":http" is used.

                                                                                                                                                                                                    func (*Server) ListenAndServeTLS

                                                                                                                                                                                                    func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error

                                                                                                                                                                                                      ListenAndServeTLS listens on the TCP network address srv.Addr and then calls Serve to handle requests on incoming TLS connections.

                                                                                                                                                                                                      Filenames containing a certificate and matching private key for the server must be provided. If the certificate is signed by a certificate authority, the certFile should be the concatenation of the server's certificate followed by the CA's certificate.

                                                                                                                                                                                                      If srv.Addr is blank, ":https" is used.

                                                                                                                                                                                                      func (*Server) Serve

                                                                                                                                                                                                      func (srv *Server) Serve(l net.Listener) error

                                                                                                                                                                                                        Serve accepts incoming connections on the Listener l, creating a new service thread for each. The service threads read requests and then call srv.Handler to reply to them.

                                                                                                                                                                                                        type Transport

                                                                                                                                                                                                        type Transport struct {
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Proxy specifies a function to return a proxy for a given
                                                                                                                                                                                                        	// Request. If the function returns a non-nil error, the
                                                                                                                                                                                                        	// request is aborted with the provided error.
                                                                                                                                                                                                        	// If Proxy is nil or returns a nil *URL, no proxy is used.
                                                                                                                                                                                                        	Proxy func(*Request) (*url.URL, error)
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Dial specifies the dial function for creating TCP
                                                                                                                                                                                                        	// connections.
                                                                                                                                                                                                        	// If Dial is nil, net.Dial is used.
                                                                                                                                                                                                        	Dial func(net, addr string) (c net.Conn, err error)
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// TLSClientConfig specifies the TLS configuration to use with
                                                                                                                                                                                                        	// tls.Client. If nil, the default configuration is used.
                                                                                                                                                                                                        	TLSClientConfig *tls.Config
                                                                                                                                                                                                        
                                                                                                                                                                                                        	DisableKeepAlives  bool
                                                                                                                                                                                                        	DisableCompression bool
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// MaxIdleConnsPerHost, if non-zero, controls the maximum idle
                                                                                                                                                                                                        	// (keep-alive) to keep to keep per-host.  If zero,
                                                                                                                                                                                                        	// DefaultMaxIdleConnsPerHost is used.
                                                                                                                                                                                                        	MaxIdleConnsPerHost int
                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                        }

                                                                                                                                                                                                          Transport is an implementation of RoundTripper that supports http, https, and http proxies (for either http or https with CONNECT). Transport can also cache connections for future re-use.

                                                                                                                                                                                                          func (*Transport) CloseIdleConnections

                                                                                                                                                                                                          func (t *Transport) CloseIdleConnections()

                                                                                                                                                                                                            CloseIdleConnections closes any connections which were previously connected from previous requests but are now sitting idle in a "keep-alive" state. It does not interrupt any connections currently in use.

                                                                                                                                                                                                            func (*Transport) RegisterProtocol

                                                                                                                                                                                                            func (t *Transport) RegisterProtocol(scheme string, rt RoundTripper)

                                                                                                                                                                                                              RegisterProtocol registers a new protocol with scheme. The Transport will pass requests using the given scheme to rt. It is rt's responsibility to simulate HTTP request semantics.

                                                                                                                                                                                                              RegisterProtocol can be used by other packages to provide implementations of protocol schemes like "ftp" or "file".

                                                                                                                                                                                                              func (*Transport) RoundTrip

                                                                                                                                                                                                              func (t *Transport) RoundTrip(req *Request) (resp *Response, err error)

                                                                                                                                                                                                                RoundTrip implements the RoundTripper interface.

                                                                                                                                                                                                                Directories

                                                                                                                                                                                                                Path Synopsis
                                                                                                                                                                                                                Package cgi implements CGI (Common Gateway Interface) as specified in RFC 3875.
                                                                                                                                                                                                                Package cgi implements CGI (Common Gateway Interface) as specified in RFC 3875.
                                                                                                                                                                                                                Package fcgi implements the FastCGI protocol.
                                                                                                                                                                                                                Package fcgi implements the FastCGI protocol.
                                                                                                                                                                                                                Package httptest provides utilities for HTTP testing.
                                                                                                                                                                                                                Package httptest provides utilities for HTTP testing.
                                                                                                                                                                                                                Package httputil provides HTTP utility functions, complementing the more common ones in the net/http package.
                                                                                                                                                                                                                Package httputil provides HTTP utility functions, complementing the more common ones in the net/http package.
                                                                                                                                                                                                                Package pprof serves via its HTTP server runtime profiling data in the format expected by the pprof visualization tool.
                                                                                                                                                                                                                Package pprof serves via its HTTP server runtime profiling data in the format expected by the pprof visualization tool.