static NbtAddress[] dc_list = null;
    static long dc_list_expiration;
    static int dc_list_counter;

    private static NtlmChallenge interrogate(final NbtAddress addr) throws SmbException {
        final UniAddress dc = new UniAddress(addr);
        final SmbTransport trans = SmbTransport.getSmbTransport(dc, 0);
        if (USERNAME == null) {
            trans.connect();
            if (LogStream.level >= 3) {

    public byte[] challenge;

    /**
     * Server address
     */
    public UniAddress dc;

    /**
     * Creates a new NTLM challenge with the specified parameters.
     * @param challenge the NTLM challenge bytes
     * @param dc the domain controller address
     */
    public NtlmChallenge(final byte[] challenge, final UniAddress dc) {
        this.challenge = challenge;
        this.dc = dc;
    }

    @Override

    //         */
    //
    //        UniAddress dc = UniAddress.getByName(domainName);
    //        SmbTransport trans = SmbTransport.getSmbTransport(dc, 0);
    //        DfsReferral[] dr = trans.getDfsReferrals(auth, "\\" + domainName, 1);
    //
    //        handle = DcerpcHandle.getHandle("ncacn_np:" +
    //                    UniAddress.getByName(dr[0].server).getHostAddress() +

        UniAddress dc;
        final boolean offerBasic = enableBasic && (insecureBasic || request.isSecure());
        final String msg = request.getHeader("Authorization");
        if (msg != null && (msg.startsWith("NTLM ") || offerBasic && msg.startsWith("Basic "))) {
            if (loadBalance) {
                dc = new UniAddress(NbtAddress.getByName(domainController, 0x1C, null));

            _domains = null;
        }
        if (_domains != null) {
            return _domains.map;
        }
        try {
            final UniAddress addr = UniAddress.getByName(auth.domain, true);
            final SmbTransport trans = SmbTransport.getSmbTransport(addr, 0);
            final CacheEntry entry = new CacheEntry(Dfs.TTL * 10L);

    /**
     * Authenticate arbitrary credentials represented by the
     * <code>NtlmPasswordAuthentication</code> object against the domain controller
     * specified by the <code>UniAddress</code> parameter. If the credentials are
     * not accepted, an <code>SmbAuthException</code> will be thrown. If an error
     * occurs an <code>SmbException</code> will be thrown. If the credentials are

import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;
import jcifs.smb1.Config;
import jcifs.smb1.UniAddress;
import jcifs.smb1.smb1.NtStatus;
import jcifs.smb1.smb1.NtlmChallenge;
import jcifs.smb1.smb1.NtlmPasswordAuthentication;
import jcifs.smb1.smb1.SmbAuthException;
import jcifs.smb1.smb1.SmbSession;

import jcifs.smb1.UniAddress;

/**
 * Very small test suite that exercises the most important state-changing
 * behaviour of {@link SmbSession}. The tests use Mockito to stub the
 * heavy network interactions through {@link SmbTransport}.
 */
@ExtendWith(MockitoExtension.class)
public class SmbSessionTest {

    @Mock
    UniAddress addr;
    @Mock
    InetAddress inet;

            }
        } else if (path.length() == 0 || path.equals("/")) {
            addresses = UniAddress.getAllByName(host, true);
        } else {
            addresses = UniAddress.getAllByName(host, false);
        }

        return getNextAddress();
    }

    UniAddress getNextAddress() {
        UniAddress addr = null;
        if (addressIndex < addresses.length) {
            addr = addresses[addressIndex++];

                        final byte[] ip = java.net.InetAddress.getByName(address).getAddress();
                        this.addresses = new UniAddress[1];
                        this.addresses[0] = new UniAddress(java.net.InetAddress.getByAddress(host, ip));
                    }
                } else if (host.length() == 0) {
                    try {