TCP
Este módulo incluye funciones que controlan la comunicación de TCP.
Resumen
Enumeraciones |
|
---|---|
anonymous enum
|
enum Esta enumeración define las marcas que se pasan a otTcpConnect(). |
anonymous enum
|
enum Esta enumeración define las marcas que se pasan a otTcpSendByReference . |
otTcpDisconnectedReason
|
enum |
otTcpIncomingConnectionAction{
|
enum Esta enumeración define las acciones de conexión entrante. |
Typedefs |
|
---|---|
otLinkedBuffer
|
typedefstruct otLinkedBuffer
Estructura de búfer vinculada para usar con TCP. |
otTcpAcceptDone)(otTcpListener *aListener, otTcpEndpoint *aEndpoint, const otSockAddr *aPeer)
|
typedefvoid(*
Esta devolución de llamada indica que la conexión TCP ahora está lista para la comunicación bidireccional. |
otTcpAcceptReady)(otTcpListener *aListener, const otSockAddr *aPeer, otTcpEndpoint **aAcceptInto)
|
typedef Esta devolución de llamada indica que llegó una conexión entrante que coincide con este objeto de escucha TCP. |
otTcpDisconnected)(otTcpEndpoint *aEndpoint, otTcpDisconnectedReason aReason)
|
typedefvoid(*
Esta devolución de llamada indica que la conexión está interrumpida y no debe usarse más, o que una conexión ingresó al estado TIME-WAIT. |
otTcpDisconnectedReason
|
typedefenum otTcpDisconnectedReason
|
otTcpEndpoint
|
typedefstruct otTcpEndpoint
|
otTcpEndpointInitializeArgs
|
typedefstruct otTcpEndpointInitializeArgs
Esta estructura contiene argumentos para la función otTcpEndpointInitialize(). |
otTcpEstablished)(otTcpEndpoint *aEndpoint)
|
typedefvoid(*
Esta devolución de llamada informa a la aplicación que se completó el protocolo de enlace de TCP de 3 vías y que ahora se establece la conexión. |
otTcpForwardProgress)(otTcpEndpoint *aEndpoint, size_t aInSendBuffer, size_t aBacklog)
|
typedefvoid(*
Esta devolución de llamada informa a la aplicación si se realizó un avance en la transferencia de datos del búfer de envío al destinatario. |
otTcpIncomingConnectionAction
|
typedef Esta enumeración define las acciones de conexión entrante. |
otTcpListener
|
typedefstruct otTcpListener
|
otTcpListenerInitializeArgs
|
typedefstruct otTcpListenerInitializeArgs
Esta estructura contiene argumentos para la función otTcpListenerInitialize(). |
otTcpReceiveAvailable)(otTcpEndpoint *aEndpoint, size_t aBytesAvailable, bool aEndOfStream, size_t aBytesRemaining)
|
typedefvoid(*
Esta devolución de llamada indica el número de bytes disponibles para el consumo del búfer de recepción. |
otTcpSendDone)(otTcpEndpoint *aEndpoint, otLinkedBuffer *aData)
|
typedefvoid(*
Esta devolución de llamada informa a la aplicación que el par de conexión reconoció los datos en el aData proporcionado, y que la aplicación puede reclamar los aData y los datos que contiene. |
Funciones |
|
---|---|
otTcpAbort(otTcpEndpoint *aEndpoint)
|
Fuerza la conexión de TCP asociada a este extremo de TCP.
|
otTcpBind(otTcpEndpoint *aEndpoint, const otSockAddr *aSockName)
|
Vincula el extremo TCP a una dirección IP y un puerto.
|
otTcpCommitReceive(otTcpEndpoint *aEndpoint, size_t aNumBytes, uint32_t aFlags)
|
Informa a la pila TCP que la aplicación terminó de procesar
aNumBytes bytes de datos al comienzo del búfer de recepción y que no es necesario que la pila de TCP continúe manteniendo esos bytes en el búfer de recepción. |
otTcpConnect(otTcpEndpoint *aEndpoint, const otSockAddr *aSockName, uint32_t aFlags)
|
Registra el host remoto y el puerto para esta conexión.
|
otTcpEndpointDeinitialize(otTcpEndpoint *aEndpoint)
|
Anula la inicialización de este extremo de TCP.
|
otTcpEndpointGetContext(otTcpEndpoint *aEndpoint)
|
void *
Obtiene el puntero de contexto que se asoció con
aEndpoint en el momento de la inicialización. |
otTcpEndpointGetInstance(otTcpEndpoint *aEndpoint)
|
Obtiene la otInstance que se asoció con
aEndpoint cuando se inicializó. |
otTcpEndpointInitialize(otInstance *aInstance, otTcpEndpoint *aEndpoint, const otTcpEndpointInitializeArgs *aArgs)
|
Inicializa un extremo de TCP.
|
otTcpGetLocalAddress(const otTcpEndpoint *aEndpoint)
|
const otSockAddr *
Obtiene un puntero para un host y puerto local del extremo TCP.
|
otTcpGetPeerAddress(const otTcpEndpoint *aEndpoint)
|
const otSockAddr *
Obtiene un puntero para el host y el puerto de un extremo de TCP.
|
otTcpListen(otTcpListener *aListener, const otSockAddr *aSockName)
|
Hace que las conexiones TCP entrantes que coincidan con la dirección IP y el puerto especificados activen las devoluciones de llamada de este objeto de escucha TCP.
|
otTcpListenerDeinitialize(otTcpListener *aListener)
|
Anula la inicialización de este objeto de escucha de TCP.
|
otTcpListenerGetContext(otTcpListener *aListener)
|
void *
Obtiene el puntero de contexto que se asoció con
aListener en el momento de la inicialización. |
otTcpListenerGetInstance(otTcpListener *aListener)
|
Obtiene la otInstance que se asoció con
aListener cuando se inicializó. |
otTcpListenerInitialize(otInstance *aInstance, otTcpListener *aListener, const otTcpListenerInitializeArgs *aArgs)
|
Inicializa un objeto de escucha de TCP.
|
otTcpReceiveByReference(otTcpEndpoint *aEndpoint, const otLinkedBuffer **aBuffer)
|
Proporciona a la aplicación una cadena de búfer vinculada a los datos que se encuentran actualmente en el búfer de recepción TCP.
|
otTcpReceiveContiguify(otTcpEndpoint *aEndpoint)
|
Reorganiza el búfer de recepción para que sea completamente contiguo en la memoria.
|
otTcpSendByExtension(otTcpEndpoint *aEndpoint, size_t aNumBytes, uint32_t aFlags)
|
Agrega datos al búfer de envío extendiendo la longitud del otLinkedBuffer final en el búfer de envío según la cantidad especificada.
|
otTcpSendByReference(otTcpEndpoint *aEndpoint, otLinkedBuffer *aBuffer, uint32_t aFlags)
|
Agrega los datos a los que hace referencia el búfer vinculado al que hace referencia
aBuffer al búfer de envío. |
otTcpSendEndOfStream(otTcpEndpoint *aEndpoint)
|
Informa al par de conexión que este extremo de TCP no enviará más datos.
|
otTcpStopListening(otTcpListener *aListener)
|
Hace que este objeto de escucha de TCP deje de escuchar las conexiones entrantes.
|
Structs |
|
---|---|
otLinkedBuffer |
Estructura de búfer vinculada para usar con TCP. |
otTcpEndpoint |
Esta estructura representa un extremo de TCP. |
otTcpEndpointInitializeArgs |
Esta estructura contiene argumentos para la función otTcpEndpointInitialize(). |
otTcpListener |
Esta estructura representa un objeto de escucha de TCP. |
otTcpListenerInitializeArgs |
Esta estructura contiene argumentos para la función otTcpListenerInitialize(). |
Enumeraciones
enumeración anónima
anonymous enum
Esta enumeración define las marcas que se pasan a otTcpConnect().
enumeración anónima
anonymous enum
Esta enumeración define las marcas que se pasan a otTcpSendByReference
.
OtTcpDisconnectedReason
otTcpDisconnectedReason
otTcpIncomingConnectionAction
otTcpIncomingConnectionAction
Esta enumeración define las acciones de conexión entrante.
Se usa en la devolución de llamada otTcpAcceptReady().
Propiedades | |
---|---|
OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT
|
Aceptar la conexión entrante |
OT_TCP_INCOMING_CONNECTION_ACTION_DEFER
|
Aplaza (ignora en silencio) la conexión entrante. |
OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE
|
Rechazar la conexión entrante |
Typedefs
otLinkedBuffer
struct otLinkedBuffer otLinkedBuffer
Estructura de búfer vinculada para usar con TCP.
Una sola estructura otLinkedBuffer hace referencia a un arreglo de bytes en la memoria, a través de mData y mLength. El campo mNext se usa para formar una cadena de estructuras otLinkedBuffer.
otTcpAcceptDone
void(* otTcpAcceptDone)(otTcpListener *aListener, otTcpEndpoint *aEndpoint, const otSockAddr *aPeer)
Esta devolución de llamada indica que la conexión TCP ahora está lista para la comunicación bidireccional.
En el caso de TCP Fast Open, es posible que esto suceda antes de que se complete el protocolo de enlace de la conexión TCP. La aplicación recibe los punteros de contexto correspondientes al objeto de escucha TCP que aceptó la conexión y al extremo TCP en el que se aceptó. El contexto proporcionado es el que está asociado con el objeto de escucha de TCP.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
otTcpAcceptReady
otTcpIncomingConnectionAction(* otTcpAcceptReady)(otTcpListener *aListener, const otSockAddr *aPeer, otTcpEndpoint **aAcceptInto)
Esta devolución de llamada indica que llegó una conexión entrante que coincide con este objeto de escucha TCP.
La respuesta típica es que la aplicación acepte la conexión entrante. Para ello, propaga aAcceptInto
con un puntero al otTcpEndpoint a fin de aceptar la conexión entrante. Este otTcpEndpoint ya se debe inicializar con otTcpEndpointInitialize(). Luego, la aplicación muestra OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT.
Como alternativa, la aplicación puede rechazar la conexión entrante. Hay dos maneras en las que la aplicación puede hacerlo. En primer lugar, si la aplicación muestra OT_TCP_INCOMING_CONNECTION_ACTION_DEFER, OpenThread ignora de forma silenciosa la solicitud de conexión de conexión; es probable que la red de intercambio de tráfico vuelva a transmitir la solicitud, lo que hará que se vuelva a llamar a la devolución de llamada. Esto es útil si los recursos no están disponibles actualmente para aceptar la conexión, pero pueden estar disponibles cuando el par de conexión retransmita el intento de establecimiento de la conexión. En segundo lugar, si la aplicación muestra OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE, OpenThread envía un mensaje de "conexión rechazada" al host que intentó establecer una conexión. Si la aplicación rechaza la conexión entrante, no es necesario que propague aAcceptInto
.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Qué muestra |
Descripción de cómo controlar la conexión entrante.
|
otTcpDisconnected
void(* otTcpDisconnected)(otTcpEndpoint *aEndpoint, otTcpDisconnectedReason aReason)
Esta devolución de llamada indica que la conexión está interrumpida y no debe usarse más, o que una conexión ingresó al estado TIME-WAIT.
Esto puede ocurrir si falla un intento de establecimiento de la conexión (iniciado mediante una llamada a otTcpConnect()) o en cualquier momento posterior (p.ej., si se agota el tiempo de espera de la conexión o si se recibe un segmento RST del par de conexión). Una vez que se activa esta devolución de llamada, se pueden recuperar todos los recursos que la aplicación proporcionó para esta conexión (es decir, cualquier otLinkedBuffers
y memoria a la que hagan referencia, pero no el extremo TCP ni el espacio de los búferes de recepción). En el caso de una conexión que entra en el estado TIME-WAIT, esta devolución de llamada se llama dos veces, una vez que se ingresa en el estado TIME-WAIT (con OT_TCP_DISCONNECTED_REASON_TIME_WAIT, y nuevamente cuando vence el estado de TIME-WAIT (con OT_TCP_DISCONNECTED_REASON_NORMAL).
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
OtTcpDisconnectedReason
enum otTcpDisconnectedReason otTcpDisconnectedReason
otTcpEndpoint
struct otTcpEndpoint otTcpEndpoint
otTcpEndpointInitializeArgs
struct otTcpEndpointInitializeArgs otTcpEndpointInitializeArgs
Esta estructura contiene argumentos para la función otTcpEndpointInitialize().
otTcpEstablished
void(* otTcpEstablished)(otTcpEndpoint *aEndpoint)
Esta devolución de llamada informa a la aplicación que se completó el protocolo de enlace de TCP de 3 vías y que ahora se establece la conexión.
Detalles | |||
---|---|---|---|
Parámetros |
|
OtTcpForwardProgress
void(* otTcpForwardProgress)(otTcpEndpoint *aEndpoint, size_t aInSendBuffer, size_t aBacklog)
Esta devolución de llamada informa a la aplicación si se realizó un avance en la transferencia de datos del búfer de envío al destinatario.
Esta devolución de llamada no es necesaria para el funcionamiento correcto de TCP. La mayoría de las aplicaciones solo pueden confiar en la devolución de llamada otTcpSendDone() para recuperar los búferes vinculados una vez que la pila TCP termina de usarlos. El propósito de esta devolución de llamada es admitir aplicaciones avanzadas que se beneficien de información más detallada sobre la progresión de la conexión en la transferencia de datos al par de conexión.
Esta operación de devolución de llamada está estrechamente vinculada al búfer de envío de TCP. Se puede interpretar que el búfer de envío tiene dos regiones. En primer lugar, hay una región en tránsito en el encabezado (delantera) del búfer de envío. Corresponde a datos que se enviaron al destinatario, pero aún no se reconocen. La segunda es la región de backlogt, que se compone de todos los datos del búfer de envío que no se encuentran en la región de vuelo. La región de trabajos pendientes corresponde a los datos que están en cola para el envío, pero que todavía no se enviaron.
La devolución de llamada se invoca en respuesta a dos tipos de eventos. En primer lugar, es posible que se reduzca la región de emisión en curso del búfer de envío (p.ej., cuando el destinatario reconoce los datos que enviamos antes). En segundo lugar, es posible que se reduzca la región de trabajo pendiente (p.ej., se enviaron datos nuevos). Estas dos condiciones suelen ocurrir al mismo tiempo en respuesta a un segmento ACK del par de conexión, por lo que se combinan en una sola devolución de llamada.
La pila TCP solo usa los bytes aInSendBuffer
que están al final del búfer de envío. Cuando aInSendBuffer
disminuye en una cantidad x, significa que x bytes adicionales que antes estaban en el encabezado del búfer de envío ya no forman parte del búfer de envío y ahora la aplicación puede reclamarlos (es decir, reemplazarlos). Ten en cuenta que la estructura otLinkedBuffer en sí solo se puede reclamar una vez que todos los bytes a los que hace referencia ya no forman parte del búfer de envío.
Esta devolución de llamada supone otTcpSendDone(), en el siguiente sentido: las aplicaciones pueden determinar cuándo se pueden reclamar los búferes vinculados si compara aInSendBuffer
con la cantidad de bytes que hay en cada búfer vinculado. Sin embargo, esperamos que otTcpSendDone(), que transmite directamente qué otLinkedBuffers se puede reclamar, será mucho más fácil de usar. Si se registran ambas devoluciones de llamada y se activan mediante el mismo evento (p.ej., en el mismo segmento ACK recibido), se activará primero la devolución de llamada otTcpSendDone(), y, a continuación, esta devolución de llamada.
Además, esta devolución de llamada proporciona aBacklog
, que indica cuántos bytes de datos en el búfer de envío aún no están en tránsito. Para las aplicaciones que solo desean agregar datos al búfer de envío cuando existe la certeza de que se enviarán pronto, puede ser conveniente enviar datos solo cuando aBacklog
sea lo suficientemente pequeño (0 o cercano a 0). Por ejemplo, una aplicación puede usar aBacklog
para que pueda reaccionar a la compilación de la cola cuando se descarta o agrega datos a fin de evitar crear una acumulación de datos.
Después de una llamada a otTcpSendByReference() o a otTcpSendByExtension() con una cantidad positiva de bytes, se garantiza la llamada a la devolución de llamada otTcpForwardProgress(), para indicar cuándo se envían los bytes que se agregaron al búfer de envío. La llamada a otTcpForwardProgress() se puede realizar inmediatamente después de que los bytes se agreguen al búfer de envío (si algunos de esos bytes se envían de inmediato, lo que reduce la cantidad de tareas pendientes), o en algún momento en el futuro (una vez que la conexión envía algunos o todos los datos, lo que reduce la cantidad de tareas pendientes). Con “inmediata”, nos referimos a que la devolución de llamada se programará inmediatamente para su ejecución en un Tasklet. A fin de evitar la complejidad relacionada con el reentrado, nunca se llama a la devolución de llamada otTcpForwardProgress() directamente desde las funciones otTcpSendByReference() u otTcpSendByExtension().
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
otTcpIncomingConnectionAction
enum otTcpIncomingConnectionAction otTcpIncomingConnectionAction
Esta enumeración define las acciones de conexión entrante.
Se usa en la devolución de llamada otTcpAcceptReady().
OtTcpListener
struct otTcpListener otTcpListener
otTcpListenerInitializeArgs
struct otTcpListenerInitializeArgs otTcpListenerInitializeArgs
Esta estructura contiene argumentos para la función otTcpListenerInitialize().
otTcpReceiveAvailable
void(* otTcpReceiveAvailable)(otTcpEndpoint *aEndpoint, size_t aBytesAvailable, bool aEndOfStream, size_t aBytesRemaining)
Esta devolución de llamada indica el número de bytes disponibles para el consumo del búfer de recepción.
Se llama cada vez que se agregan bytes al búfer de recepción y cuando se llega al final de la transmisión. Si se llega al final de la transmisión (es decir, si no hay más datos disponibles para leer porque el par de conexiones cerró la conexión de escritura), aEndOfStream
es verdadero. Por último, aBytesRemaining
indica cuánta capacidad queda en el búfer de recepción para contener los datos adicionales que llegan.
Detalles | |||||||||
---|---|---|---|---|---|---|---|---|---|
Parámetros |
|
otTcpSendDone
void(* otTcpSendDone)(otTcpEndpoint *aEndpoint, otLinkedBuffer *aData)
Esta devolución de llamada informa a la aplicación que el par de conexión reconoció los datos en el aData
proporcionado, y que la aplicación puede reclamar los aData
y los datos que contiene.
Se garantiza que los aData
sean idénticos a los que se pasan a TCP a través de otTcpSendByReference(), incluidas las extensiones afectadas mediante otTcpSendByExtension().
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
Funciones
otcpAbort
otError otTcpAbort( otTcpEndpoint *aEndpoint )
Fuerza la conexión de TCP asociada a este extremo de TCP.
Esto hace que el extremo de TCP sea gratuito para otra conexión y vacía los búferes de envío y recepción, por lo que se transfiere la propiedad de todos los datos proporcionados por la aplicación en las llamadas otTcpSendByReference() y otTcpSendByExtension() a la aplicación. Las devoluciones de llamada y la memoria del extremo TCP para el búfer de recepción permanecen asociadas con el extremo TCP.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
ottcpBind
otError otTcpBind( otTcpEndpoint *aEndpoint, const otSockAddr *aSockName )
Vincula el extremo TCP a una dirección IP y un puerto.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
otTcpCommitReceive
otError otTcpCommitReceive( otTcpEndpoint *aEndpoint, size_t aNumBytes, uint32_t aFlags )
Informa a la pila TCP que la aplicación terminó de procesar aNumBytes
bytes de datos al comienzo del búfer de recepción y que no es necesario que la pila de TCP continúe manteniendo esos bytes en el búfer de recepción.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Valores que se muestran |
|
OtTcpConnect
otError otTcpConnect( otTcpEndpoint *aEndpoint, const otSockAddr *aSockName, uint32_t aFlags )
Registra el host remoto y el puerto para esta conexión.
De forma predeterminada, se usa el método de apertura rápida de TCP. Esto significa que esta función solo registra el host y el puerto remotos, y que el protocolo de enlace de conexión TCP solo se produce en la primera llamada a otTcpSendByReference(). El protocolo TCP Open Open se puede inhabilitar de forma explícita mediante aFlags
, en cuyo caso el protocolo de enlace de conexión TCP se inicia de inmediato.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Valores que se muestran |
|
otTcpEndpointDeInitialize
otError otTcpEndpointDeinitialize( otTcpEndpoint *aEndpoint )
Anula la inicialización de este extremo de TCP.
Esto significa que OpenThread ya no realiza un seguimiento de este extremo de TCP y desasigna todos los recursos que tiene asignados de forma interna para este extremo de TCP. La aplicación puede volver a usar la memoria que respalda el extremo de TCP según su criterio.
Si corresponde a una conexión TCP en vivo, la conexión se finaliza de forma inesperada (como en otTcpAbort()). Todos los recursos que la aplicación proporcionó para este extremo TCP (búferes vinculados para el búfer de envío, la memoria del búfer de recepción, la estructura aEndpoint
, etc.) se devuelven de inmediato a la aplicación.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
otTcpEndpointGetContext
void * otTcpEndpointGetContext( otTcpEndpoint *aEndpoint )
Obtiene el puntero de contexto que se asoció con aEndpoint
en el momento de la inicialización.
Detalles | |||
---|---|---|---|
Parámetros |
|
||
Qué muestra |
El puntero de contexto asociado con
aEndpoint . |
otTcpEndpointGetInstance
otInstance * otTcpEndpointGetInstance( otTcpEndpoint *aEndpoint )
Obtiene la otInstance que se asoció con aEndpoint
cuando se inicializó.
Detalles | |||
---|---|---|---|
Parámetros |
|
||
Qué muestra |
El puntero otInstance asociado con
aEndpoint . |
otTcpEndpointInitialize
otError otTcpEndpointInitialize( otInstance *aInstance, otTcpEndpoint *aEndpoint, const otTcpEndpointInitializeArgs *aArgs )
Inicializa un extremo de TCP.
Si se llama a esta función, OpenThread realiza un seguimiento del extremo de TCP y almacena y recupera datos de TCP dentro de aEndpoint
. La aplicación debe abstenerse de acceder o modificar directamente los campos de aEndpoint
. Si la aplicación necesita recuperar la memoria aEndpoint
que respalda la copia de seguridad, debe llamar a otTcpEndpointDeInitialize().
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Valores que se muestran |
|
otTcpGetLocalAddress
const otSockAddr * otTcpGetLocalAddress( const otTcpEndpoint *aEndpoint )
Obtiene un puntero para un host y puerto local del extremo TCP.
El contenido del host y el puerto puede estar inactivo si el socket no está conectado y no se vinculó después de la última desconexión.
Detalles | |||
---|---|---|---|
Parámetros |
|
||
Qué muestra |
El host y el puerto locales de
aEndpoint . |
otTcpGetPeerAddress
const otSockAddr * otTcpGetPeerAddress( const otTcpEndpoint *aEndpoint )
Obtiene un puntero para el host y el puerto de un extremo de TCP.
El contenido del host y el puerto puede estar inactivo si este socket no está en estado conectado.
Detalles | |||
---|---|---|---|
Parámetros |
|
||
Qué muestra |
El host y el puerto del par de conexión de
aEndpoint |
otTcpListener
otError otTcpListen( otTcpListener *aListener, const otSockAddr *aSockName )
Hace que las conexiones TCP entrantes que coincidan con la dirección IP y el puerto especificados activen las devoluciones de llamada de este objeto de escucha TCP.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
otTcpListenerDeInitialize
otError otTcpListenerDeinitialize( otTcpListener *aListener )
Anula la inicialización de este objeto de escucha de TCP.
Esto significa que OpenThread ya no realiza un seguimiento de este objeto de escucha TCP y desasigna todos los recursos que tiene asignados internamente para este objeto de escucha TCP. La aplicación puede volver a usar la memoria que respalda al objeto de escucha TCP cuando lo considere adecuado.
Si el objeto de escucha de TCP está escuchando, deja de escuchar.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
OtTcpListenerGetContext
void * otTcpListenerGetContext( otTcpListener *aListener )
Obtiene el puntero de contexto que se asoció con aListener
en el momento de la inicialización.
Detalles | |||
---|---|---|---|
Parámetros |
|
||
Qué muestra |
El puntero de contexto asociado con
aListener . |
otTcpListenerGetInstance
otInstance * otTcpListenerGetInstance( otTcpListener *aListener )
Obtiene la otInstance que se asoció con aListener
cuando se inicializó.
Detalles | |||
---|---|---|---|
Parámetros |
|
||
Qué muestra |
El puntero otInstance asociado con
aListener . |
otTcpListenerInitialize
otError otTcpListenerInitialize( otInstance *aInstance, otTcpListener *aListener, const otTcpListenerInitializeArgs *aArgs )
Inicializa un objeto de escucha de TCP.
Si se llama a esta función, OpenThread realiza un seguimiento del objeto de escucha de TCP y almacena y recupera datos de TCP dentro de aListener
. La aplicación debe abstenerse de acceder o modificar directamente los campos de aListener
. Si la aplicación necesita recuperar la memoria aListener
que respalda la copia de seguridad, debe llamar a otTcpListenerDeInitialize().
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Valores que se muestran |
|
otTcpReceiveByReference
otError otTcpReceiveByReference( otTcpEndpoint *aEndpoint, const otLinkedBuffer **aBuffer )
Proporciona a la aplicación una cadena de búfer vinculada a los datos que se encuentran actualmente en el búfer de recepción TCP.
La cadena de búfer vinculada es válida hasta que se invoque la devolución de llamada "& listo" o hasta la siguiente llamada a otTcpReceiveContiguify() o a otTcpCommitReceive().
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
otTcpReceiveContiguify
otError otTcpReceiveContiguify( otTcpEndpoint *aEndpoint )
Reorganiza el búfer de recepción para que sea completamente contiguo en la memoria.
Esto es opcional; una aplicación puede simplemente atravesar la cadena de búfer vinculada si se llama a otTcpReceiveByReference
. Es posible que algunas aplicaciones quieran llamar a esta función para hacer que el búfer de recepción sea contiguo a fin de simplificar su procesamiento de datos, pero esto sacrifica el tiempo de la CPU para reorganizar los datos en el búfer de recepción.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
otTcpSendByExtension
otError otTcpSendByExtension( otTcpEndpoint *aEndpoint, size_t aNumBytes, uint32_t aFlags )
Agrega datos al búfer de envío extendiendo la longitud del otLinkedBuffer final en el búfer de envío según la cantidad especificada.
Si el búfer de envío está vacío, la operación falla.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Valores que se muestran |
|
otTcpSendByReference
otError otTcpSendByReference( otTcpEndpoint *aEndpoint, otLinkedBuffer *aBuffer, uint32_t aFlags )
Agrega los datos a los que hace referencia el búfer vinculado al que hace referencia aBuffer
al búfer de envío.
Si la llamada a esta función se realiza correctamente, el búfer vinculado y los datos a los que hace referencia son propiedad de la pila TCP. La aplicación no debe modificarlos hasta que un callback "enviar lista" muestre la propiedad de esos objetos a la aplicación. Es aceptable llamar a esta función para agregar otro búfer vinculado a la cola de envío, incluso si aún no se activó la devolución de llamada "enviar Listo" para una invocación previa de esta función.
Ten en cuenta que aBuffer
no debe encadenarse, su campo mNext debe ser NULO. Si se agregan datos adicionales justo después de esta llamada, se debe usar la marca OT_TCP_SEND_MORE_TO_COME como sugerencia para la implementación de TCP.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Valores que se muestran |
|
otTcpSendEndOfStream
otError otTcpSendEndOfStream( otTcpEndpoint *aEndpoint )
Informa al par de conexión que este extremo de TCP no enviará más datos.
Se debe usar cuando la aplicación no tiene más datos para enviar al par de conexión. Para esta conexión, las lecturas futuras del par de conexión darán como resultado la condición de "fin de transmisión" y las escrituras futuras en este extremo de conexión fallarán.
La condición de fin de transmisión solo se aplica después de que el par de conexión recibe los datos que se enviaron previamente a la pila de TCP para su envío.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
otTcpStopListenering
otError otTcpStopListening( otTcpListener *aListener )
Hace que este objeto de escucha de TCP deje de escuchar las conexiones entrantes.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
Macros
OT_TCP_ENDPOINT_TCB_NUM_PTR
OT_TCP_ENDPOINT_TCB_NUM_PTR 36
OT_TCP_ENDPOINT_TCB_SIZE_BASE
OT_TCP_ENDPOINT_TCB_SIZE_BASE 368
Se eligen OT_TCP_ENDPOINT_TCB_SIZE_BASE y OT_TCP_ENDPOINT_TCB_NUM_POINTERS para que el campo mTcb de otTcpEndpoint tenga el mismo tamaño que el struct tcpcb en TCPlp.
Esto es necesario porque el campo mTcb, aunque es opaco en su declaración, se trata como struct tcpcb en la implementación de TCP.
OT_TCP_LISTENER_TCB_NUM_PTR
OT_TCP_LISTENER_TCB_NUM_PTR 3
OT_TCP_LISTENER_TCB_SIZE_BASE
OT_TCP_LISTENER_TCB_SIZE_BASE 16
Se eligen OT_TCP_LISTENER_TCB_SIZE_BASE y OT_TCP_LISTENER_TCB_NUM_POINTERS para que el campo mTcbListener de otTcpListener tenga el mismo tamaño que el struct tcpcb_listen en TCPlp.
Esto es necesario porque el campo mTcbListener, aunque en su declaración, se trata como struct tcpcb en la implementación de TCP.
OT_TCP_RECEIVE_BUFFER_SIZE_FEW_HOPS
OT_TCP_RECEIVE_BUFFER_SIZE_FEW_HOPS 2598
Tamaño de búfer recomendado para conexiones TCP que recorren 3 saltos inalámbricos o menos.
En plataformas en las que la memoria tiene una limitación particular y en situaciones en las que no se necesita un ancho de banda alto, es posible que desees seleccionar manualmente un tamaño de búfer más pequeño.
OT_TCP_RECEIVE_BUFFER_SIZE_MANY_HOPS
OT_TCP_RECEIVE_BUFFER_SIZE_MANY_HOPS 4157
Tamaño de búfer recomendado para conexiones TCP que recorren muchos saltos inalámbricos.
Si la conexión TCP recorre una gran cantidad de saltos (más de 6 aproximadamente), entonces te recomendamos seleccionar un tamaño de búfer grande de forma manual.
Recursos
Los temas de referencia de la API de OpenThread se originan en el código fuente, disponible en GitHub. Para obtener más información o colaborar con nuestra documentación, consulta Recursos.