*/
    int recv(byte[] buf, int off, int length) throws IOException;

    /**
     * Send data to the pipe
     *
     * @param buf buffer containing data to send
     * @param off offset in the buffer
     * @param length length of data to send
     * @throws IOException if an I/O error occurs
     */
    void send(byte[] buf, int off, int length) throws IOException;

    /**

///

## Await for messages and send messages { #await-for-messages-and-send-messages }

In your WebSocket route you can `await` for messages and send messages.

{* ../../docs_src/websockets_/tutorial001_py310.py hl[48:52] *}

You can receive and send binary, text, and JSON data.

## Try it { #try-it }

    And this path operation will:

    * Send the invoice to the client.
    * Collect the money from the client.
    * Send a notification back to the API user (the external developer), as a callback.
        * At this point is that the API will somehow send a POST request to the
            external API with the notification of the invoice event
            (e.g. "payment successful").
    """

			if debugPrint {
				fmt.Println("muxServer: Mux", m.ID, "send EOF", hErr)
			}
			msg.Flags |= FlagEOF
			if hErr != nil {
				msg.Flags |= FlagPayloadIsErr
				msg.Payload = []byte(*hErr)
			}
			msg.setZeroPayloadFlag()
			m.send(msg)
			return
		}
		msg.Payload = payload
		msg.setZeroPayloadFlag()
		m.send(msg)
	}
}

                log.warn("Failed to pre-allocate receive buffer", e);
            }
        }

        log.info("Initialized RDMA buffer pool with {} send and {} receive buffers", availableSendRegions.size(),
                availableReceiveRegions.size());
    }

    /**
     * Get a send region from the pool or allocate a new one
     *
     * @param minSize minimum required size
     * @return memory region for sending

        async with AsyncExitStack() as stack:
            scope[self.context_name] = stack

        // Stub tree send for varargs
        when(treeConnection.send(eq(resourceLoc), any(CommonServerMessageBlockRequest.class), isNull(), any(RequestParam[].class)))
                .thenReturn(resp);

        CommonServerMessageBlockResponse out = handle.send(req, RequestParam.NO_RETRY);
        assertSame(resp, out);

# 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.

        h.release();
        verify(tree, never()).send(isA(Smb2CloseRequest.class), any());
        verify(tree, never()).send(any(CommonServerMessageBlockRequest.class), any(SmbComBlankResponse.class), any(RequestParam[].class));

        // Second release: should close now via SMB2 path
        h.release();
        verify(tree, times(1)).send(isA(Smb2CloseRequest.class), eq(RequestParam.NO_RETRY));

			// Even if there is nothing in the queue.
			if h.batchSize > 1 && time.Since(lastBatchProcess) < time.Second {
				continue
			}
		}

		// if we have reached the count send at once
		// or we have crossed last second before batch was sent, send at once
		lastBatchProcess = time.Now()

		var retries int
		retryIntvl := h.config.RetryIntvl
		if retryIntvl <= 0 {
			retryIntvl = 3 * time.Second
		}