UniAddress[] addrs = new UniAddress[iaddrs.length];
        for ( int ii = 0; ii < iaddrs.length; ii++ ) {
            addrs[ ii ] = new UniAddress(iaddrs[ ii ]);
        }
        return addrs;
    }


    private static UniAddress[] wrapNetbiosAddresses ( NetbiosAddress[] addr ) {
        UniAddress[] addrs = new UniAddress[addr.length];

    }
     */


    Object addr;
    String calledName;

    /**
     * Create a <tt>UniAddress</tt> by wrapping an <tt>InetAddress</tt> or
     * <tt>NbtAddress</tt>.
     */

    public UniAddress( Object addr ) {
        if( addr == null ) {
            throw new IllegalArgumentException();
        }
        this.addr = addr;
    }

    /**

        Address[] addrs = tf.getNameServiceClient().getAllByName(name, true);

        if ( addrs == null || addrs.length == 0 ) {
            throw new UnknownHostException(name);
        }

        Arrays.sort(addrs, new Comparator<Address>() {

            @Override
            public int compare ( Address o1, Address o2 ) {

				t.Fatalf("Test %d: error: expected = <nil>, got = %v", i+1, err)
			}
		}

		addrs := listener.Addrs()
		addrSet := set.NewStringSet()
		for _, addr := range addrs {
			addrSet.Add(addr.String())
		}

		if !addrSet.Equals(testCase.expectedAddrs) {
			t.Fatalf("Test %d: addr: expected = %v, got = %v", i+1, testCase.expectedAddrs, addrs)
		}

		listener.Close()
	}

            NetbiosAddress[] addrs;

            try {
                addrs = tc.getNameServiceClient().getNodeStatus(this);
                if ( this.getNameType() == 0x1D ) {
                    for ( int i = 0; i < addrs.length; i++ ) {
                        if ( addrs[ i ].getNameType() == 0x20 ) {
                            return addrs[ i ].getHostName();
                        }

// we actually may have them before K8S in the Pod object.
func (s *NetServer) AddPodToMesh(ctx context.Context, pod *corev1.Pod, podIPs []netip.Addr, netNs string) error {
	log.Infof("in pod mode - adding pod %s/%s to ztunnel ", pod.Namespace, pod.Name)
	// make sure the cache is aware of the pod, even if we don't have the netns yet.
	s.currentPodSnapshot.Ensure(string(pod.UID))

            for( int i = 0; i < addrs.length; i++ ) {
                CacheEntry entry = (CacheEntry)ADDRESS_CACHE.get( addrs[i].hostName );
                if( entry == null ) {
                    entry = new CacheEntry( addrs[i].hostName, addrs[i], expiration );
                    ADDRESS_CACHE.put( addrs[i].hostName, entry );
                } else {
                    entry.address = addrs[i];

	}

	return ""
}

func retrieveListenerAdditionalAddresses(l *listener.Listener) []string {
	var addrs []string
	socketAddresses := l.GetAdditionalAddresses()
	for _, socketAddr := range socketAddresses {
		addr := socketAddr.Address
		addrs = append(addrs, addr.GetSocketAddress().Address)
	}

	return addrs
}

func retrieveListenerPort(l *listener.Listener) uint32 {

		haddrs, err := globalDNSCache.LookupHost(ctx, host)
		if err == nil {
			for _, addr := range haddrs {
				addrs.Add(net.JoinHostPort(addr, globalMinioPort))
			}
		} else {
			// Unable to lookup host in 2-secs, let it fail later anyways.
			addrs.Add(globalMinioAddr)
		}
	} else {
		addrs.Add(globalMinioAddr)
	}
	return addrs.ToSlice()
}

var globalLoggerOutput io.WriteCloser

func (cfg *IptablesConfigurator) CreateInpodRules(hostProbeSNAT *netip.Addr) error {
	// Append our rules here
	builder := cfg.appendInpodRules(hostProbeSNAT)

	if err := cfg.addLoopbackRoute(); err != nil {
		return err
	}

	if err := cfg.addInpodMarkIPRule(); err != nil {
		return err
	}

	log.Debug("Adding iptables rules")
	if err := cfg.executeCommands(builder); err != nil {