io.Copy blocked after closing

[eudore]

After ptmx is closed, io.Copy will not read and return an error.

example:

package main

import (
	"os/exec"
	"io"
	"fmt"
	"time"
	"github.com/creack/pty"
)

type w struct{}

func main() {
	cmd := exec.Command("bash")
	ptmx, err := pty.Start(cmd)
	if err != nil {
		panic(err)
	}
	go func() {
		time.Sleep(1* time.Second)
		fmt.Println("timeout")
		ptmx.Close()
	}()
	fmt.Println(io.Copy(&w{}, ptmx))
	fmt.Println("stop")
}

func (*w) Write(p []byte) (int,error) {
	return len(p), nil
}

example2:

func main() {
	cmd := exec.Command("bash")
	ptmx, err := pty.Start(cmd)
	if err != nil {
		panic(err)
	}
	go func() {
		time.Sleep(1 * time.Second)
		fmt.Println("timeout")
		ptmx.Close()
	}()
	body := make([]byte, 2048)
	for {
		n, err := ptmx.Read(body)
		if err != nil {
			fmt.Println(err)
			break
		}
		fmt.Println(body[0:n], err)
	}
	fmt.Println("stop")
}

[creack]

This seems like expected behavior.

Could you describe your use case and expected result more in detail?

exec.Command.Start forks the process, resulting the the duplication of the ptmx/tty pair file discriptor. When the ptmx gets closed in the parent, it doesn't close the child one.

[eudore]

Usually src or dest can exit after calling Close method io.Copy.
I hope that ptmx.Close will close the bidirectional io.Copy, so how should I close the pty accurately?

Scenario: websocket reads and writes a bash terminal.

The NewWebscoketConn function will convert ws.Conn into an rwc object, and then io.Copy uses rwc and ptmx to exchange read and write data streams.

The object returned by the NewWebscoketConn function implements the io.ReadWriteCloser interface, which encapsulates the reading and writing of websocket data.

import (
	"github.com/creack/pty"
	"github.com/gobwas/ws"
)
func handlebash(w http.ResponseWriter, r *http.Request) {
	conn, _, _, err := ws.UpgradeHTTP(r, w)
	if err != nil {
		return
	}

	cmd := exec.Command("bash")
	ptmx, err := pty.Start(cmd)
	if err != nil {
		return
	}
	log.Println("start bash")

	wconn := NewWebscoketConn(conn)
	go func() {
		log.Println(io.Copy(ptmx, wconn))
		log.Println("stop wconn", wconn.Close())
		ptmx.Write([]byte(" "))
		ptmx.Close()
	}()
	go func() {
		log.Println(io.Copy(wconn, ptmx))
		log.Println("stop ptmx", ptmx.Close())
		// wconn.Write([]byte("\r\n"))
		wconn.Close()
	}()
}

Initially, after wconn.Close (), Write triggers err to exit io.Copy.

With your prompt, I modified an implementation that uses ctx to close cmd to close ptmx.

	ctx, cannel := context.WithCancel(context.Background())
	cmd := exec.CommandContext(ctx, "bash")
	go func() {
		log.Println(io.Copy(ptmx, wconn))
		log.Println("stop wconn", wconn.Close())
		cannel()
	}()
	go func() {
		log.Println(io.Copy(wconn, ptmx))
		log.Println("stop ptmx")
	}()