* the 'received' member of the response object will not
         * be set to true indicating the send and sendTransaction
         * methods that the next part should be sent. This is a
         * very indirect and simple batching control mechanism.
         */

        if (andx == null || !USE_BATCHING || batchLevel >= getBatchLimit(andx.command)) {
            andxCommand = (byte) 0xFF;

- `aws:PrincipalType` - This value indicates whether the principal is an account (Root credential), user (MinIO user), or assumed role (STS)
- `aws:SecureTransport` - This is a Boolean value that represents whether the request was sent over TLS.
- `aws:SourceIp` - This is the requester's IP address, for use with IP address conditions. If running behind Nginx like proxies, MinIO preserve's the source IP.

```
{
  "Version": "2012-10-17",

        // CRITICAL: Set the binding flag per MS-SMB2
        request.setSessionBinding(true);

        // The actual transport send would need proper integration
        // This would be sent on the NEW channel's transport, not the existing one

        log.debug("Channel binding prepared for channel {} with session 0x{}", channel.getChannelId(), Long.toHexString(getSessionId()));
    }

    /**

        end
        handler -->> client: HTTP error response
    end

    operation ->> client: Return response to client
    Note over client,operation: Response is already sent, can't change it anymore
    opt Tasks
        operation -->> tasks: Send background tasks
    end
    opt Raise other exception
        tasks -->> tasks: Handle exceptions in the background task code
    end

  /**
   * Cancel: A control character used to indicate that the data with which it is sent is in error or
   * is to be disregarded.
   *
   * @since 8.0
   */
  public static final byte CAN = 24;

  /**
   * End of Medium: A control character associated with the sent data which may be used to identify
   * the physical end of the medium, or the end of the used, or wanted, portion of information

        bytesTransferred.addAndGet(bytes);
        totalWriteTime.addAndGet(durationNanos);
    }

    /**
     * Record an RDMA send operation
     *
     * @param bytes number of bytes sent
     * @param durationNanos operation duration in nanoseconds
     */
    public void recordRdmaSend(int bytes, long durationNanos) {
        rdmaSends.incrementAndGet();
        bytesTransferred.addAndGet(bytes);

# Request Body { #request-body }

When you need to send data from a client (let's say, a browser) to your API, you send it as a **request body**.

A **request** body is data sent by the client to your API. A **response** body is the data your API sends to the client.

              workerRunningState = IDLE;
              return;
            }
          }
          // Remove the interrupt bit before each task. The interrupt is for the "current task" when
          // it is sent, so subsequent tasks in the queue should not be caused to be interrupted
          // by a previous one in the queue being interrupted.
          interruptedDuringTask |= Thread.interrupted();
          try {

        String type = "VeryLongTokenTypeNameForTestingPurposes";
        String message =
                "This is a very long error message that describes in detail why the access token is invalid and what went wrong during validation";
        InvalidAccessTokenException exception = new InvalidAccessTokenException(type, message);

        assertEquals(type, exception.getType());
        assertEquals(message, exception.getMessage());

 */
package jcifs.internal.smb2.rdma;

import jcifs.internal.util.SMBUtil;

/**
 * SMB Direct Negotiate Response message.
 *
 * As per MS-SMBD 2.2.2 - SMB_DIRECT_NEGOTIATE_RESPONSE
 * This message is sent in response to negotiate SMB Direct protocol parameters.
 */
public class SmbDirectNegotiateResponse {

    // Protocol constants
    /** SMB Direct negotiate response message type */