255 lines
7.3 KiB
Go
255 lines
7.3 KiB
Go
package faceclawssh
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"github.com/gorilla/websocket"
|
|
"golang.org/x/crypto/ssh"
|
|
)
|
|
|
|
type closedPayload struct {
|
|
ExitStatus *int `json:"exitStatus,omitempty"`
|
|
Signal string `json:"signal,omitempty"`
|
|
Code *int `json:"code,omitempty"`
|
|
Reason string `json:"reason,omitempty"`
|
|
}
|
|
|
|
// runExec runs command on the host and relays newline-delimited text both
|
|
// ways until the command exits, the connection drops, or Close.
|
|
func (c *Channel) runExec(conn *pooledConn, command string) {
|
|
session, err := conn.client.NewSession()
|
|
if err != nil {
|
|
c.fail(channelOpenFailure(conn, err))
|
|
return
|
|
}
|
|
defer session.Close()
|
|
stdin, err1 := session.StdinPipe()
|
|
stdout, err2 := session.StdoutPipe()
|
|
stderr, err3 := session.StderrPipe()
|
|
if err := errors.Join(err1, err2, err3); err != nil {
|
|
c.fail(&failure{Kind: "channel", Message: err.Error()})
|
|
return
|
|
}
|
|
if err := session.Start(command); err != nil {
|
|
c.fail(&failure{Kind: "channel", Message: "could not run command: " + err.Error()})
|
|
return
|
|
}
|
|
go func() {
|
|
<-c.ctx.Done()
|
|
session.Close()
|
|
}()
|
|
c.markOpen()
|
|
go func() {
|
|
defer c.guard()
|
|
for text := range c.sendQ {
|
|
if _, err := io.WriteString(stdin, text+"\n"); err != nil {
|
|
return
|
|
}
|
|
}
|
|
// Close was called and the queue has drained: EOF tells the command
|
|
// we're done (tmux control mode detaches on it).
|
|
stdin.Close()
|
|
}()
|
|
stderrDone := make(chan struct{})
|
|
go func() {
|
|
defer close(stderrDone)
|
|
defer c.guard()
|
|
readLines(stderr, func(line string) { c.emit("stderr", line) })
|
|
}()
|
|
readErr := readLines(stdout, func(line string) { c.emit("text", line) })
|
|
// Deliver the command's last words (e.g. "tmux: command not found")
|
|
// before the close event, but don't hang on a stderr that never ends.
|
|
select {
|
|
case <-stderrDone:
|
|
case <-time.After(500 * time.Millisecond):
|
|
}
|
|
if c.ctx.Err() != nil {
|
|
return
|
|
}
|
|
waitErr := session.Wait()
|
|
var exitErr *ssh.ExitError
|
|
var missing *ssh.ExitMissingError
|
|
switch {
|
|
case waitErr == nil:
|
|
status := 0
|
|
c.finish("closed", closedPayload{ExitStatus: &status})
|
|
case errors.As(waitErr, &exitErr):
|
|
status := exitErr.ExitStatus()
|
|
c.finish("closed", closedPayload{ExitStatus: &status, Signal: exitErr.Signal()})
|
|
case errors.As(waitErr, &missing):
|
|
// The channel closed without an exit status: usually the connection
|
|
// went away under it.
|
|
c.fail(lostFailure(conn, readErr))
|
|
default:
|
|
c.fail(lostFailure(conn, waitErr))
|
|
}
|
|
}
|
|
|
|
// readLines calls emit for each line of r (without its newline) and returns
|
|
// the read error that ended it (nil at EOF). Lines may be arbitrarily long.
|
|
func readLines(r io.Reader, emit func(string)) error {
|
|
reader := bufio.NewReaderSize(r, 64*1024)
|
|
for {
|
|
line, err := reader.ReadBytes('\n')
|
|
if len(line) > 0 {
|
|
if line[len(line)-1] == '\n' {
|
|
line = line[:len(line)-1]
|
|
}
|
|
emit(escapeLine(line))
|
|
}
|
|
if err == io.EOF {
|
|
return nil
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
// escapeLine makes a line safe to hand across the gomobile boundary as a
|
|
// string (which must be valid UTF-8). Valid UTF-8 passes through. Otherwise
|
|
// every byte >= 0x80 becomes "\ooo" (backslash, three octal digits): the same
|
|
// escape tmux control mode uses for control characters and backslashes in
|
|
// %output, so a %output line split mid-character still decodes back to its
|
|
// exact bytes. (Outside %output a literal backslash is ambiguous with this
|
|
// escape; such lines are only ever displayed.)
|
|
func escapeLine(line []byte) string {
|
|
if utf8.Valid(line) {
|
|
return string(line)
|
|
}
|
|
var b strings.Builder
|
|
for _, c := range line {
|
|
if c >= 0x80 {
|
|
fmt.Fprintf(&b, "\\%03o", c)
|
|
} else {
|
|
b.WriteByte(c)
|
|
}
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
// runWebSocket opens rawURL (ws://host:port/path) through the SSH
|
|
// connection — host:port is resolved on the SSH server's side — and relays
|
|
// text frames.
|
|
func (c *Channel) runWebSocket(conn *pooledConn, rawURL string) {
|
|
parsed, err := url.Parse(rawURL)
|
|
if err != nil || parsed.Scheme != "ws" || parsed.Host == "" {
|
|
c.fail(&failure{Kind: "config", Message: fmt.Sprintf("bad websocket URL %q", rawURL)})
|
|
return
|
|
}
|
|
target := parsed.Host
|
|
if parsed.Port() == "" {
|
|
target = net.JoinHostPort(parsed.Hostname(), "80")
|
|
}
|
|
dialer := websocket.Dialer{
|
|
NetDialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
|
|
forwarded, err := conn.client.DialContext(ctx, "tcp", target)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return noDeadlineConn{forwarded}, nil
|
|
},
|
|
}
|
|
// The handshake timeout rides the context: SSH channels can't do deadlines.
|
|
handshakeCtx, cancelHandshake := context.WithTimeout(c.ctx, defaultConnectTimeout)
|
|
ws, _, err := dialer.DialContext(handshakeCtx, rawURL, nil)
|
|
cancelHandshake()
|
|
if err != nil {
|
|
if c.ctx.Err() != nil {
|
|
return
|
|
}
|
|
c.fail(channelOpenFailure(conn, fmt.Errorf("could not reach %s on the host: %w", target, err)))
|
|
return
|
|
}
|
|
defer ws.Close()
|
|
go func() {
|
|
<-c.ctx.Done()
|
|
ws.Close()
|
|
}()
|
|
c.markOpen()
|
|
go func() {
|
|
defer c.guard()
|
|
for text := range c.sendQ {
|
|
if err := ws.WriteMessage(websocket.TextMessage, []byte(text)); err != nil {
|
|
return
|
|
}
|
|
}
|
|
ws.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "bye"),
|
|
time.Now().Add(time.Second))
|
|
}()
|
|
for {
|
|
kind, data, err := ws.ReadMessage()
|
|
if err != nil {
|
|
if c.ctx.Err() != nil {
|
|
return
|
|
}
|
|
var closeErr *websocket.CloseError
|
|
if errors.As(err, &closeErr) {
|
|
code := closeErr.Code
|
|
c.finish("closed", closedPayload{Code: &code, Reason: closeErr.Text})
|
|
return
|
|
}
|
|
c.fail(lostFailure(conn, err))
|
|
return
|
|
}
|
|
if kind == websocket.TextMessage {
|
|
c.emit("text", string(data))
|
|
}
|
|
}
|
|
}
|
|
|
|
// noDeadlineConn adapts an SSH direct-tcpip channel for the websocket
|
|
// library, which sets deadlines the channel doesn't support. Timeouts come
|
|
// from contexts and the SSH keepalive instead.
|
|
type noDeadlineConn struct{ net.Conn }
|
|
|
|
func (noDeadlineConn) SetDeadline(time.Time) error { return nil }
|
|
func (noDeadlineConn) SetReadDeadline(time.Time) error { return nil }
|
|
func (noDeadlineConn) SetWriteDeadline(time.Time) error { return nil }
|
|
|
|
// channelOpenFailure classifies a failure to open a channel: if the SSH
|
|
// connection itself is gone it's a network failure (reconnect), otherwise
|
|
// the host refused this particular channel.
|
|
func channelOpenFailure(conn *pooledConn, err error) *failure {
|
|
if isConnDead(conn) {
|
|
return &failure{Kind: "network", Message: "connection lost: " + err.Error()}
|
|
}
|
|
return &failure{Kind: "channel", Message: err.Error()}
|
|
}
|
|
|
|
func lostFailure(conn *pooledConn, err error) *failure {
|
|
message := "connection lost"
|
|
if err != nil && !errors.Is(err, io.EOF) {
|
|
message += ": " + err.Error()
|
|
}
|
|
if !isConnDead(conn) {
|
|
// The connection is fine; only this channel ended abruptly.
|
|
return &failure{Kind: "channel", Message: "channel closed unexpectedly"}
|
|
}
|
|
return &failure{Kind: "network", Message: message}
|
|
}
|
|
|
|
func isConnDead(conn *pooledConn) bool {
|
|
// client.Wait's goroutine marks the connection dead slightly after the
|
|
// channels see their streams end; give it a moment to catch up.
|
|
deadline := time.Now().Add(200 * time.Millisecond)
|
|
for {
|
|
poolMu.Lock()
|
|
dead := conn.dead
|
|
poolMu.Unlock()
|
|
if dead || time.Now().After(deadline) {
|
|
return dead
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
}
|