}

    /**
     * Manually unblock an IP
     *
     * @param sourceIp the IP to unblock
     * @return true if IP was unblocked, false if not found
     */
    public boolean unblockIp(String sourceIp) {
        IpAttempts ip = ipAttempts.get(sourceIp);
        if (ip != null) {
            ip.reset();
            log.info("Manually unblocked IP: {}", sourceIp);
            return true;
        }

        // Block the IP
        for (int i = 1; i <= 5; i++) {
            assertTrue(rateLimiter.checkAttempt("user" + i, ip));
            rateLimiter.recordFailure("user" + i, ip);
        }

        // Should be blocked
        assertFalse(rateLimiter.checkAttempt("user6", ip), "IP should be blocked");

        // Manually unblock
        assertTrue(rateLimiter.unblockIp(ip), "Manual unblock should succeed");

        setField(unlock, "byteOffset", 300L);
        setField(unlock, "lengthInBytes", 400L);
        setField(cmd, "locks", new LockingAndXRange[] { lock });
        setField(cmd, "unlocks", new LockingAndXRange[] { unlock });
        setField(cmd, "largeFile", false);

        byte[] buffer = new byte[20];
        int len = cmd.writeParameterWordsWireFormat(buffer, 0);

        } finally {
            lock.writeLock().unlock();
        }
    }

    /**
     * Invalidate the cache
     */
    public void invalidate() {
        lock.writeLock().lock();
        try {
            children.clear();
            isComplete = false;
            hasChanges = true;
        } finally {
            lock.writeLock().unlock();
        }
    }

    /**

            guidToHandle.put(guid, info);

            if (type == HandleType.PERSISTENT) {
                persistHandle(info);
            }
        } finally {
            lock.writeLock().unlock();
        }

        log.debug("Requested {} handle for path: {}", type, path);
        return guid;
    }

    /**
     * Update the file ID for a handle after successful create response

        final int start = bufferIndex;
        for (int i = 0; i < this.unlocks.length; i++) {
            this.unlocks[i] = createLockRange();
            bufferIndex += this.unlocks[i].decode(buffer, bufferIndex, buffer.length);
        }

        for (int i = 0; i < this.locks.length; i++) {
            this.locks[i] = createLockRange();

            }
        } finally {
            lock.writeLock().unlock();
        }
    }
    
    public List<FileInfo> getChildren() {
        lock.readLock().lock();
        try {
            lastAccessTime = System.currentTimeMillis();
            return new ArrayList<>(children.values());
        } finally {
            lock.readLock().unlock();
        }
    }
    

            lock.writeLock().unlock();
        }
    }

    /**
     * Release all leases
     */
    public void releaseAll() {
        lock.writeLock().lock();
        try {
            log.info("Releasing all {} leases", leases.size());
            leases.clear();
            pathToLease.clear();
        } finally {
            lock.writeLock().unlock();
        }
    }

    /**

        DummyAndXBlock block = new DummyAndXBlock(next);

        assertNotNull(block);
        assertSame(next, block.andx, "andx should reference provided SMB");
    }

    @Test
    @DisplayName("getBatchLimit defaults to 0")
    void testGetBatchLimitDefault() {
        DummyAndXBlock block = new DummyAndXBlock();
        assertEquals(0, block.getBatchLimit((byte) 0x25));
    }

    @Test

            final byte[] sig = mac.doFinal();
            System.arraycopy(sig, 0, data, offset + SIGNATURE_OFFSET, SIGNATURE_LENGTH);
        } finally {
            this.signingLock.unlock();
        }
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.internal.SMBSigningDigest#verify(byte[], int, int, int, jcifs.internal.CommonServerMessageBlock)
     */