Symbols ![]()
loading...
Files ![]()
loading (2/5)...
otTcpCircularSendBufferWrite() function
Sends out data on a TCP endpoint, using the provided TCP circular send buffer to manage buffering. Once this function is called, @p aSendBuffer and @p aEndpoint are considered "attached" to each other. While they are attached, ALL send operations for @p aEndpoint must be made using @p aSendBuffer and ALL operations on @p aSendBuffer must be associated with @p aEndpoint . The only way to "detach" a TCP circular send buffer and a TCP endpoint is to wait for the send buffer to become completely empty. This can happen in two ways: (1) all data in the send buffer is sent and acknowledged in the normal course of TCP protocol operation, or (2) the connection is terminated. The recommended usage pattern is to use a single TCP circular send buffer with a TCP endpoint, and to send data on that TCP endpoint only via its associated TCP circular buffer. This recommended usage pattern sidesteps the issues described above by always using a TCP endpoint and TCP circular send buffer together. If the circular send buffer reaches capacity, only a prefix of the provided data is copied into the circular send buffer.
Syntax
otError otTcpCircularSendBufferWrite(otTcpEndpoint *aEndpoint,
otTcpCircularSendBuffer *aSendBuffer,
const void *aData,
size_t aLength,
size_t *aWritten,
uint32_t aFlags);
Return value
OT_ERROR_NONE Successfully copied data into the send buffer and sent it on the TCP endpoint. OT_ERROR_FAILED Failed to send out data on the TCP endpoint.
Related Functions
Found 29 other functions taking a ![]()
otTcpEndpoint
argument:
Function
Description
Provides the application with a linked buffer chain referencing data currently in the TCP receive buffer. The linked buffer chain is valid until the "receive ready" callback is next invoked, or until the next call to otTcpReceiveContiguify() or otTcpCommitReceive().
Informs the TCP stack that the application has finished processing @p aNumBytes bytes of data at the start of the receive buffer and that the TCP stack need not continue maintaining those bytes in the receive buffer.
Initializes a TCP endpoint. Calling this function causes OpenThread to keep track of the TCP endpoint and store and retrieve TCP data inside the @p aEndpoint. The application should refrain from directly accessing or modifying the fields in @p aEndpoint. If the application needs to reclaim the memory backing @p aEndpoint, it should call otTcpEndpointDeinitialize().
Obtains the otInstance that was associated with @p aEndpoint upon initialization.
Obtains the context pointer that was associated with @p aEndpoint upon initialization.
Obtains a pointer to a TCP endpoint's local host and port. The contents of the host and port may be stale if this socket is not in a connected state and has not been bound after it was last disconnected.
Obtains a pointer to a TCP endpoint's peer's host and port. The contents of the host and port may be stale if this socket is not in a connected state.
Binds the TCP endpoint to an IP address and port.
Records the remote host and port for this connection. TCP Fast Open must be enabled or disabled using @p aFlags. If it is disabled, then the TCP connection establishment handshake is initiated immediately. If it is enabled, then this function merely records the the remote host and port, and the TCP connection establishment handshake only happens on the first call to `otTcpSendByReference()`. If TCP Fast Open is disabled, then the caller must wait for the `otTcpEstablished` callback indicating that TCP connection establishment handshake is done before it can start sending data e.g., by calling `otTcpSendByReference()`.
Adds data referenced by the linked buffer pointed to by @p aBuffer to the send buffer. Upon a successful call to this function, the linked buffer and data it references are owned by the TCP stack; they should not be modified by the application until a "send done" callback returns ownership of those objects to the application. It is acceptable to call this function to add another linked buffer to the send queue, even if the "send done" callback for a previous invocation of this function has not yet fired. Note that @p aBuffer should not be chained; its mNext field should be NULL. If additional data will be added right after this call, then the OT_TCP_SEND_MORE_TO_COME flag should be used as a hint to the TCP implementation.
Adds data to the send buffer by extending the length of the final otLinkedBuffer in the send buffer by the specified amount. If the send buffer is empty, then the operation fails.
Reorganizes the receive buffer to be entirely contiguous in memory. This is optional; an application can simply traverse the linked buffer chain obtained by calling @p otTcpReceiveByReference. Some applications may wish to call this function to make the receive buffer contiguous to simplify their data processing, but this comes at the expense of CPU time to reorganize the data in the receive buffer.
Informs the connection peer that this TCP endpoint will not send more data. This should be used when the application has no more data to send to the connection peer. For this connection, future reads on the connection peer will result in the "end of stream" condition, and future writes on this connection endpoint will fail. The "end of stream" condition only applies after any data previously provided to the TCP stack to send out has been received by the connection peer.
Forcibly ends the TCP connection associated with this TCP endpoint. This immediately makes the TCP endpoint free for use for another connection and empties the send and receive buffers, transferring ownership of any data provided by the application in otTcpSendByReference() and otTcpSendByExtension() calls back to the application. The TCP endpoint's callbacks and memory for the receive buffer remain associated with the TCP endpoint.
Deinitializes this TCP endpoint. This means that OpenThread no longer keeps track of this TCP endpoint and deallocates all resources it has internally allocated for this TCP endpoint. The application can reuse the memory backing the TCP endpoint as it sees fit. If it corresponds to a live TCP connection, the connection is terminated unceremoniously (as in otTcpAbort()). All resources the application has provided for this TCP endpoint (linked buffers for the send buffer, memory for the receive buffer, the @p aEndpoint structure itself, etc.) are immediately returned to the application.
References
Code
Location
Referrer
Call Tree
otTcpCircularSendBufferWrite() is called by 1 function:
Data Use
otTcpCircularSendBufferWrite():