if err != nil {
			if perr := parseDialError(err); perr != nil {
				t.Error(perr)
			}
			t.Fatal(err)
		}
		addr := c1.LocalAddr()

		var f *os.File
		switch c1 := c1.(type) {
		case *TCPConn:
			f, err = c1.File()
		case *UDPConn:
			f, err = c1.File()
		case *UnixConn:
			f, err = c1.File()
		}
		if err := c1.Close(); err != nil {
			if perr := parseCloseError(err, false); perr != nil {

	case "tcp":
		return &TCPListener{fd: fd}
	default:
		panic("unsupported network for file listener: " + fd.net)
	}
}

func newFileConn(fd *netFD) Conn {
	switch fd.net {
	case "tcp":
		return &TCPConn{conn{fd: fd}}
	case "udp":
		return &UDPConn{conn{fd: fd}}
	default:
		panic("unsupported network for file connection: " + fd.net)
	}
}

// This helper is implemented in the syscall package. It means we don't have

//go:build !illumos

package net

import (
	"internal/syscall/unix"
	"syscall"
)

// SetKeepAliveConfig configures keep-alive messages sent by the operating system.
func (c *TCPConn) SetKeepAliveConfig(config KeepAliveConfig) error {
	if !c.ok() {
		return syscall.EINVAL
	}

	if err := setKeepAlive(c.fd, config.Enable); err != nil {

	defer c.Close()

	var buf [128]byte
	n, err := c.Read(buf[:])
	if err != nil {
		return err
	}
	if _, err := c.Write(buf[:n]); err != nil {
		return err
	}
	if err := c.(*net.TCPConn).CloseWrite(); err != nil {
		return err
	}
	return c.Close()
}

func findListener() (net.Listener, error) {
	// We start looking for pre-opened sockets at fd=3 because 0, 1, and 2

// tcpConnWithoutReadFrom implements all the methods of *TCPConn other
// than ReadFrom. This is used to permit ReadFrom to call io.Copy
// without leading to a recursive call to ReadFrom.
type tcpConnWithoutReadFrom struct {
	noReadFrom
	*TCPConn
}

// Fallback implementation of io.ReaderFrom's ReadFrom, when sendfile isn't
// applicable.
func genericReadFrom(c *TCPConn, r io.Reader) (n int64, err error) {

// Recover the original address from redirect socket. Supposed to work for tcp over ipv4 and ipv6.
func GetOriginalDestination(conn net.Conn) (daddr net.IP, dport uint16, err error) {
	// obtain os fd from Conn
	tcp, ok := conn.(*net.TCPConn)
	if !ok {
		err = errors.New("socket is not tcp")
		return
	}
	file, err := tcp.File()
	if err != nil {
		return
	}
	defer file.Close()
	fd := file.Fd()

	// Detect underlying ip is v4 or v6

	// nolint: staticcheck
	defer bufferPoolCopy.Put(buf1)
	bufCap := cap(buf1)
	buf := buf1[0:bufCap:bufCap]

	// For netstack: src is a gonet.Conn, doesn't implement WriterTo. Dst is a net.TcpConn - and implements ReadFrom.
	// CopyBuffered is the actual implementation of Copy and CopyBuffer.
	// if buf is nil, one is allocated.
	// Duplicated from io

	// This will prevent stats from working.

func forceClose(conn net.Conn) error {
	// Close may be called more than once.
	defer func() { _ = conn.Close() }()

	// Force the connection closed (should result in sending RST)
	return conn.(*net.TCPConn).SetLinger(0)

		t.Errorf("newFileListener: tcp listener type mismatch: %T", l)
	} else {
		testIsTCPAddr(t, "Addr", l.Addr())
	}
}

func TestWasip1NewFileConn(t *testing.T) {
	if c, ok := newFileConn(newFD("tcp", -1)).(*TCPConn); !ok {
		t.Errorf("newFileConn: tcp conn type mismatch: %T", c)
	} else {
		testIsTCPAddr(t, "LocalAddr", c.LocalAddr())
		testIsTCPAddr(t, "RemoteAddr", c.RemoteAddr())
	}

	major, minor := unix.KernelVersion()
	// SOL_MPTCP only supported from kernel 5.16
	hasSOLMPTCP = major > 5 || (major == 5 && minor >= 16)
}

func (sd *sysDialer) dialMPTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error) {
	if supportsMultipathTCP() {
		if conn, err := sd.doDialTCPProto(ctx, laddr, raddr, _IPPROTO_MPTCP); err == nil {
			return conn, nil
		}
	}