* is global therefore property names should be unique. Before use,
 * the <code>load</code> method should be called with the name of a
 * <code>Properties</code> file (or <code>null</code> indicating no
 * file) to initialize the <code>Config</code>. The <code>System</code>
 * properties will then populate the <code>Config</code> as well potentially
 * overwriting properties from the file. Thus properties provided on the

    static final long TTL = Config.getLong("jcifs.smb1.smb.client.dfs.ttl", 300);
    static final boolean DISABLED = Config.getBoolean("jcifs.smb1.smb.client.dfs.disabled", false);

    /**
     * Sentinel cache entry indicating a negative cache result
     */
    protected static CacheEntry FALSE_ENTRY = new Dfs.CacheEntry(0L);

    /**
     * Cache of trusted domains for DFS resolution
     */

        /** The process to monitor and destroy. */
        private final Process p;

        /** The input stream thread reading process output. */
        private final InputStreamThread ist;

        /** Flag indicating if the destroyer has been executed. */
        private final AtomicBoolean executed = new AtomicBoolean(false);

        /** Timeout for process destruction in milliseconds. */
        private final long timeout;

     * and then replacing the original file upon successful commit.
     */
    protected class SynonymUpdater implements Closeable {

        /** A flag indicating whether the changes have been committed. */
        protected boolean isCommit = false;

        /** The temporary file to write changes to. */
        protected File newFile;

     * To allow interpolation of this field, this method lazily parses
     * the {@link #getActiveString()} value as a boolean and defaults to {@code true}
     * if not set.
     *
     * @return a boolean indicating if this proxy is active
     */
    public boolean isActive() {
        return (getActiveString() != null) ? Boolean.parseBoolean(getActiveString()) : true;
    }

    /**

   *
   * @since 13.0
   */
  public enum Policies implements Policy {
    /**
     * When potential deadlock is detected, this policy results in the throwing of the {@code
     * PotentialDeadlockException} indicating the potential deadlock, which includes stack traces
     * illustrating the cycle in lock acquisition order.
     */
    THROW {
      @Override
      public void handlePotentialDeadlock(PotentialDeadlockException e) {

    static final String[] SID_TYPE_NAMES =
            { "0", "User", "Domain group", "Domain", "Local group", "Builtin group", "Deleted", "Invalid", "Unknown" };

    /**
     * Flag indicating that SIDs should be resolved to names.
     */
    public static final int SID_FLAG_RESOLVE_SIDS = 0x0001;

    /**
     * Well known SID: EVERYONE
     */
    public static SID EVERYONE = null;

    /**

         * the andx command will not be written and therefore the
         * response will not read a batched command and therefore
         * the 'received' member of the response object will not
         * be set to true indicating the send and sendTransaction
         * methods that the next part should be sent. This is a
         * very indirect and simple batching control mechanism.
         */

    protected CrawlerClientFactory clientFactory;

    /**
     * Context object containing crawler state and configuration.
     */
    protected CrawlerContext crawlerContext;

    /**
     * Flag indicating whether to wait on folder operations.
     */
    protected boolean noWaitOnFolder = false;

    /**
     * Increments the active thread count using atomic operation.
     */

    /**
     * List of listeners for connection events.
     */
    protected List<OnConnectListener> onConnectListenerList = new CopyOnWriteArrayList<>();

    /**
     * Flag indicating whether the client is connected.
     */
    private volatile boolean connected;

    /**
     * Scroll for delete operations.
     */