os: mark pipes returned by os.Pipe() as inheritable by default

Now that we don't automatically pass all inheritable handles to new
processes, we can make pipes returned by os.Pipe() inheritable, just
like they are on Unix. This then allows them to be passed through the
SysProcAttr.AdditionalInheritedHandles parameter simply.

Updates #44011.
Fixes #21085.

Change-Id: I8eae329fbc74f9dc7962136fa9aae8fb66879751
Reviewed-on: https://go-review.googlesource.com/c/go/+/288299
Trust: Jason A. Donenfeld <Jason@zx2c4.com>
Trust: Alex Brainman <alex.brainman@gmail.com>
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Alex Brainman <alex.brainman@gmail.com>

diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go
index 8b0c93f3826010185fb5cda7c30248b68bb1f704..57591a38abba561e67e33305438103a73515529a 100644 (file)
--- a/src/os/exec/exec_test.go
+++ b/src/os/exec/exec_test.go
@@ -915,6 +915,16 @@ func TestHelperProcess(*testing.T) {
        case "sleep":
                time.Sleep(3 * time.Second)
                os.Exit(0)
+       case "pipehandle":
+               handle, _ := strconv.ParseUint(args[0], 16, 64)
+               pipe := os.NewFile(uintptr(handle), "")
+               _, err := fmt.Fprint(pipe, args[1])
+               if err != nil {
+                       fmt.Fprintf(os.Stderr, "writing to pipe failed: %v\n", err)
+                       os.Exit(1)
+               }
+               pipe.Close()
+               os.Exit(0)
        default:
                fmt.Fprintf(os.Stderr, "Unknown command %q\n", cmd)
                os.Exit(2)

diff --git a/src/os/exec/exec_windows_test.go b/src/os/exec/exec_windows_test.go
new file mode 100644 (file)
index 0000000..fbccffe
--- /dev/null
+++ b/src/os/exec/exec_windows_test.go
@@ -0,0 +1,43 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build windows
+// +build windows
+
+package exec_test
+
+import (
+       "io"
+       "os"
+       "strconv"
+       "syscall"
+       "testing"
+)
+
+func TestPipePassing(t *testing.T) {
+       r, w, err := os.Pipe()
+       if err != nil {
+               t.Error(err)
+       }
+       const marker = "arrakis, dune, desert planet"
+       childProc := helperCommand(t, "pipehandle", strconv.FormatUint(uint64(w.Fd()), 16), marker)
+       childProc.SysProcAttr = &syscall.SysProcAttr{AdditionalInheritedHandles: []syscall.Handle{syscall.Handle(w.Fd())}}
+       err = childProc.Start()
+       if err != nil {
+               t.Error(err)
+       }
+       w.Close()
+       response, err := io.ReadAll(r)
+       if err != nil {
+               t.Error(err)
+       }
+       r.Close()
+       if string(response) != marker {
+               t.Errorf("got %q; want %q", string(response), marker)
+       }
+       err = childProc.Wait()
+       if err != nil {
+               t.Error(err)
+       }
+}

diff --git a/src/os/file_windows.go b/src/os/file_windows.go
index dfc5fc6ce68656492ba4cf861e6cfffed31c6c54..0d3c048a7597c39d07bb0d816dc74d17086d70c5 100644 (file)
--- a/src/os/file_windows.go
+++ b/src/os/file_windows.go
@@ -279,10 +279,11 @@ func rename(oldname, newname string) error {
 }
 
 // Pipe returns a connected pair of Files; reads from r return bytes written to w.
-// It returns the files and an error, if any.
+// It returns the files and an error, if any. The Windows handles underlying
+// the returned files are marked as inheritable by child processes.
 func Pipe() (r *File, w *File, err error) {
        var p [2]syscall.Handle
-       e := syscall.CreatePipe(&p[0], &p[1], nil, 0)
+       e := syscall.Pipe(p[:])
        if e != nil {
                return nil, nil, NewSyscallError("pipe", e)
        }