*/
    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 );

    private CacheEntry<Map<String, CacheEntry<DfsReferralDataInternal>>> _domains = null; /*
                                                                                           * aka trusted domains cache
                                                                                           */
    private final Object domainsLock = new Object();

    /**
     * @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

    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 final int SHARING_DENY_WRITE = 0x20;
    static final int SHARING_DENY_READ_EXECUTE = 0x30;
    static final int SHARING_DENY_NONE = 0x40;

    static final int DO_NOT_CACHE = 0x1000; // bit 12
    static final int WRITE_THROUGH = 0x4000; // bit 14

    static final int OPEN_FN_CREATE = 0x10;
    static final int OPEN_FN_FAIL_IF_EXISTS = 0x00;
    static final int OPEN_FN_OPEN = 0x01;

    protected static CacheEntry FALSE_ENTRY = new Dfs.CacheEntry(0L);

    protected CacheEntry _domains = null; /* aka trusted domains cache */
    protected CacheEntry referrals = null;

    public HashMap getTrustedDomains(NtlmPasswordAuthentication auth) throws SmbAuthException {
        if (DISABLED || auth.domain == "?")
            return null;

        }

        /*
         * Create an NbtAddress for the local interface with
         * the name deduced above possibly with scope applied and
         * cache it forever.
         */
        Name localName = new Name(tc.getConfig(), localHostname, 0x00, tc.getConfig().getNetbiosScope());
        this.localhostAddress = new NbtAddress(
            localName,

 * augment the addresses name's hashCode to distinguish those resolved by
 * Lmhosts, WINS, or BCAST. Otherwise a failed query from say WINS would
 * get pulled out of the cache for a BCAST on the same name.
 */
                                response.addrEntry[0].hostName.srcHashCode =
                                                        request.addr.hashCode();