*/
    DfsReferralData resolve ( CIFSContext tf, String domain, String root, String path ) throws CIFSException;


    /**
     * Add a referral to the cache
     * 
     * @param path
     * @param dr
     * @param tc
     */
    void cache ( CIFSContext tc, String path, DfsReferralData dr );

    /**
     * @return cache key
     */
    String getKey ();


    /**
     * 
     * @param key
     *            cache key
     */
    void setKey ( String key );


    /**
     * @param map
     */
    void setCacheMap ( Map<String, DfsReferralDataInternal> map );


    /**
     * Replaces the entry with key in the cache map with this referral
     */

                sid_cache.put(sids[si], sids[si]);
            }
        }
}
    }
    /**
     * Resolve an array of SIDs using a cache and at most one MSRPC request.
     * <p>
     * This method will attempt
     * to resolve SIDs using a cache and cache the results of any SIDs that
     * required resolving with the authority. SID cache entries are currently not

            log.trace("Have DC referral " + dr);
        }

        if ( dr != null && domain.equals(dr.getServer()) && root.equals(dr.getShare()) ) {
            // If we do cache these we never get to the properly cached
            // standalone referral we might have.
            log.warn("Dropping self-referential referral " + dr);
            dr = null;
        }
        return dr;
    }

    int getNetbiosRetryCount ();


    /**
     * 
     * 
     * Property <tt>jcifs.netbios.cachePolicy</tt> in minutes (int, default 600)
     * 
     * @return netbios cache timeout, in seconds, 0 - disable caching, -1 - cache forever
     */
    int getNetbiosCachePolicy ();


    /**
     * 
     * @return the maximum size of IO buffers, limits the maximum message size
     */

     * The operating system detects a change in file size only when the file is written to the disk. For operating
     * systems that use extensive caching, detection occurs only when the cache is sufficiently flushed.s
     */
    public static final int FILE_NOTIFY_CHANGE_SIZE = 0x00000008;

    /**

    static Object[] cache = new Object[MAX_BUFFERS];
    private static int freeBuffers = 0;

    static public byte[] getBuffer() {
        synchronized( cache ) {
            byte[] buf;

            if (freeBuffers > 0) {
                for (int i = 0; i < MAX_BUFFERS; i++) {
                    if( cache[i] != null ) {
                        buf = (byte[])cache[i];
                        cache[i] = null;

    private static final Map<String, byte[]> TARGET_INFO_CACHE = new HashMap<>();


    private static byte[] getDefaultTargetInfo ( CIFSContext tc ) {
        String domain = tc.getConfig().getDefaultDomain();
        byte[] ti = TARGET_INFO_CACHE.get(domain);
        if ( ti != null ) {
            return ti;
        }

        ti = makeTargetInfo(tc, domain);
        TARGET_INFO_CACHE.put(domain, ti);
        return ti;
    }

        Arrays.fill(buf, (byte) 0);
        synchronized ( this.cache ) {
            if ( this.freeBuffers < this.cache.length ) {
                for ( int i = 0; i < this.cache.length; i++ ) {
                    if ( this.cache[ i ] == null ) {
                        this.cache[ i ] = buf;
                        this.freeBuffers++;
                        return;
                    }

 * @internal
 */
public interface SidResolver {

    /**
     * Resolve an array of SIDs using a cache and at most one MSRPC request.
     * <p>
     * This method will attempt
     * to resolve SIDs using a cache and cache the results of any SIDs that
     * required resolving with the authority. SID cache entries are currently not
     * expired because under normal circumstances SID information never changes.
     *