| // Copyright 2011 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // HTTP client implementation. See RFC 2616. |
| // |
| // This is the low-level Transport implementation of RoundTripper. |
| // The high-level interface is in client.go. |
| |
| package http |
| |
| import ( |
| "bufio" |
| "compress/gzip" |
| "crypto/tls" |
| "encoding/base64" |
| "errors" |
| "fmt" |
| "io" |
| "log" |
| "net" |
| "net/url" |
| "os" |
| "strings" |
| "sync" |
| "time" |
| ) |
| |
| // DefaultTransport is the default implementation of Transport and is |
| // used by DefaultClient. It establishes network connections as needed |
| // and caches them for reuse by subsequent calls. It uses HTTP proxies |
| // as directed by the $HTTP_PROXY and $NO_PROXY (or $http_proxy and |
| // $no_proxy) environment variables. |
| var DefaultTransport RoundTripper = &Transport{Proxy: ProxyFromEnvironment} |
| |
| // DefaultMaxIdleConnsPerHost is the default value of Transport's |
| // MaxIdleConnsPerHost. |
| const DefaultMaxIdleConnsPerHost = 2 |
| |
| // 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. |
| type Transport struct { |
| idleMu sync.Mutex |
| idleConn map[string][]*persistConn |
| idleConnCh map[string]chan *persistConn |
| reqMu sync.Mutex |
| reqConn map[*Request]*persistConn |
| altMu sync.RWMutex |
| altProto map[string]RoundTripper // nil or map of URI scheme => RoundTripper |
| |
| // 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(network, addr string) (net.Conn, error) |
| |
| // TLSClientConfig specifies the TLS configuration to use with |
| // tls.Client. If nil, the default configuration is used. |
| TLSClientConfig *tls.Config |
| |
| // DisableKeepAlives, if true, prevents re-use of TCP connections |
| // between different HTTP requests. |
| DisableKeepAlives bool |
| |
| // DisableCompression, if true, prevents the Transport from |
| // requesting compression with an "Accept-Encoding: gzip" |
| // request header when the Request contains no existing |
| // Accept-Encoding value. If the Transport requests gzip on |
| // its own and gets a gzipped response, it's transparently |
| // decoded in the Response.Body. However, if the user |
| // explicitly requested gzip it is not automatically |
| // uncompressed. |
| DisableCompression bool |
| |
| // MaxIdleConnsPerHost, if non-zero, controls the maximum idle |
| // (keep-alive) to keep per-host. If zero, |
| // DefaultMaxIdleConnsPerHost is used. |
| MaxIdleConnsPerHost int |
| |
| // ResponseHeaderTimeout, if non-zero, specifies the amount of |
| // time to wait for a server's response headers after fully |
| // writing the request (including its body, if any). This |
| // time does not include the time to read the response body. |
| ResponseHeaderTimeout time.Duration |
| |
| // TODO: tunable on global max cached connections |
| // TODO: tunable on timeout on cached connections |
| } |
| |
| // 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 ProxyFromEnvironment(req *Request) (*url.URL, error) { |
| proxy := getenvEitherCase("HTTP_PROXY") |
| if proxy == "" { |
| return nil, nil |
| } |
| if !useProxy(canonicalAddr(req.URL)) { |
| return nil, nil |
| } |
| proxyURL, err := url.Parse(proxy) |
| if err != nil || !strings.HasPrefix(proxyURL.Scheme, "http") { |
| if u, err := url.Parse("http://" + proxy); err == nil { |
| proxyURL = u |
| err = nil |
| } |
| } |
| if err != nil { |
| return nil, fmt.Errorf("invalid proxy address %q: %v", proxy, err) |
| } |
| return proxyURL, nil |
| } |
| |
| // ProxyURL returns a proxy function (for use in a Transport) |
| // that always returns the same URL. |
| func ProxyURL(fixedURL *url.URL) func(*Request) (*url.URL, error) { |
| return func(*Request) (*url.URL, error) { |
| return fixedURL, nil |
| } |
| } |
| |
| // transportRequest is a wrapper around a *Request that adds |
| // optional extra headers to write. |
| type transportRequest struct { |
| *Request // original request, not to be mutated |
| extra Header // extra headers to write, or nil |
| } |
| |
| func (tr *transportRequest) extraHeaders() Header { |
| if tr.extra == nil { |
| tr.extra = make(Header) |
| } |
| return tr.extra |
| } |
| |
| // RoundTrip implements the RoundTripper interface. |
| // |
| // For higher-level HTTP client support (such as handling of cookies |
| // and redirects), see Get, Post, and the Client type. |
| func (t *Transport) RoundTrip(req *Request) (resp *Response, err error) { |
| if req.URL == nil { |
| return nil, errors.New("http: nil Request.URL") |
| } |
| if req.Header == nil { |
| return nil, errors.New("http: nil Request.Header") |
| } |
| if req.URL.Scheme != "http" && req.URL.Scheme != "https" { |
| t.altMu.RLock() |
| var rt RoundTripper |
| if t.altProto != nil { |
| rt = t.altProto[req.URL.Scheme] |
| } |
| t.altMu.RUnlock() |
| if rt == nil { |
| return nil, &badStringError{"unsupported protocol scheme", req.URL.Scheme} |
| } |
| return rt.RoundTrip(req) |
| } |
| if req.URL.Host == "" { |
| return nil, errors.New("http: no Host in request URL") |
| } |
| treq := &transportRequest{Request: req} |
| cm, err := t.connectMethodForRequest(treq) |
| if err != nil { |
| return nil, err |
| } |
| |
| // Get the cached or newly-created connection to either the |
| // host (for http or https), the http proxy, or the http proxy |
| // pre-CONNECTed to https server. In any case, we'll be ready |
| // to send it requests. |
| pconn, err := t.getConn(cm) |
| if err != nil { |
| return nil, err |
| } |
| |
| return pconn.roundTrip(treq) |
| } |
| |
| // 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 (t *Transport) RegisterProtocol(scheme string, rt RoundTripper) { |
| if scheme == "http" || scheme == "https" { |
| panic("protocol " + scheme + " already registered") |
| } |
| t.altMu.Lock() |
| defer t.altMu.Unlock() |
| if t.altProto == nil { |
| t.altProto = make(map[string]RoundTripper) |
| } |
| if _, exists := t.altProto[scheme]; exists { |
| panic("protocol " + scheme + " already registered") |
| } |
| t.altProto[scheme] = rt |
| } |
| |
| // 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 (t *Transport) CloseIdleConnections() { |
| t.idleMu.Lock() |
| m := t.idleConn |
| t.idleConn = nil |
| t.idleMu.Unlock() |
| if m == nil { |
| return |
| } |
| for _, conns := range m { |
| for _, pconn := range conns { |
| pconn.close() |
| } |
| } |
| } |
| |
| // CancelRequest cancels an in-flight request by closing its |
| // connection. |
| func (t *Transport) CancelRequest(req *Request) { |
| t.reqMu.Lock() |
| pc := t.reqConn[req] |
| t.reqMu.Unlock() |
| if pc != nil { |
| pc.conn.Close() |
| } |
| } |
| |
| // |
| // Private implementation past this point. |
| // |
| |
| func getenvEitherCase(k string) string { |
| if v := os.Getenv(strings.ToUpper(k)); v != "" { |
| return v |
| } |
| return os.Getenv(strings.ToLower(k)) |
| } |
| |
| func (t *Transport) connectMethodForRequest(treq *transportRequest) (*connectMethod, error) { |
| cm := &connectMethod{ |
| targetScheme: treq.URL.Scheme, |
| targetAddr: canonicalAddr(treq.URL), |
| } |
| if t.Proxy != nil { |
| var err error |
| cm.proxyURL, err = t.Proxy(treq.Request) |
| if err != nil { |
| return nil, err |
| } |
| } |
| return cm, nil |
| } |
| |
| // proxyAuth returns the Proxy-Authorization header to set |
| // on requests, if applicable. |
| func (cm *connectMethod) proxyAuth() string { |
| if cm.proxyURL == nil { |
| return "" |
| } |
| if u := cm.proxyURL.User; u != nil { |
| return "Basic " + base64.URLEncoding.EncodeToString([]byte(u.String())) |
| } |
| return "" |
| } |
| |
| // putIdleConn adds pconn to the list of idle persistent connections awaiting |
| // a new request. |
| // If pconn is no longer needed or not in a good state, putIdleConn |
| // returns false. |
| func (t *Transport) putIdleConn(pconn *persistConn) bool { |
| if t.DisableKeepAlives || t.MaxIdleConnsPerHost < 0 { |
| pconn.close() |
| return false |
| } |
| if pconn.isBroken() { |
| return false |
| } |
| key := pconn.cacheKey |
| max := t.MaxIdleConnsPerHost |
| if max == 0 { |
| max = DefaultMaxIdleConnsPerHost |
| } |
| t.idleMu.Lock() |
| select { |
| case t.idleConnCh[key] <- pconn: |
| // We're done with this pconn and somebody else is |
| // currently waiting for a conn of this type (they're |
| // actively dialing, but this conn is ready |
| // first). Chrome calls this socket late binding. See |
| // https://insouciant.org/tech/connection-management-in-chromium/ |
| t.idleMu.Unlock() |
| return true |
| default: |
| } |
| if t.idleConn == nil { |
| t.idleConn = make(map[string][]*persistConn) |
| } |
| if len(t.idleConn[key]) >= max { |
| t.idleMu.Unlock() |
| pconn.close() |
| return false |
| } |
| for _, exist := range t.idleConn[key] { |
| if exist == pconn { |
| log.Fatalf("dup idle pconn %p in freelist", pconn) |
| } |
| } |
| t.idleConn[key] = append(t.idleConn[key], pconn) |
| t.idleMu.Unlock() |
| return true |
| } |
| |
| func (t *Transport) getIdleConnCh(cm *connectMethod) chan *persistConn { |
| key := cm.key() |
| t.idleMu.Lock() |
| defer t.idleMu.Unlock() |
| if t.idleConnCh == nil { |
| t.idleConnCh = make(map[string]chan *persistConn) |
| } |
| ch, ok := t.idleConnCh[key] |
| if !ok { |
| ch = make(chan *persistConn) |
| t.idleConnCh[key] = ch |
| } |
| return ch |
| } |
| |
| func (t *Transport) getIdleConn(cm *connectMethod) (pconn *persistConn) { |
| key := cm.key() |
| t.idleMu.Lock() |
| defer t.idleMu.Unlock() |
| if t.idleConn == nil { |
| return nil |
| } |
| for { |
| pconns, ok := t.idleConn[key] |
| if !ok { |
| return nil |
| } |
| if len(pconns) == 1 { |
| pconn = pconns[0] |
| delete(t.idleConn, key) |
| } else { |
| // 2 or more cached connections; pop last |
| // TODO: queue? |
| pconn = pconns[len(pconns)-1] |
| t.idleConn[key] = pconns[0 : len(pconns)-1] |
| } |
| if !pconn.isBroken() { |
| return |
| } |
| } |
| } |
| |
| func (t *Transport) setReqConn(r *Request, pc *persistConn) { |
| t.reqMu.Lock() |
| defer t.reqMu.Unlock() |
| if t.reqConn == nil { |
| t.reqConn = make(map[*Request]*persistConn) |
| } |
| if pc != nil { |
| t.reqConn[r] = pc |
| } else { |
| delete(t.reqConn, r) |
| } |
| } |
| |
| func (t *Transport) dial(network, addr string) (c net.Conn, err error) { |
| if t.Dial != nil { |
| return t.Dial(network, addr) |
| } |
| return net.Dial(network, addr) |
| } |
| |
| // getConn dials and creates a new persistConn to the target as |
| // specified in the connectMethod. This includes doing a proxy CONNECT |
| // and/or setting up TLS. If this doesn't return an error, the persistConn |
| // is ready to write requests to. |
| func (t *Transport) getConn(cm *connectMethod) (*persistConn, error) { |
| if pc := t.getIdleConn(cm); pc != nil { |
| return pc, nil |
| } |
| |
| type dialRes struct { |
| pc *persistConn |
| err error |
| } |
| dialc := make(chan dialRes) |
| go func() { |
| pc, err := t.dialConn(cm) |
| dialc <- dialRes{pc, err} |
| }() |
| |
| idleConnCh := t.getIdleConnCh(cm) |
| select { |
| case v := <-dialc: |
| // Our dial finished. |
| return v.pc, v.err |
| case pc := <-idleConnCh: |
| // Another request finished first and its net.Conn |
| // became available before our dial. Or somebody |
| // else's dial that they didn't use. |
| // But our dial is still going, so give it away |
| // when it finishes: |
| go func() { |
| if v := <-dialc; v.err == nil { |
| t.putIdleConn(v.pc) |
| } |
| }() |
| return pc, nil |
| } |
| } |
| |
| func (t *Transport) dialConn(cm *connectMethod) (*persistConn, error) { |
| conn, err := t.dial("tcp", cm.addr()) |
| if err != nil { |
| if cm.proxyURL != nil { |
| err = fmt.Errorf("http: error connecting to proxy %s: %v", cm.proxyURL, err) |
| } |
| return nil, err |
| } |
| |
| pa := cm.proxyAuth() |
| |
| pconn := &persistConn{ |
| t: t, |
| cacheKey: cm.key(), |
| conn: conn, |
| reqch: make(chan requestAndChan, 50), |
| writech: make(chan writeRequest, 50), |
| closech: make(chan struct{}), |
| } |
| |
| switch { |
| case cm.proxyURL == nil: |
| // Do nothing. |
| case cm.targetScheme == "http": |
| pconn.isProxy = true |
| if pa != "" { |
| pconn.mutateHeaderFunc = func(h Header) { |
| h.Set("Proxy-Authorization", pa) |
| } |
| } |
| case cm.targetScheme == "https": |
| connectReq := &Request{ |
| Method: "CONNECT", |
| URL: &url.URL{Opaque: cm.targetAddr}, |
| Host: cm.targetAddr, |
| Header: make(Header), |
| } |
| if pa != "" { |
| connectReq.Header.Set("Proxy-Authorization", pa) |
| } |
| connectReq.Write(conn) |
| |
| // Read response. |
| // Okay to use and discard buffered reader here, because |
| // TLS server will not speak until spoken to. |
| br := bufio.NewReader(conn) |
| resp, err := ReadResponse(br, connectReq) |
| if err != nil { |
| conn.Close() |
| return nil, err |
| } |
| if resp.StatusCode != 200 { |
| f := strings.SplitN(resp.Status, " ", 2) |
| conn.Close() |
| return nil, errors.New(f[1]) |
| } |
| } |
| |
| if cm.targetScheme == "https" { |
| // Initiate TLS and check remote host name against certificate. |
| cfg := t.TLSClientConfig |
| if cfg == nil || cfg.ServerName == "" { |
| host := cm.tlsHost() |
| if cfg == nil { |
| cfg = &tls.Config{ServerName: host} |
| } else { |
| clone := *cfg // shallow clone |
| clone.ServerName = host |
| cfg = &clone |
| } |
| } |
| conn = tls.Client(conn, cfg) |
| if err = conn.(*tls.Conn).Handshake(); err != nil { |
| return nil, err |
| } |
| if t.TLSClientConfig == nil || !t.TLSClientConfig.InsecureSkipVerify { |
| if err = conn.(*tls.Conn).VerifyHostname(cm.tlsHost()); err != nil { |
| return nil, err |
| } |
| } |
| pconn.conn = conn |
| } |
| |
| pconn.br = bufio.NewReader(pconn.conn) |
| pconn.bw = bufio.NewWriter(pconn.conn) |
| go pconn.readLoop() |
| go pconn.writeLoop() |
| return pconn, nil |
| } |
| |
| // useProxy returns true if requests to addr should use a proxy, |
| // according to the NO_PROXY or no_proxy environment variable. |
| // addr is always a canonicalAddr with a host and port. |
| func useProxy(addr string) bool { |
| if len(addr) == 0 { |
| return true |
| } |
| host, _, err := net.SplitHostPort(addr) |
| if err != nil { |
| return false |
| } |
| if host == "localhost" { |
| return false |
| } |
| if ip := net.ParseIP(host); ip != nil { |
| if ip.IsLoopback() { |
| return false |
| } |
| } |
| |
| no_proxy := getenvEitherCase("NO_PROXY") |
| if no_proxy == "*" { |
| return false |
| } |
| |
| addr = strings.ToLower(strings.TrimSpace(addr)) |
| if hasPort(addr) { |
| addr = addr[:strings.LastIndex(addr, ":")] |
| } |
| |
| for _, p := range strings.Split(no_proxy, ",") { |
| p = strings.ToLower(strings.TrimSpace(p)) |
| if len(p) == 0 { |
| continue |
| } |
| if hasPort(p) { |
| p = p[:strings.LastIndex(p, ":")] |
| } |
| if addr == p { |
| return false |
| } |
| if p[0] == '.' && (strings.HasSuffix(addr, p) || addr == p[1:]) { |
| // no_proxy ".foo.com" matches "bar.foo.com" or "foo.com" |
| return false |
| } |
| if p[0] != '.' && strings.HasSuffix(addr, p) && addr[len(addr)-len(p)-1] == '.' { |
| // no_proxy "foo.com" matches "bar.foo.com" |
| return false |
| } |
| } |
| return true |
| } |
| |
| // connectMethod is the map key (in its String form) for keeping persistent |
| // TCP connections alive for subsequent HTTP requests. |
| // |
| // A connect method may be of the following types: |
| // |
| // Cache key form Description |
| // ----------------- ------------------------- |
| // ||http|foo.com http directly to server, no proxy |
| // ||https|foo.com https directly to server, no proxy |
| // http://proxy.com|https|foo.com http to proxy, then CONNECT to foo.com |
| // http://proxy.com|http http to proxy, http to anywhere after that |
| // |
| // Note: no support to https to the proxy yet. |
| // |
| type connectMethod struct { |
| proxyURL *url.URL // nil for no proxy, else full proxy URL |
| targetScheme string // "http" or "https" |
| targetAddr string // Not used if proxy + http targetScheme (4th example in table) |
| } |
| |
| func (ck *connectMethod) key() string { |
| return ck.String() // TODO: use a struct type instead |
| } |
| |
| func (ck *connectMethod) String() string { |
| proxyStr := "" |
| targetAddr := ck.targetAddr |
| if ck.proxyURL != nil { |
| proxyStr = ck.proxyURL.String() |
| if ck.targetScheme == "http" { |
| targetAddr = "" |
| } |
| } |
| return strings.Join([]string{proxyStr, ck.targetScheme, targetAddr}, "|") |
| } |
| |
| // addr returns the first hop "host:port" to which we need to TCP connect. |
| func (cm *connectMethod) addr() string { |
| if cm.proxyURL != nil { |
| return canonicalAddr(cm.proxyURL) |
| } |
| return cm.targetAddr |
| } |
| |
| // tlsHost returns the host name to match against the peer's |
| // TLS certificate. |
| func (cm *connectMethod) tlsHost() string { |
| h := cm.targetAddr |
| if hasPort(h) { |
| h = h[:strings.LastIndex(h, ":")] |
| } |
| return h |
| } |
| |
| // persistConn wraps a connection, usually a persistent one |
| // (but may be used for non-keep-alive requests as well) |
| type persistConn struct { |
| t *Transport |
| cacheKey string // its connectMethod.String() |
| conn net.Conn |
| closed bool // whether conn has been closed |
| br *bufio.Reader // from conn |
| bw *bufio.Writer // to conn |
| reqch chan requestAndChan // written by roundTrip; read by readLoop |
| writech chan writeRequest // written by roundTrip; read by writeLoop |
| closech chan struct{} // broadcast close when readLoop (TCP connection) closes |
| isProxy bool |
| |
| lk sync.Mutex // guards following 3 fields |
| numExpectedResponses int |
| broken bool // an error has happened on this connection; marked broken so it's not reused. |
| // mutateHeaderFunc is an optional func to modify extra |
| // headers on each outbound request before it's written. (the |
| // original Request given to RoundTrip is not modified) |
| mutateHeaderFunc func(Header) |
| } |
| |
| func (pc *persistConn) isBroken() bool { |
| pc.lk.Lock() |
| b := pc.broken |
| pc.lk.Unlock() |
| return b |
| } |
| |
| var remoteSideClosedFunc func(error) bool // or nil to use default |
| |
| func remoteSideClosed(err error) bool { |
| if err == io.EOF { |
| return true |
| } |
| if remoteSideClosedFunc != nil { |
| return remoteSideClosedFunc(err) |
| } |
| return false |
| } |
| |
| func (pc *persistConn) readLoop() { |
| defer close(pc.closech) |
| alive := true |
| |
| for alive { |
| pb, err := pc.br.Peek(1) |
| |
| pc.lk.Lock() |
| if pc.numExpectedResponses == 0 { |
| pc.closeLocked() |
| pc.lk.Unlock() |
| if len(pb) > 0 { |
| log.Printf("Unsolicited response received on idle HTTP channel starting with %q; err=%v", |
| string(pb), err) |
| } |
| return |
| } |
| pc.lk.Unlock() |
| |
| rc := <-pc.reqch |
| |
| var resp *Response |
| if err == nil { |
| resp, err = ReadResponse(pc.br, rc.req) |
| if err == nil && resp.StatusCode == 100 { |
| // Skip any 100-continue for now. |
| // TODO(bradfitz): if rc.req had "Expect: 100-continue", |
| // actually block the request body write and signal the |
| // writeLoop now to begin sending it. (Issue 2184) For now we |
| // eat it, since we're never expecting one. |
| resp, err = ReadResponse(pc.br, rc.req) |
| } |
| } |
| hasBody := resp != nil && rc.req.Method != "HEAD" && resp.ContentLength != 0 |
| |
| if err != nil { |
| pc.close() |
| } else { |
| if rc.addedGzip && hasBody && resp.Header.Get("Content-Encoding") == "gzip" { |
| resp.Header.Del("Content-Encoding") |
| resp.Header.Del("Content-Length") |
| resp.ContentLength = -1 |
| gzReader, zerr := gzip.NewReader(resp.Body) |
| if zerr != nil { |
| pc.close() |
| err = zerr |
| } else { |
| resp.Body = &readerAndCloser{gzReader, resp.Body} |
| } |
| } |
| resp.Body = &bodyEOFSignal{body: resp.Body} |
| } |
| |
| if err != nil || resp.Close || rc.req.Close || resp.StatusCode <= 199 { |
| // Don't do keep-alive on error if either party requested a close |
| // or we get an unexpected informational (1xx) response. |
| // StatusCode 100 is already handled above. |
| alive = false |
| } |
| |
| var waitForBodyRead chan bool |
| if hasBody { |
| waitForBodyRead = make(chan bool, 2) |
| resp.Body.(*bodyEOFSignal).earlyCloseFn = func() error { |
| // Sending false here sets alive to |
| // false and closes the connection |
| // below. |
| waitForBodyRead <- false |
| return nil |
| } |
| resp.Body.(*bodyEOFSignal).fn = func(err error) { |
| alive1 := alive |
| if err != nil { |
| alive1 = false |
| } |
| if alive1 && !pc.t.putIdleConn(pc) { |
| alive1 = false |
| } |
| if !alive1 || pc.isBroken() { |
| pc.close() |
| } |
| waitForBodyRead <- alive1 |
| } |
| } |
| |
| if alive && !hasBody { |
| if !pc.t.putIdleConn(pc) { |
| alive = false |
| } |
| } |
| |
| rc.ch <- responseAndError{resp, err} |
| |
| // Wait for the just-returned response body to be fully consumed |
| // before we race and peek on the underlying bufio reader. |
| if waitForBodyRead != nil { |
| alive = <-waitForBodyRead |
| } |
| |
| pc.t.setReqConn(rc.req, nil) |
| |
| if !alive { |
| pc.close() |
| } |
| } |
| } |
| |
| func (pc *persistConn) writeLoop() { |
| for { |
| select { |
| case wr := <-pc.writech: |
| if pc.isBroken() { |
| wr.ch <- errors.New("http: can't write HTTP request on broken connection") |
| continue |
| } |
| err := wr.req.Request.write(pc.bw, pc.isProxy, wr.req.extra) |
| if err == nil { |
| err = pc.bw.Flush() |
| } |
| if err != nil { |
| pc.markBroken() |
| } |
| wr.ch <- err |
| case <-pc.closech: |
| return |
| } |
| } |
| } |
| |
| type responseAndError struct { |
| res *Response |
| err error |
| } |
| |
| type requestAndChan struct { |
| req *Request |
| ch chan responseAndError |
| |
| // did the Transport (as opposed to the client code) add an |
| // Accept-Encoding gzip header? only if it we set it do |
| // we transparently decode the gzip. |
| addedGzip bool |
| } |
| |
| // A writeRequest is sent by the readLoop's goroutine to the |
| // writeLoop's goroutine to write a request while the read loop |
| // concurrently waits on both the write response and the server's |
| // reply. |
| type writeRequest struct { |
| req *transportRequest |
| ch chan<- error |
| } |
| |
| func (pc *persistConn) roundTrip(req *transportRequest) (resp *Response, err error) { |
| pc.t.setReqConn(req.Request, pc) |
| pc.lk.Lock() |
| pc.numExpectedResponses++ |
| headerFn := pc.mutateHeaderFunc |
| pc.lk.Unlock() |
| |
| if headerFn != nil { |
| headerFn(req.extraHeaders()) |
| } |
| |
| // Ask for a compressed version if the caller didn't set their |
| // own value for Accept-Encoding. We only attempted to |
| // uncompress the gzip stream if we were the layer that |
| // requested it. |
| requestedGzip := false |
| if !pc.t.DisableCompression && req.Header.Get("Accept-Encoding") == "" { |
| // Request gzip only, not deflate. Deflate is ambiguous and |
| // not as universally supported anyway. |
| // See: http://www.gzip.org/zlib/zlib_faq.html#faq38 |
| requestedGzip = true |
| req.extraHeaders().Set("Accept-Encoding", "gzip") |
| } |
| |
| // Write the request concurrently with waiting for a response, |
| // in case the server decides to reply before reading our full |
| // request body. |
| writeErrCh := make(chan error, 1) |
| pc.writech <- writeRequest{req, writeErrCh} |
| |
| resc := make(chan responseAndError, 1) |
| pc.reqch <- requestAndChan{req.Request, resc, requestedGzip} |
| |
| var re responseAndError |
| var pconnDeadCh = pc.closech |
| var failTicker <-chan time.Time |
| var respHeaderTimer <-chan time.Time |
| WaitResponse: |
| for { |
| select { |
| case err := <-writeErrCh: |
| if err != nil { |
| re = responseAndError{nil, err} |
| pc.close() |
| break WaitResponse |
| } |
| if d := pc.t.ResponseHeaderTimeout; d > 0 { |
| respHeaderTimer = time.After(d) |
| } |
| case <-pconnDeadCh: |
| // The persist connection is dead. This shouldn't |
| // usually happen (only with Connection: close responses |
| // with no response bodies), but if it does happen it |
| // means either a) the remote server hung up on us |
| // prematurely, or b) the readLoop sent us a response & |
| // closed its closech at roughly the same time, and we |
| // selected this case first, in which case a response |
| // might still be coming soon. |
| // |
| // We can't avoid the select race in b) by using a unbuffered |
| // resc channel instead, because then goroutines can |
| // leak if we exit due to other errors. |
| pconnDeadCh = nil // avoid spinning |
| failTicker = time.After(100 * time.Millisecond) // arbitrary time to wait for resc |
| case <-failTicker: |
| re = responseAndError{err: errors.New("net/http: transport closed before response was received")} |
| break WaitResponse |
| case <-respHeaderTimer: |
| pc.close() |
| re = responseAndError{err: errors.New("net/http: timeout awaiting response headers")} |
| break WaitResponse |
| case re = <-resc: |
| break WaitResponse |
| } |
| } |
| |
| pc.lk.Lock() |
| pc.numExpectedResponses-- |
| pc.lk.Unlock() |
| |
| if re.err != nil { |
| pc.t.setReqConn(req.Request, nil) |
| } |
| return re.res, re.err |
| } |
| |
| // markBroken marks a connection as broken (so it's not reused). |
| // It differs from close in that it doesn't close the underlying |
| // connection for use when it's still being read. |
| func (pc *persistConn) markBroken() { |
| pc.lk.Lock() |
| defer pc.lk.Unlock() |
| pc.broken = true |
| } |
| |
| func (pc *persistConn) close() { |
| pc.lk.Lock() |
| defer pc.lk.Unlock() |
| pc.closeLocked() |
| } |
| |
| func (pc *persistConn) closeLocked() { |
| pc.broken = true |
| if !pc.closed { |
| pc.conn.Close() |
| pc.closed = true |
| } |
| pc.mutateHeaderFunc = nil |
| } |
| |
| var portMap = map[string]string{ |
| "http": "80", |
| "https": "443", |
| } |
| |
| // canonicalAddr returns url.Host but always with a ":port" suffix |
| func canonicalAddr(url *url.URL) string { |
| addr := url.Host |
| if !hasPort(addr) { |
| return addr + ":" + portMap[url.Scheme] |
| } |
| return addr |
| } |
| |
| // bodyEOFSignal wraps a ReadCloser but runs fn (if non-nil) at most |
| // once, right before its final (error-producing) Read or Close call |
| // returns. If earlyCloseFn is non-nil and Close is called before |
| // io.EOF is seen, earlyCloseFn is called instead of fn, and its |
| // return value is the return value from Close. |
| type bodyEOFSignal struct { |
| body io.ReadCloser |
| mu sync.Mutex // guards following 4 fields |
| closed bool // whether Close has been called |
| rerr error // sticky Read error |
| fn func(error) // error will be nil on Read io.EOF |
| earlyCloseFn func() error // optional alt Close func used if io.EOF not seen |
| } |
| |
| func (es *bodyEOFSignal) Read(p []byte) (n int, err error) { |
| es.mu.Lock() |
| closed, rerr := es.closed, es.rerr |
| es.mu.Unlock() |
| if closed { |
| return 0, errors.New("http: read on closed response body") |
| } |
| if rerr != nil { |
| return 0, rerr |
| } |
| |
| n, err = es.body.Read(p) |
| if err != nil { |
| es.mu.Lock() |
| defer es.mu.Unlock() |
| if es.rerr == nil { |
| es.rerr = err |
| } |
| es.condfn(err) |
| } |
| return |
| } |
| |
| func (es *bodyEOFSignal) Close() error { |
| es.mu.Lock() |
| defer es.mu.Unlock() |
| if es.closed { |
| return nil |
| } |
| es.closed = true |
| if es.earlyCloseFn != nil && es.rerr != io.EOF { |
| return es.earlyCloseFn() |
| } |
| err := es.body.Close() |
| es.condfn(err) |
| return err |
| } |
| |
| // caller must hold es.mu. |
| func (es *bodyEOFSignal) condfn(err error) { |
| if es.fn == nil { |
| return |
| } |
| if err == io.EOF { |
| err = nil |
| } |
| es.fn(err) |
| es.fn = nil |
| } |
| |
| type readerAndCloser struct { |
| io.Reader |
| io.Closer |
| } |