}

        final Set<FileEntry> set = new HashSet<>();

        if (tc.getDfs().isTrustedDomain(tc, locator.getServer())) {
            /*
             * The server name is actually the name of a trusted
             * domain. Add DFS roots to the list.
             */
            try {
                entries = doDfsRootEnum(tc, locator, locator.getAddress());
                for (final FileEntry e : entries) {

    /**
     * Create a copy of the credentials.
     * @return a copy of the credentials
     */
    CredentialsInternal clone();

    /**
     * Create an SSP context for authentication.
     * @param tc the CIFS context
     * @param targetDomain the target domain for authentication
     * @param host the target host
     * @param initialToken initial authentication token, if any

     */
    public Handler() {
    }

    /**
     * Constructs an SMB URL handler with the specified CIFS context.
     *
     * @param tc the CIFS context to use
     */
    public Handler(final CIFSContext tc) {
        this.transportContext = tc;
    }

    @Override
    protected int getDefaultPort() {
        return SmbConstants.DEFAULT_PORT;
    }

    @Override

    /**
     * Add a referral to the cache
     *
     * @param path the DFS path for this referral
     * @param dr the DFS referral data to cache
     * @param tc the CIFS context containing configuration
     */
    void cache(CIFSContext tc, String path, DfsReferralData dr);

        super(config, SMB2_TREE_DISCONNECT);
    }

    @Override
    protected Smb2TreeDisconnectResponse createResponse(final CIFSContext tc,
            final ServerMessageBlock2Request<Smb2TreeDisconnectResponse> req) {
        return new Smb2TreeDisconnectResponse(tc.getConfig());
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override

    /**
     * Checks whether a connection can be reused for the given configuration.
     *
     * @param tc the CIFS context to check compatibility with
     * @param forceSigning whether signing is being forced
     * @return whether a connection can be reused for this config
     */
    boolean canReuse(CIFSContext tc, boolean forceSigning);

	// Add tracing to the prom. handler
	tracedHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		tc, ok := r.Context().Value(mcontext.ContextTraceKey).(*mcontext.TraceCtxt)
		if ok {
			tc.FuncName = "handler.MetricsV3"
			tc.ResponseRecorder.LogErrBody = true
		}

		innerHandler.ServeHTTP(w, r)
	})

	// Add authentication
	h.auth(tracedHandler).ServeHTTP(w, r)

     *
     * @param tc
     *            context to use
     *
     * @return guessed alternate name
     */
    @Override
    public String nextCalledName(final CIFSContext tc) {
        if (this.addr instanceof NbtAddress) {
            return ((NbtAddress) this.addr).nextCalledName(tc);
        }
        if (this.calledName != NbtAddress.SMBSERVER_NAME) {

     */
    @Override
    public boolean canReuse(final CIFSContext tc, final boolean forceSigning) {
        return getConfig().equals(tc.getConfig());
    }

    @Override
    public boolean isValid(final CIFSContext tc, final SmbNegotiationRequest req) {
        if (!isReceived() || getStatus() != 0) {
            return false;
        }

     *      jcifs.internal.smb2.ServerMessageBlock2Request)
     */
    @Override
    protected Smb2CloseResponse createResponse(final CIFSContext tc, final ServerMessageBlock2Request<Smb2CloseResponse> req) {
        return new Smb2CloseResponse(tc.getConfig(), this.fileId, this.fileName);
    }

    /**
     * Set the close flags
     *
     * @param flags
     *            the flags to set
     */