- lbEndpoints:
    - endpoint:
        address:
          socketAddress:
            address: 10.244.0.8
            portValue: 53
        healthCheckConfig: {}
      healthStatus: HEALTHY
      loadBalancingWeight: 1
      metadata:
        filterMetadata:
          istio:
            workload: coredns;kube-system;;;Kubernetes
    - endpoint:
        address:
          socketAddress:

                                    {
                                        "endpoint": {
                                            "address": {
                                                "socket_address": {
                                                    "address": "127.0.0.1",
                                                    "port_value": 15020
                                                }

			inFilter: &ListenerFilter{
				Address: "0.0.0.0",
			},
			inListener: &listener.Listener{
				Address: &core.Address{
					Address: &core.Address_SocketAddress{
						SocketAddress: &core.SocketAddress{Address: "1.1.1.1"},
					},
				},
				AdditionalAddresses: []*listener.AdditionalAddress{
					{
						Address: &core.Address{
							Address: &core.Address_SocketAddress{

    @Override
    public SmbTransportImpl getSmbTransport ( CIFSContext tc, Address address, int port, boolean nonPooled ) {
        return getSmbTransport(tc, address, port, tc.getConfig().getLocalAddr(), tc.getConfig().getLocalPort(), null, nonPooled);
    }


    @Override
    public SmbTransportImpl getSmbTransport ( CIFSContext tc, Address address, int port, boolean nonPooled, boolean forceSigning ) {

			expected: "example.com",
		},
		{
			desc:     "test domains with ipv4 addresses",
			domains:  []string{"example.com", "example.com:8080", "1.2.3.4", "1.2.3.4:8080"},
			expected: "example.com, 1.2.3.4",
		},
		{
			desc:     "test domains with ipv6 addresses",
			domains:  []string{"example.com", "example.com:8080", "[fd00:10:96::7fc7]", "[fd00:10:96::7fc7]:8080"},

##
service:
  type: ClusterIP
  clusterIP: ~
  port: "9000"
  nodePort: 32000
  loadBalancerIP: ~
  externalIPs: []
  annotations: {}

  ## service.loadBalancerSourceRanges Addresses that are allowed when service is LoadBalancer
  ## https://kubernetes.io/docs/tasks/access-application-cluster/configure-cloud-provider-firewall/#restrict-access-for-loadbalancer-service
  ##
  #loadBalancerSourceRanges:

	w := c.tabwriter()
	d := c.ztunnelDump
	serviceNames := map[string]string{}
	workloadNames := map[string]string{}
	for _, s := range d.Services {
		var ip string
		if len(s.Addresses) != 0 {
			_, ip, _ = strings.Cut(s.Addresses[0], "/")
		}
		if ip == "" {
			// fallback to None when a service does not have a VIP
			ip = "None"
		}
		serviceNames[ip] = s.Hostname
	}
	for _, s := range d.Workloads {

     * 
     * @param tc
     *            context to use
     * @param address
     * @param port
     * @param exclusive
     *            whether to acquire an unshared connection
     * @return a transport connection to the target
     */
    SmbTransport getSmbTransport ( CIFSContext tc, Address address, int port, boolean exclusive );


    /**
     * Get transport connection
     * 

      proxySelector = proxySelector,
    )
  }

  fun newRoute(
    address: Address = newAddress(),
    proxy: Proxy = this.proxy,
    socketAddress: InetSocketAddress = InetSocketAddress.createUnresolved(uriHost, uriPort),
  ): Route {
    return Route(
      address = address,
      proxy = proxy,
      socketAddress = socketAddress,
    )
  }

	}
	c.clusters = &cd
	return nil
}

func retrieveEndpointAddress(host *admin.HostStatus) string {
	addr := host.Address.GetSocketAddress()
	if addr != nil {
		return addr.Address
	}
	if pipe := host.Address.GetPipe(); pipe != nil {
		return "unix://" + pipe.Path
	}
	if internal := host.Address.GetEnvoyInternalAddress(); internal != nil {
		switch an := internal.GetAddressNameSpecifier().(type) {