public void enc_ndr_small(final int s) {
        this.buf[this.index] = (byte) (s & 0xFF);
        advance(1);
    }

    /**
     * Decodes a small integer (1 byte) from NDR format.
     *
     * @return the decoded small integer value
     */
    public int dec_ndr_small() {
        final int val = this.buf[this.index] & 0xFF;
        advance(1);
        return val;
    }

    /**

                        SamrDomainHandle domainHandle = new SamrDomainHandle(handle, policyHandle, 0x02000000, domSid)) {
                    final MsrpcEnumerateAliasesInDomain rpc = new MsrpcEnumerateAliasesInDomain(domainHandle, 0xFFFF, sam);
                    handle.sendrecv(rpc);
                    if (rpc.retval != 0) {
                        throw new SmbException(rpc.retval, false);
                    }

     * @return the unsigned short value as an integer
     * @throws IOException if an I/O error occurs
     */
    public int readUnsignedShort() throws IOException {
        return readShort() & 0xffff;
    }

    /**
     * Reads a Windows FILETIME value and converts it to a Date.
     * @return the Date object, or null if the time represents infinity
     * @throws IOException if an I/O error occurs
     */

    val length = source.readMedium()
    if (length > INITIAL_MAX_FRAME_SIZE) {
      throw IOException("FRAME_SIZE_ERROR: $length")
    }
    val type = source.readByte() and 0xff
    val flags = source.readByte() and 0xff
    val streamId = source.readInt() and 0x7fffffff // Ignore reserved bit.
    if (type != TYPE_WINDOW_UPDATE && logger.isLoggable(FINE)) {
      logger.fine(frameLog(true, streamId, length, type, flags))

            byte[] testBuffer = new byte[8];
            ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);
            bb.putShort((short) 0xFFFE); // Max even pathConsumed
            bb.putShort((short) 0); // numReferrals
            bb.putShort((short) 0xFFFF); // Max tflags
            bb.putShort((short) 0); // tflags high bytes

            buffer.decode(testBuffer, 0, testBuffer.length);

            throws SmbException, MalformedURLException, UnknownHostException {
        this.file = file;
        this.append = append;
        this.openFlags = openFlags;
        this.access = openFlags >>> 16 & 0xFFFF;
        if (append) {
            try {
                fp = file.length();
            } catch (final SmbAuthException sae) {
                throw sae;
            } catch (final SmbException se) {

            final byte[] addr = localInetAddress.getAddress();
            localHostname =
                    "JCIFS" + (addr[2] & 0xFF) + "_" + (addr[3] & 0xFF) + "_" + Hexdump.toHexString((int) (Math.random() * 0xFF), 2);
        }

        /*
         * Create an NbtAddress for the local interface with
         * the name deduced above possibly with scope applied and

        // CAP_LARGE_WRITE
        if (th.hasCapability(SmbConstants.CAP_LARGE_WRITEX) && !th.areSignaturesActive()) {
            this.writeSizeFile = Math.min(th.getConfig().getSendBufferSize() - 70, 0xFFFF - 70);
        } else {
            log.debug("No support or SMB signing is enabled, not enabling large writes");
            this.writeSizeFile = this.writeSize;
        }

        if (log.isDebugEnabled()) {

        // Set security buffer length to excessive size (> 64KB)
        SMBUtil.writeInt2(128, buffer, 56); // Security buffer offset
        // writeInt2(100000) will truncate to 100000 & 0xFFFF = 34464
        SMBUtil.writeInt2(100000, buffer, 58); // This becomes 34464 due to 16-bit truncation

        // Since 34464 is within the 16-bit range but could still be considered excessive for security buffer,

    }

    @Test
    @DisplayName("Test createCancel with maximum MID value")
    void testCreateCancelWithMaxMid() {
        // Set MID to maximum value
        int maxMid = 0xFFFF;
        transaction.setMid(maxMid);

        // Create cancel request
        CommonServerMessageBlockRequest cancelRequest = transaction.createCancel();