Add socket/tcp_fd_passing

examples/socket/tcp_fd_passing/.gitignore

@@ -0,0 +1,3 @@
+tcp-server
+tcp-client
+uds-server

examples/socket/tcp_fd_passing/Taskfile.yml

@@ -0,0 +1,27 @@
+# https://taskfile.dev
+
+version: '3'
+
+vars:
+  GREETING: Hello, World!
+
+tasks:
+  default:
+    cmds:
+      - task: build
+      - task: run
+  build:
+    cmds:
+      - go build -o tcp-client tcpclient/main.go
+      - go build -o tcp-server tcpserver/main.go
+      - go build -o uds-server udsserver/main.go
+  run:
+    cmds:
+      - ./uds-server &
+      - sleep 1
+      - ./tcp-server &
+      - sleep 1
+      - ./tcp-client
+      - pkill tcp-server
+      - pkill uds-server
+    ignore_error: true

examples/socket/tcp_fd_passing/tcpclient/main.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"log"
+	"net"
+	"time"
+)
+
+func main() {
+	log.SetFlags(log.Lmicroseconds)
+
+	if err := run(); err != nil {
+		panic(err)
+	}
+}
+
+func run() error {
+	conn, err := net.Dial("tcp", ":8888")
+	if err != nil {
+		return err
+	}
+	defer func() {
+		conn.Close()
+		log.Println("[TCP-C] close")
+	}()
+	log.Println("[TCP-C] connect tcp-server")
+
+	buf := make([]byte, 5)
+	n, err := conn.Read(buf)
+	if err != nil {
+		switch {
+		case errors.Is(err, io.EOF):
+			return nil
+		default:
+			return err
+		}
+	}
+
+	msg := buf[:n]
+	log.Printf("[TCP-C] recv (%s)", msg)
+
+	msg = bytes.ToUpper(msg)
+	_, err = conn.Write(msg)
+	if err != nil {
+		return err
+	}
+	log.Printf("[TCP-C] send (%s)", msg)
+
+	buf = make([]byte, 1)
+	for {
+		conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
+
+		_, err = conn.Read(buf)
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				log.Println("[TCP-C] disconnect")
+				break
+			}
+
+			return err
+		}
+	}
+
+	return nil
+}

examples/socket/tcp_fd_passing/tcpserver/main.go

@@ -0,0 +1,94 @@
+package main
+
+import (
+	"errors"
+	"log"
+	"net"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+func main() {
+	log.SetFlags(log.Lmicroseconds)
+
+	if err := run(); err != nil {
+		panic(err)
+	}
+}
+
+func run() error {
+	var (
+		udsConn net.Conn
+		err     error
+	)
+	for range 3 {
+		udsConn, err = net.DialTimeout("unix", "@tcp_fd_passing", 1*time.Second)
+		if err != nil {
+			var netErr net.Error
+			if errors.As(err, &netErr); netErr.Timeout() {
+				continue
+			}
+
+			return err
+		}
+
+		break
+	}
+	defer udsConn.Close()
+	log.Println("[TCP-S] connect uds-server")
+
+	ln, err := net.Listen("tcp", ":8888")
+	if err != nil {
+		return err
+	}
+	defer ln.Close()
+	log.Println("[TCP-S] listen on :8888")
+
+	for {
+		errCh := make(chan error, 1)
+		func() {
+			conn, err := ln.Accept()
+			if err != nil {
+				errCh <- err
+				return
+			}
+			defer func() {
+				conn.Close()
+				log.Println("[TCP-S] close")
+			}()
+			log.Println("[TCP-S] accept client")
+
+			unixConn, _ := udsConn.(*net.UnixConn)
+			tcpConn, _ := conn.(*net.TCPConn)
+			file, _ := tcpConn.File()
+			err = sendFD(unixConn, int(file.Fd()))
+			if err != nil {
+				errCh <- err
+				return
+			}
+			log.Printf("[TCP-S] send fd=%d to uds-server", file.Fd())
+
+			errCh <- nil
+		}()
+
+		err = <-errCh
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func sendFD(sock *net.UnixConn, fd int) error {
+	var (
+		dummy  = make([]byte, 1)
+		rights = unix.UnixRights(fd)
+		err    error
+	)
+	_, _, err = sock.WriteMsgUnix(dummy, rights, nil)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

examples/socket/tcp_fd_passing/udsserver/main.go

@@ -0,0 +1,132 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+func main() {
+	log.SetFlags(log.Lmicroseconds)
+
+	if err := run(); err != nil {
+		panic(err)
+	}
+}
+
+func run() error {
+	ln, err := net.Listen("unix", "@tcp_fd_passing")
+	if err != nil {
+		return err
+	}
+	defer ln.Close()
+
+	log.Println("[UDS-S] server listening on")
+
+	udsConn, err := ln.Accept()
+	if err != nil {
+		return err
+	}
+	defer udsConn.Close()
+
+	log.Printf("[UDS-S] %v", udsConn.RemoteAddr())
+
+	unixConn, ok := udsConn.(*net.UnixConn)
+	if !ok {
+		return fmt.Errorf("not net.UnixConn")
+	}
+
+	fd, err := recvFD(unixConn)
+	if err != nil {
+		return err
+	}
+	log.Printf("[UDS-S] recv fd=%d", fd)
+
+	file := os.NewFile(uintptr(fd), "client-socket")
+	if file == nil {
+		return fmt.Errorf("os.NewFile() failed")
+	}
+	defer file.Close()
+
+	conn, err := net.FileConn(file)
+	if err != nil {
+		return fmt.Errorf("net.FileConn() failed")
+	}
+	defer func() {
+		conn.Close()
+		log.Println("[UDS-S] close")
+	}()
+
+	buf := []byte("hello")
+	_, err = conn.Write(buf)
+	if err != nil {
+		return err
+	}
+	log.Printf("[UDS-S] send (%s)", buf)
+
+	buf = make([]byte, 5)
+	n, err := conn.Read(buf)
+	if err != nil {
+		switch {
+		case errors.Is(err, io.EOF):
+			log.Println("[UDS-S] disconnect")
+		default:
+			return err
+		}
+	}
+	log.Printf("[UDS-S] recv (%s)", buf[:n])
+
+	tcpConn, _ := conn.(*net.TCPConn)
+	tcpConn.CloseWrite()
+	log.Println("[UDS-S] shutdown(SHUT_WR)")
+
+	return nil
+}
+
+func recvFD(sock *net.UnixConn) (int, error) {
+	var (
+		dummy = make([]byte, 1)
+		oob   = make([]byte, unix.CmsgSpace(4))
+		flags int
+		err   error
+	)
+	_, _, flags, _, err = sock.ReadMsgUnix(dummy, oob)
+	if err != nil {
+		return -1, err
+	}
+
+	if flags&unix.MSG_TRUNC != 0 {
+		return -1, fmt.Errorf("control message is truncated")
+	}
+
+	var (
+		msgs []unix.SocketControlMessage
+	)
+	msgs, err = unix.ParseSocketControlMessage(oob)
+	if err != nil {
+		return -1, err
+	}
+
+	if len(msgs) != 1 {
+		return -1, fmt.Errorf("want: 1 control message; got: %d", len(msgs))
+	}
+
+	var (
+		fds []int
+	)
+	fds, err = unix.ParseUnixRights(&msgs[0])
+	if err != nil {
+		return -1, err
+	}
+
+	if len(fds) != 1 {
+		return -1, fmt.Errorf("want: 1 fd; got: %d", len(fds))
+	}
+
+	return fds[0], nil
+}