_dst.enc_ndr_short(this.domain_guid.time_hi_and_version);
            _dst.enc_ndr_small(this.domain_guid.clock_seq_hi_and_reserved);
            _dst.enc_ndr_small(this.domain_guid.clock_seq_low);
            int _domain_guid_nodes = 6;
            int _domain_guid_nodei = _dst.index;
            _dst.advance(1 * _domain_guid_nodes);
            _dst.enc_ndr_referent(this.sid, 1);

/**
 * A descriptor for a <i>discrete</i> {@code Comparable} domain such as all {@link Integer}
 * instances. A discrete domain is one that supports the three basic operations: {@link #next},
 * {@link #previous} and {@link #distance}, according to their specifications. The methods {@link
 * #minValue} and {@link #maxValue} should also be overridden for bounded types.
 *

        if( DOMAIN == null ) {
            throw new SmbException( "A domain was not specified" );
        }
synchronized (DOMAIN) {
            long now = System.currentTimeMillis();
            int retry = 1;

            do {
                if (dc_list_expiration < now) {
                    NbtAddress[] list = NbtAddress.getAllByName( DOMAIN, 0x1C, null, null );

            }
        }

        return ntlm;
    }


    private synchronized NtlmChallenge getChallengeForDomain ( String domain ) throws UnknownHostException, ServletException {
        if ( domain == null ) {
            throw new ServletException("A domain was not specified");
        }
        long now = System.currentTimeMillis();
        int retry = 1;

        do {

        return doResolve(link, relative, domain, false);
    }


    /**
     * @return
     * @throws URISyntaxException
     * @throws CIFSException
     */
    private DfsReferralData doResolve ( String link, String relative, boolean domain, boolean upper ) throws URISyntaxException, CIFSException {

        DEFAULT_DOMAIN = domain;
    }

    public NtlmHttpURLConnection(HttpURLConnection connection) {
        super(connection.getURL());
        this.connection = connection;
        requestProperties = new HashMap();
    }

    public void connect() throws IOException {
        if (connected) return;
        connection.connect();
        connected = true;
    }

/**
 * A descriptor for a <i>discrete</i> {@code Comparable} domain such as all {@link Integer}
 * instances. A discrete domain is one that supports the three basic operations: {@link #next},
 * {@link #previous} and {@link #distance}, according to their specifications. The methods {@link
 * #minValue} and {@link #maxValue} should also be overridden for bounded types.
 *

     *            The hostname of the server that should be queried. For maximum efficiency this should be the hostname
     *            of a domain controller however a member server will work as well and a domain controller may not
     *            return names for SIDs corresponding to local accounts for which the domain controller is not an
     *            authority.
     * @param tc

     * @see jcifs.DfsReferralData#getDomain()
     */
    @Override
    public String getDomain () {
        return this.domain;
    }


    /**
     * @param domain
     *            the domain to set
     */
    public void setDomain ( String domain ) {
        this.domain = domain;
    }


    @Override
    public String getLink () {
        return this.link;
    }

        public rpc.policy_handle domain_handle;

        public SamrOpenDomain(rpc.policy_handle handle,
                    int access_mask,
                    rpc.sid_t sid,
                    rpc.policy_handle domain_handle) {
            this.handle = handle;
            this.access_mask = access_mask;
            this.sid = sid;
            this.domain_handle = domain_handle;
        }