# See the OWNERS docs at https://go.k8s.io/owners

reviewers:
  - sig-network-reviewers
  - andrewsykim
  - aroradaman
  - uablrek
approvers:
  - sig-network-approvers
  - andrewsykim
  - uablrek
labels:
  - sig/network
  - area/ipvs
emeritus_approvers:
  - brendandburns
  - lbernail

              "filter_chains": [
                {
                  "filters": [
                    {
                      "name": "envoy.filters.network.http_connection_manager",
                      "typed_config": {
                        "@type": "type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager",
                        "stat_prefix": "connect_terminate",
                        "route_config": {

					if network == "ip4" || network == "ip" && v4Ok {
						if len(v4Addrs) == 0 {
							t.Errorf("DefaultResolver.LookupIP(%q, %q): no IPv4 addresses", network, host)
						}
					}
					if network == "ip6" || network == "ip" && v6Ok {
						if len(v6Addrs) == 0 {
							t.Errorf("DefaultResolver.LookupIP(%q, %q): no IPv6 addresses", network, host)
						}
					}

var (
	errInvalidInterface         = errors.New("invalid network interface")
	errInvalidInterfaceIndex    = errors.New("invalid network interface index")
	errInvalidInterfaceName     = errors.New("invalid network interface name")
	errNoSuchInterface          = errors.New("no such network interface")
	errNoSuchMulticastInterface = errors.New("no such multicast network interface")
)

	// 1. namespace/hostname format
	s := a.services.GetKey(krt.Key[model.ServiceInfo](key))
	if s != nil {
		return s
	}

	// 2. network/ip format
	network, ip, _ := strings.Cut(key, "/")
	services := a.services.ByAddress.Lookup(networkAddress{
		network: network,
		ip:      ip,
	})
	return slices.First(services)
}

// All return all known workloads. Result is un-ordered

          filter:
            name: envoy.filters.network.http_connection_manager
            subFilter:
              name: envoy.filters.http.router
      proxy:
        proxyVersion: ^1\.19.*
  - applyTo: HTTP_FILTER
    match:
      context: SIDECAR_INBOUND
      listener:
        filterChain:
          filter:
            name: envoy.filters.network.http_connection_manager
            subFilter:

			}
			_, present := network[nodeName]
			if !present {
				if err := isServerResolvable(endpoint, 5*time.Second); err == nil {
					network[nodeName] = string(madmin.ItemOnline)
				} else {
					if xnet.IsNetworkOrHostDown(err, false) {
						network[nodeName] = string(madmin.ItemOffline)
					} else if xnet.IsNetworkOrHostDown(err, true) {
						network[nodeName] = "connection attempt timedout"
					}
				}
			}
		}
	}

		for i, network := range []string{"tcp", "tcp4", "tcp6", "unix", "unixpacket"} {
			t.Run(network, func(t *testing.T) {
				if !testableNetwork(network) {
					t.Skipf("skipping: %s not available", network)
				}

				ln := newLocalListener(t, network)
				defer ln.Close()
				var id int

// use [Dialer.DialContext] with NetDialer set to the desired dialer.
func DialWithDialer(dialer *net.Dialer, network, addr string, config *Config) (*Conn, error) {
	return dial(context.Background(), dialer, network, addr, config)
}

func dial(ctx context.Context, netDialer *net.Dialer, network, addr string, config *Config) (*Conn, error) {
	if netDialer.Timeout != 0 {
		var cancel context.CancelFunc

network namespace processes always take the output path, while packets coming in from
outside the host network namespace (whether that's from an external host or from a pod
network namespace) arrive via `ingress` and take the input or forward path, depending on
the routing decision made after `prerouting`; packets destined for an IP which is assigned