}
	}
}

func (p *dnsProxy) Address() string {
	if p.server != nil {
		if p.server.Listener != nil {
			return p.server.Listener.Addr().String()
		}
		if p.server.PacketConn != nil {
			return p.server.PacketConn.LocalAddr().String()
		}
	}
	return ""
}

func (p *dnsProxy) ServeDNS(w dns.ResponseWriter, req *dns.Msg) {
	p.resolver.ServeDNS(p, w, req)

	pcmu sync.RWMutex
	PacketConn
	done chan bool // signal that indicates server stopped
}

func (ls *localPacketServer) buildup(handler func(*localPacketServer, PacketConn)) error {
	go func() {
		handler(ls, ls.PacketConn)
		close(ls.done)
	}()
	return nil
}

func (ls *localPacketServer) teardown() error {
	ls.pcmu.Lock()
	if ls.PacketConn != nil {

type T1 struct {
	T2
	T3
	T4
}

type T2 struct {
	Conn
}

type T3 struct {
	PacketConn
}

type T4 struct {
	PacketConn
	T5
}

type T5 struct {
	x int
	T6
}

type T6 struct {
	y, z int
}

type Conn interface {
	A()
}

type PacketConn interface {
	B()
}

func F(a, b T1) bool {
	return a == b

		return nil, func() { t.Logf("skipping %s test", network) }
	}
	return []byte("PACKETCONN TEST"), nil
}

func TestPacketConn(t *testing.T) {
	var packetConnTests = []struct {
		net   string
		addr1 string
		addr2 string
	}{
		{"udp", "127.0.0.1:0", "127.0.0.1:0"},
		{"unixgram", testUnixAddr(t), testUnixAddr(t)},
	}

	closer := func(c PacketConn, net, addr1, addr2 string) {
		c.Close()
		switch net {
		case "unixgram":

				t.Fatal(err)
			}

			ls := (&packetListener{PacketConn: c1}).newLocalServer()
			defer ls.teardown()
			tpch := make(chan error, 1)
			handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, tpch) }
			if err := ls.buildup(handler); err != nil {
				t.Fatal(err)
			}

			trch := make(chan error, 1)
			_, port, err := SplitHostPort(ls.PacketConn.LocalAddr().String())
			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

	"syscall"
)

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

	failingDNSServer.setFailure(true)
	model.NetworkGatewayTestDNSServers = []string{
		// try resolving with the failing server first to make sure the next upstream is retried
		failingDNSServer.Server.PacketConn.LocalAddr().String(),
		workingDNSServer.Server.PacketConn.LocalAddr().String(),
	}
	t.Cleanup(func() {
		errW := workingDNSServer.Shutdown()
		errF := failingDNSServer.Shutdown()
		if errW != nil || errF != nil {

var _ Instance = &udpInstance{}

type udpInstance struct {
	Config
	l net.PacketConn
}

func newUDP(config Config) Instance {
	return &udpInstance{
		Config: config,
	}
}

func (s *udpInstance) GetConfig() Config {
	return s.Config
}

func (s *udpInstance) Start(onReady OnReadyFunc) error {
	var listener net.PacketConn
	var port int
	var err error
	if s.Port.TLS {

	if err != nil {
		return nil, err
	}
	return addrs.forResolve(network, address).(*IPAddr), nil
}

// IPConn is the implementation of the [Conn] and [PacketConn] interfaces
// for IP network connections.
type IPConn struct {
	conn
}

// SyscallConn returns a raw network connection.
// This implements the [syscall.Conn] interface.