github.com/docker/docker@v299999999.0.0-20200612211812-aaf470eca7b5+incompatible/client/request.go (about) 1 package client // import "github.com/docker/docker/client" 2 3 import ( 4 "bytes" 5 "context" 6 "encoding/json" 7 "fmt" 8 "io" 9 "io/ioutil" 10 "net" 11 "net/http" 12 "net/url" 13 "os" 14 "strings" 15 16 "github.com/docker/docker/api/types" 17 "github.com/docker/docker/api/types/versions" 18 "github.com/docker/docker/errdefs" 19 "github.com/pkg/errors" 20 ) 21 22 // serverResponse is a wrapper for http API responses. 23 type serverResponse struct { 24 body io.ReadCloser 25 header http.Header 26 statusCode int 27 reqURL *url.URL 28 } 29 30 // head sends an http request to the docker API using the method HEAD. 31 func (cli *Client) head(ctx context.Context, path string, query url.Values, headers map[string][]string) (serverResponse, error) { 32 return cli.sendRequest(ctx, http.MethodHead, path, query, nil, headers) 33 } 34 35 // get sends an http request to the docker API using the method GET with a specific Go context. 36 func (cli *Client) get(ctx context.Context, path string, query url.Values, headers map[string][]string) (serverResponse, error) { 37 return cli.sendRequest(ctx, http.MethodGet, path, query, nil, headers) 38 } 39 40 // post sends an http request to the docker API using the method POST with a specific Go context. 41 func (cli *Client) post(ctx context.Context, path string, query url.Values, obj interface{}, headers map[string][]string) (serverResponse, error) { 42 body, headers, err := encodeBody(obj, headers) 43 if err != nil { 44 return serverResponse{}, err 45 } 46 return cli.sendRequest(ctx, http.MethodPost, path, query, body, headers) 47 } 48 49 func (cli *Client) postRaw(ctx context.Context, path string, query url.Values, body io.Reader, headers map[string][]string) (serverResponse, error) { 50 return cli.sendRequest(ctx, http.MethodPost, path, query, body, headers) 51 } 52 53 // putRaw sends an http request to the docker API using the method PUT. 54 func (cli *Client) putRaw(ctx context.Context, path string, query url.Values, body io.Reader, headers map[string][]string) (serverResponse, error) { 55 return cli.sendRequest(ctx, http.MethodPut, path, query, body, headers) 56 } 57 58 // delete sends an http request to the docker API using the method DELETE. 59 func (cli *Client) delete(ctx context.Context, path string, query url.Values, headers map[string][]string) (serverResponse, error) { 60 return cli.sendRequest(ctx, http.MethodDelete, path, query, nil, headers) 61 } 62 63 type headers map[string][]string 64 65 func encodeBody(obj interface{}, headers headers) (io.Reader, headers, error) { 66 if obj == nil { 67 return nil, headers, nil 68 } 69 70 body, err := encodeData(obj) 71 if err != nil { 72 return nil, headers, err 73 } 74 if headers == nil { 75 headers = make(map[string][]string) 76 } 77 headers["Content-Type"] = []string{"application/json"} 78 return body, headers, nil 79 } 80 81 func (cli *Client) buildRequest(method, path string, body io.Reader, headers headers) (*http.Request, error) { 82 expectedPayload := (method == http.MethodPost || method == http.MethodPut) 83 if expectedPayload && body == nil { 84 body = bytes.NewReader([]byte{}) 85 } 86 87 req, err := http.NewRequest(method, path, body) 88 if err != nil { 89 return nil, err 90 } 91 req = cli.addHeaders(req, headers) 92 93 if cli.proto == "unix" || cli.proto == "npipe" { 94 // For local communications, it doesn't matter what the host is. We just 95 // need a valid and meaningful host name. (See #189) 96 req.Host = "docker" 97 } 98 99 req.URL.Host = cli.addr 100 req.URL.Scheme = cli.scheme 101 102 if expectedPayload && req.Header.Get("Content-Type") == "" { 103 req.Header.Set("Content-Type", "text/plain") 104 } 105 return req, nil 106 } 107 108 func (cli *Client) sendRequest(ctx context.Context, method, path string, query url.Values, body io.Reader, headers headers) (serverResponse, error) { 109 req, err := cli.buildRequest(method, cli.getAPIPath(ctx, path, query), body, headers) 110 if err != nil { 111 return serverResponse{}, err 112 } 113 resp, err := cli.doRequest(ctx, req) 114 if err != nil { 115 return resp, errdefs.FromStatusCode(err, resp.statusCode) 116 } 117 err = cli.checkResponseErr(resp) 118 return resp, errdefs.FromStatusCode(err, resp.statusCode) 119 } 120 121 func (cli *Client) doRequest(ctx context.Context, req *http.Request) (serverResponse, error) { 122 serverResp := serverResponse{statusCode: -1, reqURL: req.URL} 123 124 req = req.WithContext(ctx) 125 resp, err := cli.client.Do(req) 126 if err != nil { 127 if cli.scheme != "https" && strings.Contains(err.Error(), "malformed HTTP response") { 128 return serverResp, fmt.Errorf("%v.\n* Are you trying to connect to a TLS-enabled daemon without TLS?", err) 129 } 130 131 if cli.scheme == "https" && strings.Contains(err.Error(), "bad certificate") { 132 return serverResp, errors.Wrap(err, "The server probably has client authentication (--tlsverify) enabled. Please check your TLS client certification settings") 133 } 134 135 // Don't decorate context sentinel errors; users may be comparing to 136 // them directly. 137 switch err { 138 case context.Canceled, context.DeadlineExceeded: 139 return serverResp, err 140 } 141 142 if nErr, ok := err.(*url.Error); ok { 143 if nErr, ok := nErr.Err.(*net.OpError); ok { 144 if os.IsPermission(nErr.Err) { 145 return serverResp, errors.Wrapf(err, "Got permission denied while trying to connect to the Docker daemon socket at %v", cli.host) 146 } 147 } 148 } 149 150 if err, ok := err.(net.Error); ok { 151 if err.Timeout() { 152 return serverResp, ErrorConnectionFailed(cli.host) 153 } 154 if !err.Temporary() { 155 if strings.Contains(err.Error(), "connection refused") || strings.Contains(err.Error(), "dial unix") { 156 return serverResp, ErrorConnectionFailed(cli.host) 157 } 158 } 159 } 160 161 // Although there's not a strongly typed error for this in go-winio, 162 // lots of people are using the default configuration for the docker 163 // daemon on Windows where the daemon is listening on a named pipe 164 // `//./pipe/docker_engine, and the client must be running elevated. 165 // Give users a clue rather than the not-overly useful message 166 // such as `error during connect: Get http://%2F%2F.%2Fpipe%2Fdocker_engine/v1.26/info: 167 // open //./pipe/docker_engine: The system cannot find the file specified.`. 168 // Note we can't string compare "The system cannot find the file specified" as 169 // this is localised - for example in French the error would be 170 // `open //./pipe/docker_engine: Le fichier spécifié est introuvable.` 171 if strings.Contains(err.Error(), `open //./pipe/docker_engine`) { 172 // Checks if client is running with elevated privileges 173 if f, elevatedErr := os.Open("\\\\.\\PHYSICALDRIVE0"); elevatedErr == nil { 174 err = errors.Wrap(err, "In the default daemon configuration on Windows, the docker client must be run with elevated privileges to connect.") 175 } else { 176 f.Close() 177 err = errors.Wrap(err, "This error may indicate that the docker daemon is not running.") 178 } 179 } 180 181 return serverResp, errors.Wrap(err, "error during connect") 182 } 183 184 if resp != nil { 185 serverResp.statusCode = resp.StatusCode 186 serverResp.body = resp.Body 187 serverResp.header = resp.Header 188 } 189 return serverResp, nil 190 } 191 192 func (cli *Client) checkResponseErr(serverResp serverResponse) error { 193 if serverResp.statusCode >= 200 && serverResp.statusCode < 400 { 194 return nil 195 } 196 197 var body []byte 198 var err error 199 if serverResp.body != nil { 200 bodyMax := 1 * 1024 * 1024 // 1 MiB 201 bodyR := &io.LimitedReader{ 202 R: serverResp.body, 203 N: int64(bodyMax), 204 } 205 body, err = ioutil.ReadAll(bodyR) 206 if err != nil { 207 return err 208 } 209 if bodyR.N == 0 { 210 return fmt.Errorf("request returned %s with a message (> %d bytes) for API route and version %s, check if the server supports the requested API version", http.StatusText(serverResp.statusCode), bodyMax, serverResp.reqURL) 211 } 212 } 213 if len(body) == 0 { 214 return fmt.Errorf("request returned %s for API route and version %s, check if the server supports the requested API version", http.StatusText(serverResp.statusCode), serverResp.reqURL) 215 } 216 217 var ct string 218 if serverResp.header != nil { 219 ct = serverResp.header.Get("Content-Type") 220 } 221 222 var errorMessage string 223 if (cli.version == "" || versions.GreaterThan(cli.version, "1.23")) && ct == "application/json" { 224 var errorResponse types.ErrorResponse 225 if err := json.Unmarshal(body, &errorResponse); err != nil { 226 return errors.Wrap(err, "Error reading JSON") 227 } 228 errorMessage = strings.TrimSpace(errorResponse.Message) 229 } else { 230 errorMessage = strings.TrimSpace(string(body)) 231 } 232 233 return errors.Wrap(errors.New(errorMessage), "Error response from daemon") 234 } 235 236 func (cli *Client) addHeaders(req *http.Request, headers headers) *http.Request { 237 // Add CLI Config's HTTP Headers BEFORE we set the Docker headers 238 // then the user can't change OUR headers 239 for k, v := range cli.customHTTPHeaders { 240 if versions.LessThan(cli.version, "1.25") && k == "User-Agent" { 241 continue 242 } 243 req.Header.Set(k, v) 244 } 245 246 if headers != nil { 247 for k, v := range headers { 248 req.Header[k] = v 249 } 250 } 251 return req 252 } 253 254 func encodeData(data interface{}) (*bytes.Buffer, error) { 255 params := bytes.NewBuffer(nil) 256 if data != nil { 257 if err := json.NewEncoder(params).Encode(data); err != nil { 258 return nil, err 259 } 260 } 261 return params, nil 262 } 263 264 func ensureReaderClosed(response serverResponse) { 265 if response.body != nil { 266 // Drain up to 512 bytes and close the body to let the Transport reuse the connection 267 io.CopyN(ioutil.Discard, response.body, 512) 268 response.body.Close() 269 } 270 }