0
0
//go:build linux
package apiserverfront
import (
"errors"
"fmt"
"net"
"os"
"strconv"
"strings"
"golang.org/x/sys/unix"
)
func ListenerFromFD(fd int) (net.Listener, error) {
unix.CloseOnExec(fd)
f := os.NewFile(uintptr(fd), FDName)
if f == nil {
return nil, fmt.Errorf("apiserverfront: fd %d is not open", fd)
}
defer f.Close()
ln, err := net.FileListener(f)
if err != nil {
return nil, fmt.Errorf("apiserverfront: the inherited fd %d is no listening socket: %w", fd, err)
}
if _, ok := ln.(*net.TCPListener); !ok {
ln.Close()
return nil, fmt.Errorf("apiserverfront: the inherited fd %d is not a TCP listener", fd)
}
return ln, nil
}
func HeldFromFD(fd int, name string) (*Held, error) {
unix.CloseOnExec(fd)
port, err := boundPort(fd)
if err != nil {
unix.Close(fd)
return nil, fmt.Errorf("apiserverfront: the inherited hold %q (fd %d): %w", name, fd, err)
}
return &Held{Name: name, Port: port, f: os.NewFile(uintptr(fd), HoldFDPrefix+name)}, nil
}
func boundPort(fd int) (int, error) {
sa, err := unix.Getsockname(fd)
if err != nil {
return 0, err
}
switch a := sa.(type) {
case *unix.SockaddrInet6:
return a.Port, nil
case *unix.SockaddrInet4:
return a.Port, nil
}
return 0, errors.New("not an inet socket")
}
func bindHold(name string, port int) (*Held, error) {
h, err := bindHoldOnce(name, port, false)
if err == nil || port == 0 || !errors.Is(err, unix.EADDRINUSE) || !onlyTimeWait(port) {
return h, err
}
return bindHoldOnce(name, port, true)
}
func onlyTimeWait(port int) bool {
waiting, other := 0, 0
for _, table := range []string{"/proc/net/tcp", "/proc/net/tcp6"} {
raw, err := os.ReadFile(table)
if err != nil {
continue
}
lines := strings.Split(string(raw), "\n")
for _, line := range lines[min(1, len(lines)):] {
f := strings.Fields(line)
if len(f) < 4 {
continue
}
i := strings.LastIndexByte(f[1], ':')
if i < 0 {
continue
}
local, err := strconv.ParseUint(f[1][i+1:], 16, 16)
if err != nil || int(local) != port {
continue
}
if f[3] == tcpTimeWait {
waiting++
} else {
other++
}
}
}
return waiting > 0 && other == 0
}
const tcpTimeWait = "06"
func bindHoldOnce(name string, port int, reuseFirst bool) (*Held, error) {
fd, err := unix.Socket(unix.AF_INET6, unix.SOCK_STREAM|unix.SOCK_CLOEXEC, 0)
var sa unix.Sockaddr = &unix.SockaddrInet6{Port: port}
if err == nil {
if err = unix.SetsockoptInt(fd, unix.IPPROTO_IPV6, unix.IPV6_V6ONLY, 0); err != nil {
unix.Close(fd)
return nil, fmt.Errorf("apiserverfront: hold %q: a dual-stack socket: %w", name, err)
}
} else {
if fd, err = unix.Socket(unix.AF_INET, unix.SOCK_STREAM|unix.SOCK_CLOEXEC, 0); err != nil {
return nil, fmt.Errorf("apiserverfront: hold %q: %w", name, err)
}
sa = &unix.SockaddrInet4{Port: port}
}
if reuseFirst {
if err := unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_REUSEADDR, 1); err != nil {
unix.Close(fd)
return nil, fmt.Errorf("apiserverfront: hold %q: SO_REUSEADDR before bind over TIME_WAIT: %w", name, err)
}
}
if err := unix.Bind(fd, sa); err != nil {
unix.Close(fd)
return nil, fmt.Errorf("apiserverfront: hold %q on port %d: %w", name, port, err)
}
if err := unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_REUSEADDR, 1); err != nil {
unix.Close(fd)
return nil, fmt.Errorf("apiserverfront: hold %q: SO_REUSEADDR after bind: %w", name, err)
}
got, err := boundPort(fd)
if err != nil {
unix.Close(fd)
return nil, fmt.Errorf("apiserverfront: hold %q: %w", name, err)
}
return &Held{Name: name, Port: got, f: os.NewFile(uintptr(fd), HoldFDPrefix+name)}, nil
}
func storeListener(sock string, ln net.Listener) error {
tl, ok := ln.(*net.TCPListener)
if !ok {
return errors.New("apiserverfront: only a TCP listener goes into the fd store")
}
raw, err := tl.SyscallConn()
if err != nil {
return err
}
var werr error
err = raw.Control(func(fd uintptr) { werr = storeFD(sock, int(fd), "FDNAME="+FDName) })
if err != nil {
return err
}
return werr
}
func storeHold(sock string, h *Held) error {
raw, err := h.f.SyscallConn()
if err != nil {
return err
}
var werr error
err = raw.Control(func(fd uintptr) { werr = storeFD(sock, int(fd), "FDNAME="+HoldFDPrefix+h.Name+"\nFDPOLL=0") })
if err != nil {
return err
}
return werr
}
func storeFD(sock string, fd int, fields string) error {
s, err := unix.Socket(unix.AF_UNIX, unix.SOCK_DGRAM|unix.SOCK_CLOEXEC, 0)
if err != nil {
return fmt.Errorf("apiserverfront: a socket for the fd store at %s: %w", sock, err)
}
defer unix.Close(s)
if err := unix.Sendmsg(s, []byte("FDSTORE=1\n"+fields), unix.UnixRights(fd), &unix.SockaddrUnix{Name: sock}, 0); err != nil {
return fmt.Errorf("apiserverfront: handing %q to the fd store at %s: %w", fields, sock, err)
}
return nil
}