Files
faceclaw/native/ssh/channels.go
T

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)
}
}