package client import ( "bytes" "encoding/base64" "encoding/json" "errors" "fmt" "io" "io/ioutil" "net/http" "net/url" "os" gosignal "os/signal" "runtime" "strconv" "strings" "time" "github.com/Sirupsen/logrus" "github.com/docker/docker/api" "github.com/docker/docker/api/types" "github.com/docker/docker/cliconfig" "github.com/docker/docker/dockerversion" "github.com/docker/docker/pkg/jsonmessage" "github.com/docker/docker/pkg/signal" "github.com/docker/docker/pkg/stdcopy" "github.com/docker/docker/pkg/term" "github.com/docker/docker/registry" "github.com/docker/docker/utils" ) var ( errConnectionFailed = errors.New("Cannot connect to the Docker daemon. Is the docker daemon running on this host?") ) type serverResponse struct { body io.ReadCloser header http.Header statusCode int } // HTTPClient creates a new HTTP client with the cli's client transport instance. func (cli *DockerCli) HTTPClient() *http.Client { return &http.Client{Transport: cli.transport} } func (cli *DockerCli) encodeData(data interface{}) (*bytes.Buffer, error) { params := bytes.NewBuffer(nil) if data != nil { if err := json.NewEncoder(params).Encode(data); err != nil { return nil, err } } return params, nil } func (cli *DockerCli) clientRequest(method, path string, in io.Reader, headers map[string][]string) (*serverResponse, error) { serverResp := &serverResponse{ body: nil, statusCode: -1, } expectedPayload := (method == "POST" || method == "PUT") if expectedPayload && in == nil { in = bytes.NewReader([]byte{}) } req, err := http.NewRequest(method, fmt.Sprintf("%s/v%s%s", cli.basePath, api.Version, path), in) if err != nil { return serverResp, err } // Add CLI Config's HTTP Headers BEFORE we set the Docker headers // then the user can't change OUR headers for k, v := range cli.configFile.HTTPHeaders { req.Header.Set(k, v) } req.Header.Set("User-Agent", "Docker-Client/"+dockerversion.Version+" ("+runtime.GOOS+")") req.URL.Host = cli.addr req.URL.Scheme = cli.scheme if headers != nil { for k, v := range headers { req.Header[k] = v } } if expectedPayload && req.Header.Get("Content-Type") == "" { req.Header.Set("Content-Type", "text/plain") } resp, err := cli.HTTPClient().Do(req) if resp != nil { serverResp.statusCode = resp.StatusCode } if err != nil { if utils.IsTimeout(err) || strings.Contains(err.Error(), "connection refused") || strings.Contains(err.Error(), "dial unix") { return serverResp, errConnectionFailed } if cli.tlsConfig == nil && strings.Contains(err.Error(), "malformed HTTP response") { return serverResp, fmt.Errorf("%v.\n* Are you trying to connect to a TLS-enabled daemon without TLS?", err) } if cli.tlsConfig != nil && strings.Contains(err.Error(), "remote error: bad certificate") { return serverResp, fmt.Errorf("The server probably has client authentication (--tlsverify) enabled. Please check your TLS client certification settings: %v", err) } return serverResp, fmt.Errorf("An error occurred trying to connect: %v", err) } if serverResp.statusCode < 200 || serverResp.statusCode >= 400 { body, err := ioutil.ReadAll(resp.Body) if err != nil { return serverResp, err } if len(body) == 0 { return serverResp, fmt.Errorf("Error: request returned %s for API route and version %s, check if the server supports the requested API version", http.StatusText(serverResp.statusCode), req.URL) } return serverResp, fmt.Errorf("Error response from daemon: %s", bytes.TrimSpace(body)) } serverResp.body = resp.Body serverResp.header = resp.Header return serverResp, nil } // cmdAttempt builds the corresponding registry Auth Header from the given // authConfig. It returns the servers body, status, error response func (cli *DockerCli) cmdAttempt(authConfig cliconfig.AuthConfig, method, path string, in io.Reader, out io.Writer) (io.ReadCloser, int, error) { buf, err := json.Marshal(authConfig) if err != nil { return nil, -1, err } registryAuthHeader := []string{ base64.URLEncoding.EncodeToString(buf), } // begin the request serverResp, err := cli.clientRequest(method, path, in, map[string][]string{ "X-Registry-Auth": registryAuthHeader, }) if err == nil && out != nil { // If we are streaming output, complete the stream since // errors may not appear until later. err = cli.streamBody(serverResp.body, serverResp.header.Get("Content-Type"), true, out, nil) } if err != nil { // Since errors in a stream appear after status 200 has been written, // we may need to change the status code. if strings.Contains(err.Error(), "Authentication is required") || strings.Contains(err.Error(), "Status 401") || strings.Contains(err.Error(), "401 Unauthorized") || strings.Contains(err.Error(), "status code 401") { serverResp.statusCode = http.StatusUnauthorized } } return serverResp.body, serverResp.statusCode, err } func (cli *DockerCli) clientRequestAttemptLogin(method, path string, in io.Reader, out io.Writer, index *registry.IndexInfo, cmdName string) (io.ReadCloser, int, error) { // Resolve the Auth config relevant for this server authConfig := registry.ResolveAuthConfig(cli.configFile, index) body, statusCode, err := cli.cmdAttempt(authConfig, method, path, in, out) if statusCode == http.StatusUnauthorized { fmt.Fprintf(cli.out, "\nPlease login prior to %s:\n", cmdName) if err = cli.CmdLogin(index.GetAuthConfigKey()); err != nil { return nil, -1, err } authConfig = registry.ResolveAuthConfig(cli.configFile, index) return cli.cmdAttempt(authConfig, method, path, in, out) } return body, statusCode, err } func (cli *DockerCli) callWrapper(method, path string, data interface{}, headers map[string][]string) (io.ReadCloser, http.Header, int, error) { sr, err := cli.call(method, path, data, headers) return sr.body, sr.header, sr.statusCode, err } func (cli *DockerCli) call(method, path string, data interface{}, headers map[string][]string) (*serverResponse, error) { params, err := cli.encodeData(data) if err != nil { sr := &serverResponse{ body: nil, header: nil, statusCode: -1, } return sr, nil } if data != nil { if headers == nil { headers = make(map[string][]string) } headers["Content-Type"] = []string{"application/json"} } serverResp, err := cli.clientRequest(method, path, params, headers) return serverResp, err } type streamOpts struct { rawTerminal bool in io.Reader out io.Writer err io.Writer headers map[string][]string } func (cli *DockerCli) stream(method, path string, opts *streamOpts) (*serverResponse, error) { serverResp, err := cli.clientRequest(method, path, opts.in, opts.headers) if err != nil { return serverResp, err } return serverResp, cli.streamBody(serverResp.body, serverResp.header.Get("Content-Type"), opts.rawTerminal, opts.out, opts.err) } func (cli *DockerCli) streamBody(body io.ReadCloser, contentType string, rawTerminal bool, stdout, stderr io.Writer) error { defer body.Close() if api.MatchesContentType(contentType, "application/json") { return jsonmessage.DisplayJSONMessagesStream(body, stdout, cli.outFd, cli.isTerminalOut) } if stdout != nil || stderr != nil { // When TTY is ON, use regular copy var err error if rawTerminal { _, err = io.Copy(stdout, body) } else { _, err = stdcopy.StdCopy(stdout, stderr, body) } logrus.Debugf("[stream] End of stdout") return err } return nil } func (cli *DockerCli) resizeTty(id string, isExec bool) { height, width := cli.getTtySize() if height == 0 && width == 0 { return } v := url.Values{} v.Set("h", strconv.Itoa(height)) v.Set("w", strconv.Itoa(width)) path := "" if !isExec { path = "/containers/" + id + "/resize?" } else { path = "/exec/" + id + "/resize?" } if _, _, err := readBody(cli.call("POST", path+v.Encode(), nil, nil)); err != nil { logrus.Debugf("Error resize: %s", err) } } func waitForExit(cli *DockerCli, containerID string) (int, error) { serverResp, err := cli.call("POST", "/containers/"+containerID+"/wait", nil, nil) if err != nil { return -1, err } defer serverResp.body.Close() var res types.ContainerWaitResponse if err := json.NewDecoder(serverResp.body).Decode(&res); err != nil { return -1, err } return res.StatusCode, nil } // getExitCode perform an inspect on the container. It returns // the running state and the exit code. func getExitCode(cli *DockerCli, containerID string) (bool, int, error) { serverResp, err := cli.call("GET", "/containers/"+containerID+"/json", nil, nil) if err != nil { // If we can't connect, then the daemon probably died. if err != errConnectionFailed { return false, -1, err } return false, -1, nil } defer serverResp.body.Close() var c types.ContainerJSON if err := json.NewDecoder(serverResp.body).Decode(&c); err != nil { return false, -1, err } return c.State.Running, c.State.ExitCode, nil } // getExecExitCode perform an inspect on the exec command. It returns // the running state and the exit code. func getExecExitCode(cli *DockerCli, execID string) (bool, int, error) { serverResp, err := cli.call("GET", "/exec/"+execID+"/json", nil, nil) if err != nil { // If we can't connect, then the daemon probably died. if err != errConnectionFailed { return false, -1, err } return false, -1, nil } defer serverResp.body.Close() //TODO: Should we reconsider having a type in api/types? //this is a response to exex/id/json not container var c struct { Running bool ExitCode int } if err := json.NewDecoder(serverResp.body).Decode(&c); err != nil { return false, -1, err } return c.Running, c.ExitCode, nil } func (cli *DockerCli) monitorTtySize(id string, isExec bool) error { cli.resizeTty(id, isExec) if runtime.GOOS == "windows" { go func() { prevH, prevW := cli.getTtySize() for { time.Sleep(time.Millisecond * 250) h, w := cli.getTtySize() if prevW != w || prevH != h { cli.resizeTty(id, isExec) } prevH = h prevW = w } }() } else { sigchan := make(chan os.Signal, 1) gosignal.Notify(sigchan, signal.SIGWINCH) go func() { for range sigchan { cli.resizeTty(id, isExec) } }() } return nil } func (cli *DockerCli) getTtySize() (int, int) { if !cli.isTerminalOut { return 0, 0 } ws, err := term.GetWinsize(cli.outFd) if err != nil { logrus.Debugf("Error getting size: %s", err) if ws == nil { return 0, 0 } } return int(ws.Height), int(ws.Width) } func readBody(serverResp *serverResponse, err error) ([]byte, int, error) { if serverResp.body != nil { defer serverResp.body.Close() } if err != nil { return nil, serverResp.statusCode, err } body, err := ioutil.ReadAll(serverResp.body) if err != nil { return nil, -1, err } return body, serverResp.statusCode, nil }