svcListenAddress = constants.UnspecifiedIPv6
		}

		if len(destinationCIDR) > 0 || len(svcListenAddress) == 0 || (svcListenAddress == actualWildcard && bind == actualWildcard) {
			sniHosts = []string{string(service.Hostname)}
			for _, a := range service.Attributes.Aliases {
				alt := GenerateAltVirtualHosts(a.Hostname.String(), 0, node.DNSDomain)

		},
	}
}

func (lb *ListenerBuilder) buildConnectTerminateListener(routes []*route.Route) *listener.Listener {
	actualWildcard, _ := getActualWildcardAndLocalHost(lb.node)
	l := &listener.Listener{
		Name:    ConnectTerminate,
		Address: util.BuildAddress(actualWildcard, model.HBoneInboundListenPort),
		FilterChains: []*listener.FilterChain{
			{
				Name: "default",
				TransportSocket: &core.TransportSocket{

	opts outboundListenerOpts,
	actualWildcard string,
	listenerProtocol istionetworking.ListenerProtocol,
) []*filterChainOpts {
	var rdsName string
	if opts.port.Port == 0 {
		rdsName = opts.bind.Primary() // use the UDS as a rds name
	} else {
		if listenerProtocol == istionetworking.ListenerProtocolAuto && opts.bind.Primary() != actualWildcard && opts.service != nil {

				hbone:       lb.node.IsWaypointProxy(),
			}
			if cc.bind == "" {
				// If user didn't provide, pick one based on IP
				actualWildcards := getSidecarInboundBindIPs(lb.node)
				cc.bind = actualWildcards[0]
				if len(actualWildcards) > 1 {
					cc.extraBind = actualWildcards[1:]
				}
			}
			// for inbound only generate a standalone listener when bindToPort=true

	actualWildcards, _ := getWildcardsAndLocalHost(lb.node.GetIPMode())
	// add an extra listener that binds to the port that is the recipient of the iptables redirect
	ipTablesListener := &listener.Listener{
		Name:             model.VirtualOutboundListenerName,
		Address:          util.BuildAddress(actualWildcards[0], uint32(lb.push.Mesh.ProxyListenPort)),

				port.Number, builder.node.ID)
			continue
		}
		var extraBind []string
		bind := actualWildcards[0]
		if features.EnableDualStack && len(actualWildcards) > 1 {
			extraBind = actualWildcards[1:]
		}
		if len(port.Bind) > 0 {
			bind = port.Bind
			extraBind = nil
		}

		},
	}
	for _, tt := range tests {
		tt.proxy.DiscoverIPMode()
		actualWildcards, _ := getWildcardsAndLocalHost(tt.proxy.GetIPMode())
		if len(actualWildcards) != len(tt.expected) {
			t.Errorf("Test %s failed, expected: %v got: %v", tt.name, tt.expected, actualWildcards)
		}
	}
}

func TestGetDualStackLocalHost(t *testing.T) {
	tests := []struct {
		name     string