bufferIndex += 4;

        final int nunlocks = SMBUtil.readInt2(buffer, bufferIndex);
        this.unlocks = new LockingAndXRange[nunlocks];
        bufferIndex += 2;

        final int nlocks = SMBUtil.readInt2(buffer, bufferIndex);
        this.locks = new LockingAndXRange[nlocks];
        bufferIndex += 2;
        return start - bufferIndex;
    }

    /**

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

        log.debug("Cleaned up rate limiter entries. Accounts: {}, IPs: {}", accountAttempts.size(), ipAttempts.size());
    }

    /**
     * Manually unlock an account
     *
     * @param username the username to unlock
     * @return true if account was unlocked, false if not found
     */
    public boolean unlockAccount(String username) {
        AccountAttempts account = accountAttempts.get(username);

            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

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

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

    /**

        } catch (SmbException e) {
            // Expected
        }

        // Manually unlock
        assertTrue(rateLimiter.unlockAccount(username), "Manual unlock should succeed");

        // Should be allowed again
        assertTrue(rateLimiter.checkAttempt(username, ip), "Should be allowed after manual unlock");
    }

    @Test
    public void testManualUnblockIp() throws Exception {

        }

        @Test
        @DisplayName("Should write request with no locks")
        void testWriteBytesWireFormatNoLocks() {
            Smb2Lock[] noLocks = new Smb2Lock[0];
            Smb2LockRequest req = new Smb2LockRequest(mockConfig, testFileId, noLocks);
            byte[] buffer = new byte[256];

            int bytesWritten = req.writeBytesWireFormat(buffer, 0);

        // This test verifies that the DBFluteSystem is properly unlocked and locked
        // during the process, though we can't directly test the lock state

        // When
        try {
            curtainBeforeHook.processDBFluteSystem();

            // Then - if we get here without exception, the unlock/lock worked
            DfFinalTimeZoneProvider provider = getDBFluteSystemTimeZoneProvider();

    }
}
```

### 4.3 Lease Manager
```java
package jcifs.internal.smb2.lease;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import jcifs.CIFSContext;

public class LeaseManager {
    private final ConcurrentHashMap<Smb2LeaseKey, LeaseEntry> leases;

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