// support this approach for UDP sockets. Instead, we test the internals that
// make it possible for WASI host runtimes and guest programs to integrate
// socket extensions with the net package using net.FileConn/net.FileListener.
//
// Note that the creation of net.Conn and net.Listener values for TCP sockets
// has an end-to-end test in src/runtime/internal/wasitest, here we are only
// verifying the code paths specific to UDP, and error handling for invalid use

//
// The packages golang.org/x/net/ipv4 and golang.org/x/net/ipv6 can be
// used to manipulate IP-level socket options in oob.
func (c *IPConn) ReadMsgIP(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error) {
	if !c.ok() {
		return 0, 0, 0, nil, syscall.EINVAL
	}
	n, oobn, flags, addr, err = c.readMsg(b, oob)
	if err != nil {
		err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}

#include <sys/termios.h>
#include <sys/ttycom.h>
#include <sys/wait.h>
#include <net/bpf.h>
#include <net/if.h>
#include <net/if_types.h>
#include <net/if_var.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_mroute.h>
#include <netinet/if_ether.h>
#include <net/if_bridge.h>

// We keep some constants not supported in OpenBSD 5.5 and beyond for

// that module is lower under Go 1.17 semantics than under Go 1.16.
module example.com/m

go 1.17

replace (
	example.net/lazy v0.1.0 => ./lazy
	example.net/requireincompatible v0.1.0 => ./requireincompatible
)

require (
	example.com/retract/incompatible v1.0.0 // indirect
	example.net/lazy v0.1.0
)
-- lazy/go.mod --
// Module lazy requires example.com/retract/incompatible v1.0.0.
//

  @Test fun overflowMaxCodePoint() {
    assertNull(Punycode.decode("xn--a-b.net"))
    assertNull(Punycode.decode("xn--a-9b.net"))
    assertEquals("a՚.net", Punycode.decode("xn--a-99b.net"))
    assertEquals("a溠.net", Punycode.decode("xn--a-999b.net"))
    assertEquals("a\uD8E2\uDF5C.net", Punycode.decode("xn--a-9999b.net"))
    assertNull(Punycode.decode("xn--a-99999b.net"))
  }

  @Test fun dashInPrefix() {
    testEncodeDecode(

# even when it's been moved to a different directory.
# Simulate that by creating a symlink to the tree.

# We use net instead of std because stale std has
# the behavior of checking that all std targets
# are stale rather than any of them.

[!symlink] skip
[short] skip

go build net
! stale net

symlink new -> $GOROOT
env OLDGOROOT=$GOROOT
env GOROOT=$WORK${/}gopath${/}src${/}new
go env GOROOT

import (
	"errors"
	"fmt"
	"net"

	api "k8s.io/kubernetes/pkg/apis/core"
)

// Interface manages the allocation of IP addresses out of a range. Interface
// should be threadsafe.
type Interface interface {
	Allocate(net.IP) error
	AllocateNext() (net.IP, error)
	Release(net.IP) error
	ForEach(func(net.IP))
	CIDR() net.IPNet
	IPFamily() api.IPFamily
	Has(ip net.IP) bool
	Destroy()
	EnableMetrics()

 */
package okhttp3.internal.platform

import java.security.KeyStore
import java.security.Provider
import javax.net.ssl.SSLContext
import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.TrustManagerFactory
import javax.net.ssl.X509TrustManager
import okhttp3.Protocol

/**
 * Platform using OpenJSSE (https://github.com/openjsse/openjsse) if installed as the first

	defer func() { crashy = false }()

	const N = 10
	const M = 100
	net := "unix"
	if !testableNetwork(net) {
		net = "tcp"
		if !testableNetwork(net) {
			t.Skipf("skipping on %s/%s; neither 'unix' or 'tcp' is supported", runtime.GOOS, runtime.GOARCH)
		}
	}
	done := make(chan string, N*M)
	addr, sock, srvWG := startServer(t, net, "", done)
	if net == "unix" {
		defer os.Remove(addr)
	}

	switch fd.net {
	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)
	}
}