}
	return
}

// FilePacketConn returns a copy of the packet network connection
// corresponding to the open file f.
// It is the caller's responsibility to close f when finished.
// Closing c does not affect f, and closing f does not affect c.
func FilePacketConn(f *os.File) (c PacketConn, err error) {
	c, err = filePacketConn(f)
	if err != nil {

	// TODO: Implement this
	return nil, syscall.EWINDOWS
}

func fileListener(f *os.File) (Listener, error) {
	// TODO: Implement this
	return nil, syscall.EWINDOWS
}

func filePacketConn(f *os.File) (PacketConn, error) {
	// TODO: Implement this
	return nil, syscall.EWINDOWS

import (
	"os"
	"syscall"
)

func fileConn(f *os.File) (Conn, error)             { return nil, syscall.ENOPROTOOPT }
func fileListener(f *os.File) (Listener, error)     { return nil, syscall.ENOPROTOOPT }

				t.Error(perr)
			}
			t.Fatal(err)
		}

		c2, err := FilePacketConn(f)
		if err := f.Close(); err != nil {
			t.Error(err)
		}
		if err != nil {
			if perr := parseCommonError(err); perr != nil {
				t.Error(perr)
			}
			t.Fatal(err)
		}
		defer c2.Close()

		if _, err := c2.WriteTo([]byte("FILEPACKETCONN TEST"), addr); err != nil {
			if perr := parseWriteError(err); perr != nil {

		return nil, err
	}
	pfd := f.PollFD().Copy()
	fd := newPollFD(net, pfd)
	if err := fd.init(); err != nil {
		pfd.Close()
		return nil, err
	}
	return newFileConn(fd), nil
}

func filePacketConn(f *os.File) (PacketConn, error) {
	return nil, syscall.ENOPROTOOPT
}

func fileListenNet(filetype syscall.Filetype) (string, error) {
	switch filetype {
	case syscall.FILETYPE_SOCKET_STREAM:
		return "tcp", nil

	case *TCPAddr:
		return &TCPListener{fd: fd}, nil
	case *UnixAddr:
		return &UnixListener{fd: fd, path: laddr.Name, unlink: false}, nil
	}
	fd.Close()
	return nil, syscall.EINVAL
}

func filePacketConn(f *os.File) (PacketConn, error) {
	fd, err := newFileFD(f)
	if err != nil {
		return nil, err
	}
	switch fd.laddr.(type) {
	case *UDPAddr:
		return newUDPConn(fd), nil
	case *IPAddr:

	if err != nil {
		return nil, err
	}
	if s != "Listen" {
		return nil, errors.New("file does not represent a listener")
	}

	return &TCPListener{fd: fd}, nil
}

func filePacketConn(f *os.File) (PacketConn, error) {
	return nil, syscall.EPLAN9

		}
		if perr := parseCommonError(err); perr != nil {
			t.Error(perr)
		}
	} else {
		ln.Close()
		t.Error("should fail")
	}
	pc, err := FilePacketConn(f)
	if err != nil {
		if pc != nil {
			t.Errorf("FilePacketConn returned non-nil interface %T(%v) with err != nil", pc, pc)
		}
		if perr := parseCommonError(err); perr != nil {
			t.Error(perr)
		}
	} else {
		pc.Close()

		{"Dialer.Timeout", Field, 1},
		{"ErrClosed", Var, 16},
		{"ErrWriteToConnected", Var, 0},
		{"Error", Type, 0},
		{"FileConn", Func, 0},
		{"FileListener", Func, 0},
		{"FilePacketConn", Func, 0},
		{"FlagBroadcast", Const, 0},
		{"FlagLoopback", Const, 0},
		{"FlagMulticast", Const, 0},
		{"FlagPointToPoint", Const, 0},
		{"FlagRunning", Const, 20},
		{"FlagUp", Const, 0},

pkg net, func DialUnix(string, *UnixAddr, *UnixAddr) (*UnixConn, error)
pkg net, func FileConn(*os.File) (Conn, error)
pkg net, func FileListener(*os.File) (Listener, error)
pkg net, func FilePacketConn(*os.File) (PacketConn, error)
pkg net, func IPv4(uint8, uint8, uint8, uint8) IP
pkg net, func IPv4Mask(uint8, uint8, uint8, uint8) IPMask
pkg net, func InterfaceAddrs() ([]Addr, error)