Supports sending output to clients when running programs remotely

_fixtures/out_redirect.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	fmt.Println("hello world!")
+	fmt.Fprintf(os.Stdout, "hello world!")
+	fmt.Fprintf(os.Stderr, "hello world!\n")
+	fmt.Fprintf(os.Stderr, "hello world! error!")
+}

cmd/dlv/cmds/commands.go

@@ -19,6 +19,7 @@ import (
 	"github.com/go-delve/delve/pkg/gobuild"
 	"github.com/go-delve/delve/pkg/goversion"
 	"github.com/go-delve/delve/pkg/logflags"
+	"github.com/go-delve/delve/pkg/proc"
 	"github.com/go-delve/delve/pkg/terminal"
 	"github.com/go-delve/delve/pkg/version"
 	"github.com/go-delve/delve/service"
@@ -985,7 +986,7 @@ func execute(attachPid int, processArgs []string, conf *config.Config, coreFile
 				DebugInfoDirectories: conf.DebugInfoDirectories,
 				CheckGoVersion:       checkGoVersion,
 				TTY:                  tty,
-				Redirects:            redirects,
+				Redirect:             proc.NewRedirectByPath(redirects),
 				DisableASLR:          disableASLR,
 				RrOnProcessPid:       rrOnProcessPid,
 			},

pkg/proc/gdbserial/rr.go

@@ -20,7 +20,7 @@ import (
 // program. Returns a run function which will actually record the program, a
 // stop function which will prematurely terminate the recording of the
 // program.
-func RecordAsync(cmd []string, wd string, quiet bool, redirects [3]string) (run func() (string, error), stop func() error, err error) {
+func RecordAsync(cmd []string, wd string, quiet bool, redirects [3]proc.OutputRedirect) (run func() (string, error), stop func() error, err error) {
 	if err := checkRRAvailable(); err != nil {
 		return nil, nil, err
 	}
@@ -63,11 +63,13 @@ func RecordAsync(cmd []string, wd string, quiet bool, redirects [3]string) (run
 	return run, stop, nil
 }
 
-func openRedirects(redirects [3]string, quiet bool) (stdin, stdout, stderr *os.File, closefn func(), err error) {
-	toclose := []*os.File{}
+func openRedirects(redirects [3]proc.OutputRedirect, quiet bool) (stdin, stdout, stderr *os.File, closefn func(), err error) {
+	var (
+		toclose = []*os.File{}
+	)
 
-	if redirects[0] != "" {
-		stdin, err = os.Open(redirects[0])
+	if redirects[0].Path != "" {
+		stdin, err = os.Open(redirects[0].Path)
 		if err != nil {
 			return nil, nil, nil, nil, err
 		}
@@ -76,19 +78,25 @@ func openRedirects(redirects [3]string, quiet bool) (stdin, stdout, stderr *os.F
 		stdin = os.Stdin
 	}
 
-	create := func(path string, dflt *os.File) *os.File {
-		if path == "" {
-			if quiet {
-				return nil
+	create := func(redirect proc.OutputRedirect, dflt *os.File) (f *os.File) {
+		if redirect.Path != "" {
+			f, err = os.Create(redirect.Path)
+			if f != nil {
+				toclose = append(toclose, f)
 			}
-			return dflt
+
+			return f
+		} else if redirect.File != nil {
+			toclose = append(toclose, redirect.File)
+
+			return redirect.File
 		}
-		var f *os.File
-		f, err = os.Create(path)
-		if f != nil {
-			toclose = append(toclose, f)
+
+		if quiet {
+			return nil
 		}
-		return f
+
+		return dflt
 	}
 
 	stdout = create(redirects[1], os.Stdout)
@@ -112,7 +120,7 @@ func openRedirects(redirects [3]string, quiet bool) (stdin, stdout, stderr *os.F
 
 // Record uses rr to record the execution of the specified program and
 // returns the trace directory's path.
-func Record(cmd []string, wd string, quiet bool, redirects [3]string) (tracedir string, err error) {
+func Record(cmd []string, wd string, quiet bool, redirects [3]proc.OutputRedirect) (tracedir string, err error) {
 	run, _, err := RecordAsync(cmd, wd, quiet, redirects)
 	if err != nil {
 		return "", err
@@ -288,7 +296,7 @@ func rrParseGdbCommand(line string) rrInit {
 }
 
 // RecordAndReplay acts like calling Record and then Replay.
-func RecordAndReplay(cmd []string, wd string, quiet bool, debugInfoDirs []string, redirects [3]string) (*proc.TargetGroup, string, error) {
+func RecordAndReplay(cmd []string, wd string, quiet bool, debugInfoDirs []string, redirects [3]proc.OutputRedirect) (*proc.TargetGroup, string, error) {
 	tracedir, err := Record(cmd, wd, quiet, redirects)
 	if tracedir == "" {
 		return nil, "", err

pkg/proc/gdbserial/rr_test.go

@@ -30,7 +30,7 @@ func withTestRecording(name string, t testing.TB, fn func(grp *proc.TargetGroup,
 		t.Skip("test skipped, rr not found")
 	}
 	t.Log("recording")
-	grp, tracedir, err := gdbserial.RecordAndReplay([]string{fixture.Path}, ".", true, []string{}, [3]string{})
+	grp, tracedir, err := gdbserial.RecordAndReplay([]string{fixture.Path}, ".", true, []string{}, proc.NewEmptyRedirect())
 	if err != nil {
 		t.Fatal("Launch():", err)
 	}

pkg/proc/namedpipe_other.go

@@ -0,0 +1,84 @@
+//go:build !windows
+// +build !windows
+
+package proc
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"io"
+	"os"
+	"path/filepath"
+	"sync/atomic"
+	"syscall"
+)
+
+type openOnRead struct {
+	p      string
+	rd     io.ReadCloser
+	status int32 // 0: initialization 1: file is opened 2: file is closed
+}
+
+func (oor *openOnRead) Read(p []byte) (n int, err error) {
+	if oor.rd != nil {
+		return oor.rd.Read(p)
+	}
+
+	// try from "into" to "open"
+	if !atomic.CompareAndSwapInt32(&oor.status, 0, 1) {
+		return 0, io.EOF
+	}
+
+	fh, err := os.OpenFile(oor.p, os.O_RDONLY, os.ModeNamedPipe)
+	if err != nil {
+		return 0, err
+	}
+
+	oor.rd = fh
+	return oor.rd.Read(p)
+}
+
+func (oor *openOnRead) Close() error {
+	defer os.Remove(oor.p)
+
+	// try from "init" to "close".
+	if !atomic.CompareAndSwapInt32(&oor.status, 0, 2) {
+		// try from "open" to "close"
+		if atomic.CompareAndSwapInt32(&oor.status, 1, 2) {
+			// Make the "oor.Read()" function stop blocking
+			_, err := os.OpenFile(oor.p, os.O_WRONLY, os.ModeNamedPipe)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return oor.rd.Close()
+}
+
+func NamedPipe() (reader [2]io.ReadCloser, output [3]OutputRedirect, err error) {
+	r := make([]byte, 4)
+	if _, err = rand.Read(r); err != nil {
+		return reader, output, err
+	}
+
+	var (
+		prefix     = filepath.Join(os.TempDir(), hex.EncodeToString(r))
+		stdoutPath = prefix + "stdout"
+		stderrPath = prefix + "stderr"
+	)
+
+	if err = syscall.Mkfifo(stdoutPath, 0o600); err != nil {
+		return reader, output, err
+	}
+
+	if err := syscall.Mkfifo(stderrPath, 0o600); err != nil {
+		_ = os.Remove(stdoutPath)
+		return reader, output, err
+	}
+
+	reader[0] = &openOnRead{p: stdoutPath}
+	reader[1] = &openOnRead{p: stderrPath}
+
+	return reader, NewRedirectByPath([3]string{"", stdoutPath, stderrPath}), nil
+}

pkg/proc/namedpipe_windows.go

@@ -0,0 +1,23 @@
+//go:build windows
+// +build windows
+
+package proc
+
+import (
+	"io"
+	"os"
+)
+
+func NamedPipe() (reader [2]io.ReadCloser, output [3]OutputRedirect, err error) {
+	reader[0], output[1].File, err = os.Pipe()
+	if err != nil {
+		return reader, output, err
+	}
+
+	reader[1], output[2].File, err = os.Pipe()
+	if err != nil {
+		return reader, output, err
+	}
+
+	return reader, output, nil
+}

pkg/proc/native/nonative_darwin.go

@@ -16,7 +16,7 @@ import (
 var ErrNativeBackendDisabled = errors.New("native backend disabled during compilation")
 
 // Launch returns ErrNativeBackendDisabled.
-func Launch(_ []string, _ string, _ proc.LaunchFlags, _ []string, _ string, _ [3]string) (*proc.TargetGroup, error) {
+func Launch(_ []string, _ string, _ proc.LaunchFlags, _ []string, _ string, _ [3]proc.OutputRedirect) (*proc.TargetGroup, error) {
 	return nil, ErrNativeBackendDisabled
 }
 

pkg/proc/native/proc.go

@@ -370,11 +370,13 @@ func (dbp *nativeProcess) writeSoftwareBreakpoint(thread *nativeThread, addr uin
 	return err
 }
 
-func openRedirects(redirects [3]string, foreground bool) (stdin, stdout, stderr *os.File, closefn func(), err error) {
-	toclose := []*os.File{}
+func openRedirects(redirects [3]proc.OutputRedirect, foreground bool) (stdin, stdout, stderr *os.File, closefn func(), err error) {
+	var (
+		toclose = []*os.File{}
+	)
 
-	if redirects[0] != "" {
-		stdin, err = os.Open(redirects[0])
+	if redirects[0].Path != "" {
+		stdin, err = os.Open(redirects[0].Path)
 		if err != nil {
 			return nil, nil, nil, nil, err
 		}
@@ -383,16 +385,21 @@ func openRedirects(redirects [3]string, foreground bool) (stdin, stdout, stderr
 		stdin = os.Stdin
 	}
 
-	create := func(path string, dflt *os.File) *os.File {
-		if path == "" {
-			return dflt
-		}
-		var f *os.File
-		f, err = os.Create(path)
-		if f != nil {
-			toclose = append(toclose, f)
+	create := func(redirect proc.OutputRedirect, dflt *os.File) (f *os.File) {
+		if redirect.Path != "" {
+			f, err = os.Create(redirect.Path)
+			if f != nil {
+				toclose = append(toclose, f)
+			}
+
+			return f
+		} else if redirect.File != nil {
+			toclose = append(toclose, redirect.File)
+
+			return redirect.File
 		}
-		return f
+
+		return dflt
 	}
 
 	stdout = create(redirects[1], os.Stdout)

pkg/proc/native/proc_darwin.go

@@ -42,7 +42,7 @@ func (os *osProcessDetails) Close() {}
 // custom fork/exec process in order to take advantage of
 // PT_SIGEXC on Darwin which will turn Unix signals into
 // Mach exceptions.
-func Launch(cmd []string, wd string, flags proc.LaunchFlags, _ []string, _ string, _ [3]string) (*proc.TargetGroup, error) {
+func Launch(cmd []string, wd string, flags proc.LaunchFlags, _ []string, _ string, _ [3]proc.OutputRedirect) (*proc.TargetGroup, error) {
 	argv0Go, err := filepath.Abs(cmd[0])
 	if err != nil {
 		return nil, err

pkg/proc/native/proc_freebsd.go

@@ -55,7 +55,7 @@ func (os *osProcessDetails) Close() {}
 // to be supplied to that process. `wd` is working directory of the program.
 // If the DWARF information cannot be found in the binary, Delve will look
 // for external debug files in the directories passed in.
-func Launch(cmd []string, wd string, flags proc.LaunchFlags, debugInfoDirs []string, tty string, redirects [3]string) (*proc.TargetGroup, error) {
+func Launch(cmd []string, wd string, flags proc.LaunchFlags, debugInfoDirs []string, tty string, redirects [3]proc.OutputRedirect) (*proc.TargetGroup, error) {
 	var (
 		process *exec.Cmd
 		err     error

pkg/proc/native/proc_linux.go

@@ -62,15 +62,15 @@ func (os *osProcessDetails) Close() {
 // to be supplied to that process. `wd` is working directory of the program.
 // If the DWARF information cannot be found in the binary, Delve will look
 // for external debug files in the directories passed in.
-func Launch(cmd []string, wd string, flags proc.LaunchFlags, debugInfoDirs []string, tty string, redirects [3]string) (*proc.TargetGroup, error) {
+func Launch(cmd []string, wd string, flags proc.LaunchFlags, debugInfoDirs []string, tty string, redirect [3]proc.OutputRedirect) (*proc.TargetGroup, error) {
 	var (
 		process *exec.Cmd
 		err     error
 	)
 
 	foreground := flags&proc.LaunchForeground != 0
 
-	stdin, stdout, stderr, closefn, err := openRedirects(redirects, foreground)
+	stdin, stdout, stderr, closefn, err := openRedirects(redirect, foreground)
 	if err != nil {
 		return nil, err
 	}

pkg/proc/native/proc_windows.go

@@ -23,7 +23,7 @@ type osProcessDetails struct {
 func (os *osProcessDetails) Close() {}
 
 // Launch creates and begins debugging a new process.
-func Launch(cmd []string, wd string, flags proc.LaunchFlags, _ []string, _ string, redirects [3]string) (*proc.TargetGroup, error) {
+func Launch(cmd []string, wd string, flags proc.LaunchFlags, _ []string, _ string, redirects [3]proc.OutputRedirect) (*proc.TargetGroup, error) {
 	argv0Go := cmd[0]
 
 	env := proc.DisableAsyncPreemptEnv()

pkg/proc/proc_linux_test.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/go-delve/delve/pkg/proc"
 	"github.com/go-delve/delve/pkg/proc/native"
 	protest "github.com/go-delve/delve/pkg/proc/test"
 )
@@ -14,7 +15,7 @@ func TestLoadingExternalDebugInfo(t *testing.T) {
 	fixture := protest.BuildFixture("locationsprog", 0)
 	defer os.Remove(fixture.Path)
 	stripAndCopyDebugInfo(fixture, t)
-	p, err := native.Launch(append([]string{fixture.Path}, ""), "", 0, []string{filepath.Dir(fixture.Path)}, "", [3]string{})
+	p, err := native.Launch(append([]string{fixture.Path}, ""), "", 0, []string{filepath.Dir(fixture.Path)}, "", proc.NewEmptyRedirect())
 	if err != nil {
 		t.Fatal(err)
 	}