proper error reporting on ssh errors

Author: problame

Diff for: Gopkg.lock

@@ -7,6 +7,8 @@ import (
 	"io"
 	"bytes"
 	"github.com/problame/go-rwccmd"
+	"os/exec"
+	"syscall"
 )
 
 type Endpoint struct {
@@ -29,7 +31,7 @@ func (e Endpoint) CmdArgs() (cmd string, args []string, env []string) {
 	args = make([]string, 0, 2*len(e.Options)+4)
 	args = append(args,
 		"-p", fmt.Sprintf("%d", e.Port),
-		"-q",
+		"-T",
 		"-i", e.IdentityFile,
 		"-o", "BatchMode=yes",
 	)
@@ -110,11 +112,66 @@ var banner_msg = mustMessage("SSHCON_HELO")
 var proxy_error_msg = mustMessage("SSHCON_PROXY_ERROR")
 var begin_msg = mustMessage("SSHCON_BEGIN")
 
+type SSHError struct {
+	RWCError error
+	WhileActivity string
+}
+
+// Error() will try to present a one-line error message unless ssh stderr output is longer than one line
+func (e *SSHError) Error() string {
+
+	if e.RWCError == io.EOF {
+		// rwccmd returns io.EOF on exit status 0, but we do not expect ssh to do that
+		return fmt.Sprintf("ssh exited unexpectedly with exit status 0")
+	}
+
+	exitErr, ok := e.RWCError.(*exec.ExitError)
+	if !ok {
+		return fmt.Sprintf("ssh: %s", e.RWCError)
+	}
+
+	ws := exitErr.ProcessState.Sys().(syscall.WaitStatus)
+	var wsmsg string
+	if ws.Exited() {
+		wsmsg = fmt.Sprintf("(exit status %d)", ws.ExitStatus())
+	} else {
+		wsmsg = fmt.Sprintf("(%s)", ws.Signal())
+	}
+
+	haveSSHMessage := len(exitErr.Stderr) > 0
+	sshOnelineStderr := false
+	if i := bytes.Index(exitErr.Stderr, []byte("\n")); i == len(exitErr.Stderr)-1 {
+		sshOnelineStderr = true
+	}
+	stderr := bytes.TrimSpace(exitErr.Stderr)
+
+	if haveSSHMessage {
+		if sshOnelineStderr {
+			return fmt.Sprintf("ssh: '%s' %s", stderr, wsmsg) // FIXME proper single-quoting
+		} else {
+			return fmt.Sprintf("ssh %s\n%s", wsmsg, stderr)
+		}
+	}
+
+	return fmt.Sprintf("ssh terminated without stderr output %s", wsmsg)
+
+}
+
+type ProtocolError struct {
+	What string
+}
+
+func (e ProtocolError) Error() string {
+	return e.What
+}
+
 // Dial connects to the remote endpoint where it expects a command executing Proxy().
 // Dial performs a handshake consisting of the exchange of banner messages before returning the connection.
 // If the handshake cannot be completed before dialCtx is Done(), the underlying ssh command is killed
 // and the dialCtx.Err() returned.
 // If the handshake completes, dialCtx's deadline does not affect the returned connection.
+//
+// Errors returned are either dialCtx.Err(), or intances of ProtocolError or *SSHError
 func Dial(dialCtx context.Context, endpoint Endpoint) (*SSHConn , error) {
 
 	sshCmd, sshArgs, sshEnv := endpoint.CmdArgs()
@@ -131,24 +188,24 @@ func Dial(dialCtx context.Context, endpoint Endpoint) (*SSHConn , error) {
 	go func() {
 		var buf bytes.Buffer
 		if _, err := io.CopyN(&buf, cmd, int64(len(banner_msg))); err != nil {
-			confErrChan <- fmt.Errorf("error reading banner: %s", err)
+			confErrChan <- &SSHError{err, "read banner"}
 			return
 		}
 		resp := buf.Bytes()
 		switch {
 		case bytes.Equal(resp, banner_msg):
 			break
 		case bytes.Equal(resp, proxy_error_msg):
-			confErrChan <- fmt.Errorf("proxy error, check remote configuration")
+			confErrChan <- ProtocolError{"proxy error, check remote configuration"}
 			return
 		default:
-			confErrChan <- fmt.Errorf("unknown banner message: %v", resp)
+			confErrChan <- ProtocolError{fmt.Sprintf("unknown banner message: %v", resp)}
 			return
 		}
 		buf.Reset()
 		buf.Write(begin_msg)
 		if _, err := io.Copy(cmd, &buf); err != nil {
-			confErrChan <- fmt.Errorf("error sending begin message: %s", err)
+			confErrChan <- &SSHError{err, "send begin message"}
 			return
 		}
 		close(confErrChan)
@@ -165,5 +222,5 @@ func Dial(dialCtx context.Context, endpoint Endpoint) (*SSHConn , error) {
 		}
 	}
 
-	return &SSHConn{cmd}, err
+	return &SSHConn{cmd}, nil
 }