bufferIndex += server.encryptionKeyLength;
            if (byteCount > server.encryptionKeyLength) {
                int len = 0;
                // Use appropriate string decoding based on Unicode flag
                try {
                    if ((flags2 & FLAGS2_UNICODE) == FLAGS2_UNICODE) {
                        while (buffer[bufferIndex + len] != (byte) 0x00 || buffer[bufferIndex + len + 1] != (byte) 0x00) {

        }
        case 3, 4, 5 -> {
            // NTLMv2 - returns empty for unicode hash as NTLMv2 doesn't use it
            yield new byte[0];
        }
        default -> {
            // Default to NTLMv2 behavior (empty response)
            log.info("Defaulting to secure NTLMv2 authentication (no unicode hash)");
            yield new byte[0];
        }
        };
    }

    /**

    protected SecureRandom random;
    /** Whether to use command batching for improved performance */
    protected boolean useBatching = false;
    /** Whether to use Unicode encoding for strings */
    protected boolean useUnicode = true;
    /** Force use of Unicode encoding regardless of negotiation */
    protected boolean forceUnicode = false;
    /** Whether SMB signing is preferred but not required */

        int notifyOffset = 80;
        SMBUtil.writeInt4(0, buffer, notifyOffset); // NextEntryOffset (0 = last entry)
        SMBUtil.writeInt4(1, buffer, notifyOffset + 4); // Action (FILE_ACTION_ADDED)
        // Write filename in Unicode
        String fileName = "test.txt";
        byte[] fileNameBytes = fileName.getBytes("UnicodeLittleUnmarked");
        SMBUtil.writeInt4(fileNameBytes.length, buffer, notifyOffset + 8); // FileNameLength

     *
     * @return whether to announce support for unicode
     */
    boolean isUseUnicode();

    /**
     *
     * Property {@code jcifs.smb.client.forceUnicode} (boolean, default false)
     *
     * @return whether to use unicode, even if the server does not announce it
     */
    boolean isForceUnicode();

    /**
     *

        byte[] buffer = new byte[256];
        int encodedSize = context.encode(buffer, 0);

        assertTrue(encodedSize > 8); // Minimum size: count + padding + flags + algorithms
        assertEquals(context.size(), encodedSize);
    }

    @Test
    @DisplayName("Test context decoding")
    public void testDecoding() throws SMBProtocolDecodingException {
        // Encode first
        byte[] buffer = new byte[256];

     */
    @Override
    public int getContextType() {
        return NEGO_CTX_ENC_TYPE;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt2(this.ciphers != null ? this.ciphers.length : 0, dst, dstIndex);
        dstIndex += 2;

		return
	}

	status, err := pools.Status(r.Context(), idx)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	adminLogIf(r.Context(), json.NewEncoder(w).Encode(&status))
}

func (a adminAPIHandlers) ListPools(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

If you need something easy to integrate with FastAPI but that is more robust, supported by Redis, PostgreSQL or others, check <a href="https://github.com/encode/broadcaster" class="external-link" target="_blank">encode/broadcaster</a>.

///

## More info { #more-info }

To learn more about the options, check Starlette's documentation for:

Vous pouvez également parrainer :

* <a href="https://github.com/sponsors/samuelcolvin" class="external-link" target="_blank">Samuel Colvin (Pydantic)</a>
* <a href="https://github.com/sponsors/encode" class="external-link" target="_blank">Encode (Starlette, Uvicorn)</a>

---