signal_cgo_test.go

Documentation: os/signal

		 1  // Copyright 2017 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  //go:build (darwin || dragonfly || freebsd || (linux && !android) || netbsd || openbsd) && cgo
		 6  // +build darwin dragonfly freebsd linux,!android netbsd openbsd
		 7  // +build cgo
		 8  
		 9  // Note that this test does not work on Solaris: issue #22849.
		10  // Don't run the test on Android because at least some versions of the
		11  // C library do not define the posix_openpt function.
		12  
		13  package signal_test
		14  
		15  import (
		16  	"bufio"
		17  	"bytes"
		18  	"context"
		19  	"fmt"
		20  	"io"
		21  	"io/fs"
		22  	"os"
		23  	"os/exec"
		24  	ptypkg "os/signal/internal/pty"
		25  	"strconv"
		26  	"strings"
		27  	"sync"
		28  	"syscall"
		29  	"testing"
		30  	"time"
		31  )
		32  
		33  func TestTerminalSignal(t *testing.T) {
		34  	const enteringRead = "test program entering read"
		35  	if os.Getenv("GO_TEST_TERMINAL_SIGNALS") != "" {
		36  		var b [1]byte
		37  		fmt.Println(enteringRead)
		38  		n, err := os.Stdin.Read(b[:])
		39  		if n == 1 {
		40  			if b[0] == '\n' {
		41  				// This is what we expect
		42  				fmt.Println("read newline")
		43  			} else {
		44  				fmt.Printf("read 1 byte: %q\n", b)
		45  			}
		46  		} else {
		47  			fmt.Printf("read %d bytes\n", n)
		48  		}
		49  		if err != nil {
		50  			fmt.Println(err)
		51  			os.Exit(1)
		52  		}
		53  		os.Exit(0)
		54  	}
		55  
		56  	t.Parallel()
		57  
		58  	// The test requires a shell that uses job control.
		59  	bash, err := exec.LookPath("bash")
		60  	if err != nil {
		61  		t.Skipf("could not find bash: %v", err)
		62  	}
		63  
		64  	scale := 1
		65  	if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
		66  		if sc, err := strconv.Atoi(s); err == nil {
		67  			scale = sc
		68  		}
		69  	}
		70  	pause := time.Duration(scale) * 10 * time.Millisecond
		71  	wait := time.Duration(scale) * 5 * time.Second
		72  
		73  	// The test only fails when using a "slow device," in this
		74  	// case a pseudo-terminal.
		75  
		76  	pty, procTTYName, err := ptypkg.Open()
		77  	if err != nil {
		78  		ptyErr := err.(*ptypkg.PtyError)
		79  		if ptyErr.FuncName == "posix_openpt" && ptyErr.Errno == syscall.EACCES {
		80  			t.Skip("posix_openpt failed with EACCES, assuming chroot and skipping")
		81  		}
		82  		t.Fatal(err)
		83  	}
		84  	defer pty.Close()
		85  	procTTY, err := os.OpenFile(procTTYName, os.O_RDWR, 0)
		86  	if err != nil {
		87  		t.Fatal(err)
		88  	}
		89  	defer procTTY.Close()
		90  
		91  	// Start an interactive shell.
		92  	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		93  	defer cancel()
		94  	cmd := exec.CommandContext(ctx, bash, "--norc", "--noprofile", "-i")
		95  	// Clear HISTFILE so that we don't read or clobber the user's bash history.
		96  	cmd.Env = append(os.Environ(), "HISTFILE=")
		97  	cmd.Stdin = procTTY
		98  	cmd.Stdout = procTTY
		99  	cmd.Stderr = procTTY
	 100  	cmd.SysProcAttr = &syscall.SysProcAttr{
	 101  		Setsid:	true,
	 102  		Setctty: true,
	 103  		Ctty:		0,
	 104  	}
	 105  
	 106  	if err := cmd.Start(); err != nil {
	 107  		t.Fatal(err)
	 108  	}
	 109  
	 110  	if err := procTTY.Close(); err != nil {
	 111  		t.Errorf("closing procTTY: %v", err)
	 112  	}
	 113  
	 114  	progReady := make(chan bool)
	 115  	sawPrompt := make(chan bool, 10)
	 116  	const prompt = "prompt> "
	 117  
	 118  	// Read data from pty in the background.
	 119  	var wg sync.WaitGroup
	 120  	wg.Add(1)
	 121  	defer wg.Wait()
	 122  	go func() {
	 123  		defer wg.Done()
	 124  		input := bufio.NewReader(pty)
	 125  		var line, handled []byte
	 126  		for {
	 127  			b, err := input.ReadByte()
	 128  			if err != nil {
	 129  				if len(line) > 0 || len(handled) > 0 {
	 130  					t.Logf("%q", append(handled, line...))
	 131  				}
	 132  				if perr, ok := err.(*fs.PathError); ok {
	 133  					err = perr.Err
	 134  				}
	 135  				// EOF means pty is closed.
	 136  				// EIO means child process is done.
	 137  				// "file already closed" means deferred close of pty has happened.
	 138  				if err != io.EOF && err != syscall.EIO && !strings.Contains(err.Error(), "file already closed") {
	 139  					t.Logf("error reading from pty: %v", err)
	 140  				}
	 141  				return
	 142  			}
	 143  
	 144  			line = append(line, b)
	 145  
	 146  			if b == '\n' {
	 147  				t.Logf("%q", append(handled, line...))
	 148  				line = nil
	 149  				handled = nil
	 150  				continue
	 151  			}
	 152  
	 153  			if bytes.Contains(line, []byte(enteringRead)) {
	 154  				close(progReady)
	 155  				handled = append(handled, line...)
	 156  				line = nil
	 157  			} else if bytes.Contains(line, []byte(prompt)) && !bytes.Contains(line, []byte("PS1=")) {
	 158  				sawPrompt <- true
	 159  				handled = append(handled, line...)
	 160  				line = nil
	 161  			}
	 162  		}
	 163  	}()
	 164  
	 165  	// Set the bash prompt so that we can see it.
	 166  	if _, err := pty.Write([]byte("PS1='" + prompt + "'\n")); err != nil {
	 167  		t.Fatalf("setting prompt: %v", err)
	 168  	}
	 169  	select {
	 170  	case <-sawPrompt:
	 171  	case <-time.After(wait):
	 172  		t.Fatal("timed out waiting for shell prompt")
	 173  	}
	 174  
	 175  	// Start a small program that reads from stdin
	 176  	// (namely the code at the top of this function).
	 177  	if _, err := pty.Write([]byte("GO_TEST_TERMINAL_SIGNALS=1 " + os.Args[0] + " -test.run=TestTerminalSignal\n")); err != nil {
	 178  		t.Fatal(err)
	 179  	}
	 180  
	 181  	// Wait for the program to print that it is starting.
	 182  	select {
	 183  	case <-progReady:
	 184  	case <-time.After(wait):
	 185  		t.Fatal("timed out waiting for program to start")
	 186  	}
	 187  
	 188  	// Give the program time to enter the read call.
	 189  	// It doesn't matter much if we occasionally don't wait long enough;
	 190  	// we won't be testing what we want to test, but the overall test
	 191  	// will pass.
	 192  	time.Sleep(pause)
	 193  
	 194  	// Send a ^Z to stop the program.
	 195  	if _, err := pty.Write([]byte{26}); err != nil {
	 196  		t.Fatalf("writing ^Z to pty: %v", err)
	 197  	}
	 198  
	 199  	// Wait for the program to stop and return to the shell.
	 200  	select {
	 201  	case <-sawPrompt:
	 202  	case <-time.After(wait):
	 203  		t.Fatal("timed out waiting for shell prompt")
	 204  	}
	 205  
	 206  	// Restart the stopped program.
	 207  	if _, err := pty.Write([]byte("fg\n")); err != nil {
	 208  		t.Fatalf("writing %q to pty: %v", "fg", err)
	 209  	}
	 210  
	 211  	// Give the process time to restart.
	 212  	// This is potentially racy: if the process does not restart
	 213  	// quickly enough then the byte we send will go to bash rather
	 214  	// than the program. Unfortunately there isn't anything we can
	 215  	// look for to know that the program is running again.
	 216  	// bash will print the program name, but that happens before it
	 217  	// restarts the program.
	 218  	time.Sleep(10 * pause)
	 219  
	 220  	// Write some data for the program to read,
	 221  	// which should cause it to exit.
	 222  	if _, err := pty.Write([]byte{'\n'}); err != nil {
	 223  		t.Fatalf("writing %q to pty: %v", "\n", err)
	 224  	}
	 225  
	 226  	// Wait for the program to exit.
	 227  	select {
	 228  	case <-sawPrompt:
	 229  	case <-time.After(wait):
	 230  		t.Fatal("timed out waiting for shell prompt")
	 231  	}
	 232  
	 233  	// Exit the shell with the program's exit status.
	 234  	if _, err := pty.Write([]byte("exit $?\n")); err != nil {
	 235  		t.Fatalf("writing %q to pty: %v", "exit", err)
	 236  	}
	 237  
	 238  	if err = cmd.Wait(); err != nil {
	 239  		t.Errorf("subprogram failed: %v", err)
	 240  	}
	 241  }
	 242
View as plain text