teraWeb/backend/internal/serial/stream_pty_linux_test.go

//go:build linux

package serial

import (
	"context"
	"fmt"
	"io"
	"os"
	"reflect"
	"testing"
	"time"

	"golang.org/x/sys/unix"
)

func TestStreamSocketTransfersBinaryThroughLinuxPTY(t *testing.T) {
	master, slavePath := openTestPTY(t)
	defer master.Close()
	configured, err := openSerialDevice(slavePath)
	if err != nil {
		t.Fatalf("open PTY slave for setup: %v", err)
	}
	termios, err := unix.IoctlGetTermios(int(configured.Fd()), unix.TCGETS)
	if err == nil {
		applyTermiosConfig(termios, LineConfig{
			Device: slavePath, BaudRate: 115200, DataBits: 8,
			Parity: "none", StopBits: 1, FlowControl: "none",
		})
		err = unix.IoctlSetTermios(int(configured.Fd()), unix.TCSETS, termios)
	}
	if err != nil {
		configured.Close()
		t.Fatalf("configure PTY slave: %v", err)
	}
	configuredTermios := *termios
	configured.Close()

	resolver := newFakeStreamResolver()
	resolver.devices["CH01"] = slavePath
	manager, err := NewStreamLeaseManager(resolver, StreamLeaseOptions{})
	if err != nil {
		t.Fatal(err)
	}
	socketPath, stop := startStreamSocketServer(t, manager)
	defer stop()
	transport, err := NewStreamSocketClient(socketPath, "pty-integration").Open(context.Background(), "CH01")
	if err != nil {
		t.Fatalf("open stream: %v", err)
	}
	defer transport.Close()

	tx := []byte{0x00, 0x3a, 0xff, '\r', '\n'}
	if _, err := transport.Write(tx); err != nil {
		t.Fatalf("write stream: %v", err)
	}
	gotTX := readWithTimeout(t, master, len(tx))
	if !reflect.DeepEqual(gotTX, tx) {
		t.Fatalf("PTY tx = %v, want %v", gotTX, tx)
	}

	rx := []byte{0xfe, 0x00, 0x7f, '\n'}
	if _, err := master.Write(rx); err != nil {
		t.Fatalf("write PTY master: %v", err)
	}
	gotRX := readWithTimeout(t, transport, len(rx))
	if !reflect.DeepEqual(gotRX, rx) {
		t.Fatalf("PTY rx = %v, want %v", gotRX, rx)
	}
	if err := transport.Close(); err != nil {
		t.Fatalf("close stream: %v", err)
	}
	deadline := time.Now().Add(time.Second)
	for manager.Snapshot().ActiveLeases != 0 && time.Now().Before(deadline) {
		time.Sleep(time.Millisecond)
	}
	readbackDevice, err := openSerialDevice(slavePath)
	if err != nil {
		t.Fatalf("reopen PTY slave: %v", err)
	}
	defer readbackDevice.Close()
	readback, err := unix.IoctlGetTermios(int(readbackDevice.Fd()), unix.TCGETS)
	if err != nil {
		t.Fatalf("read PTY termios after stream: %v", err)
	}
	if !reflect.DeepEqual(*readback, configuredTermios) {
		t.Fatalf("stream changed termios: got %#v, want %#v", *readback, configuredTermios)
	}
}

func openTestPTY(t *testing.T) (*os.File, string) {
	t.Helper()
	fd, err := unix.Open("/dev/ptmx", unix.O_RDWR|unix.O_NOCTTY|unix.O_CLOEXEC, 0)
	if err != nil {
		t.Skipf("open /dev/ptmx: %v", err)
	}
	master := os.NewFile(uintptr(fd), "/dev/ptmx")
	if err := unix.IoctlSetPointerInt(fd, unix.TIOCSPTLCK, 0); err != nil {
		master.Close()
		t.Fatalf("unlock PTY: %v", err)
	}
	number, err := unix.IoctlGetInt(fd, unix.TIOCGPTN)
	if err != nil {
		master.Close()
		t.Fatalf("read PTY number: %v", err)
	}
	return master, fmt.Sprintf("/dev/pts/%d", number)
}

func readWithTimeout(t *testing.T, reader io.Reader, size int) []byte {
	t.Helper()
	result := make(chan struct {
		data []byte
		err  error
	}, 1)
	go func() {
		buffer := make([]byte, size)
		_, err := io.ReadFull(reader, buffer)
		result <- struct {
			data []byte
			err  error
		}{buffer, err}
	}()
	select {
	case value := <-result:
		if value.err != nil {
			t.Fatalf("read %d bytes: %v", size, value.err)
		}
		return value.data
	case <-time.After(3 * time.Second):
		t.Fatalf("timed out reading %d bytes", size)
		return nil
	}
}