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 entrantes. |
Typedefs |
|
---|---|
otLinkedBuffer
|
typedefstruct otLinkedBuffer
Una 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 de TCP. |
otTcpDisconnected)(otTcpEndpoint *aEndpoint, otTcpDisconnectedReason aReason)
|
typedefvoid(*
Esta devolución de llamada indica que la conexión se interrumpió y no debe usarse más, o que una conexión entró en el estado TIME-WAIT. |
otTcpDisconnectedReason
|
typedefenum otTcpDisconnectedReason
|
otTcpEndpoint
|
typedefstruct otTcpEndpoint
|
otTcpEndpointInitializeArgs
|
typedefstruct otTcpEndpointInitializeArgs
Esta estructura contiene argumentos para la función otTcpEndpointInicia(). |
otTcpEstablished)(otTcpEndpoint *aEndpoint)
|
typedefvoid(*
Esta devolución de llamada informa a la aplicación que el protocolo de enlace TCP de 3 vías está completo y que ya se estableció 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 entrantes. |
otTcpListener
|
typedefstruct otTcpListener
|
otTcpListenerInitializeArgs
|
typedefstruct otTcpListenerInitializeArgs
Esta estructura contiene argumentos para la función otTcpListenerInitial(). |
otTcpReceiveAvailable)(otTcpEndpoint *aEndpoint, size_t aBytesAvailable, bool aEndOfStream, size_t aBytesRemaining)
|
typedefvoid(*
Esta devolución de llamada indica la cantidad de bytes disponibles para el consumo desde el búfer de recepción. |
otTcpSendDone)(otTcpEndpoint *aEndpoint, otLinkedBuffer *aData)
|
typedefvoid(*
Esta devolución de llamada informa a la aplicación que los datos del aData proporcionado son reconocidos por el par de conexión y que la aplicación puede reclamar aData y los datos que contiene. |
Funciones |
|
---|---|
otTcpAbort(otTcpEndpoint *aEndpoint)
|
Fuerza la conexión TCP asociada con este extremo 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 de TCP que la aplicación terminó de procesar
aNumBytes bytes de datos al comienzo del búfer de recepción y que no necesita seguir 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 asociado con
aEndpoint después de la inicialización. |
otTcpEndpointGetInstance(otTcpEndpoint *aEndpoint)
|
Obtiene la otInstance que se asoció con
aEndpoint en la inicialización. |
otTcpEndpointInitialize(otInstance *aInstance, otTcpEndpoint *aEndpoint, const otTcpEndpointInitializeArgs *aArgs)
|
Inicializa un extremo de TCP.
|
otTcpGetLocalAddress(const otTcpEndpoint *aEndpoint)
|
const otSockAddr *
Obtiene un puntero para el host y el puerto local de un extremo TCP.
|
otTcpGetPeerAddress(const otTcpEndpoint *aEndpoint)
|
const otSockAddr *
Obtiene un puntero al host y al puerto de un extremo del par de TCP.
|
otTcpListen(otTcpListener *aListener, const otSockAddr *aSockName)
|
Hace que las conexiones TCP entrantes coincidan con la dirección IP y el puerto especificados para activar las devoluciones de llamada de este objeto de escucha de TCP.
|
otTcpListenerDeinitialize(otTcpListener *aListener)
|
Anula la inicialización de este objeto de escucha de TCP.
|
otTcpListenerGetContext(otTcpListener *aListener)
|
void *
Obtiene el puntero de contexto asociado con
aListener después de la inicialización. |
otTcpListenerGetInstance(otTcpListener *aListener)
|
Obtiene la otInstance que se asoció con
aListener en la inicialización. |
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 que hace referencia a datos que se encuentran actualmente en el búfer de recepción de 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 por la cantidad especificada.
|
otTcpSendByReference(otTcpEndpoint *aEndpoint, otLinkedBuffer *aBuffer, uint32_t aFlags)
|
Agrega al búfer de envío los datos a los que hace referencia el búfer vinculado al que hace referencia
aBuffer . |
otTcpSendEndOfStream(otTcpEndpoint *aEndpoint)
|
Informa a la app de intercambio de tráfico 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 |
Una estructura de búfer vinculada para usar con TCP |
otTcpEndpoint |
Esta estructura representa un extremo de TCP. |
otTcpEndpointIniciaArgs |
Esta estructura contiene argumentos para la función otTcpEndpointInicia(). |
otTcpListener |
Esta estructura representa un objeto de escucha de TCP. |
otTcpListenerInitialArgs |
Esta estructura contiene argumentos para la función otTcpListenerInitial(). |
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
.
Motivo de desconexión de otTcp
otTcpDisconnectedReason
otTcpIncomingConnectionAction
otTcpIncomingConnectionAction
Esta enumeración define las acciones de conexión entrantes.
Se usa en la devolución de llamada otTcpAcceptReady().
Propiedades | |
---|---|
OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT
|
Acepta la conexión entrante. |
OT_TCP_INCOMING_CONNECTION_ACTION_DEFER
|
Aplaza (ignora en silencio) la conexión entrante. |
OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE
|
Rechaza la conexión entrante. |
Typedefs
otLinkedBuffer
struct otLinkedBuffer otLinkedBuffer
Una estructura de búfer vinculada para usar con TCP
Una sola estructura otLinkedBuffer hace referencia a un array 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 la apertura rápida de TCP, esto puede ocurrir antes de que el protocolo de enlace de conexión TCP se complete. La aplicación se proporciona con los punteros de contexto para el objeto de escucha de TCP que aceptó la conexión y el extremo de TCP en el que se aceptó. El contexto proporcionado es el 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 de TCP.
La respuesta típica es que la aplicación acepte la conexión entrante. Para ello, propaga aAcceptInto
con un puntero al otTcpEndpoint al que se aceptará la conexión entrante. Este otTcpEndpoint ya se debe inicializar con otTcpEndpointInicia(). Luego, la aplicación muestra OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT.
Como alternativa, la aplicación puede rechazar la aceptación de la conexión entrante. La aplicación puede hacer esto de dos maneras. Primero, si la aplicación muestra OT_TCP_INCOMING_CONNECTION_ACTION_DEFER, OpenThread ignora de forma automática la solicitud de establecimiento de conexión. Es probable que el par de conexiones vuelva a transmitir la solicitud, momento en el que se llamará nuevamente a la devolución de llamada. Esto es valioso si, en la actualidad, los recursos no están disponibles para aceptar la conexión, pero pueden estar disponibles cuando el par de conexiones retransmite su intento de establecer 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 propagues aAcceptInto
.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Qué muestra |
Descripción de cómo controlar la conexión entrante.
|
oTTcpDesconectado
void(* otTcpDisconnected)(otTcpEndpoint *aEndpoint, otTcpDisconnectedReason aReason)
Esta devolución de llamada indica que la conexión se interrumpió y no debe usarse más, o que una conexión entró en el estado TIME-WAIT.
Puede ocurrir si falla un intento de establecimiento de conexión (que se inicia llamando a otTcpConnect()) o después de ese momento (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 reclamar 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 de TCP ni el espacio para los búferes de recepción). En el caso de una conexión que entra en el estado TIME-WAIT, se llama a esta devolución de llamada 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 TIME-WAIT (con OT_TCP_DISCONNECTED_REASON_NORMAL).
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
Motivo de desconexión de otTcp
enum otTcpDisconnectedReason otTcpDisconnectedReason
otTcpEndpoint
struct otTcpEndpoint otTcpEndpoint
otTcpEndpointIniciaArgs
struct otTcpEndpointInitializeArgs otTcpEndpointInitializeArgs
Esta estructura contiene argumentos para la función otTcpEndpointInicia().
otTcpEstablished
void(* otTcpEstablished)(otTcpEndpoint *aEndpoint)
Esta devolución de llamada informa a la aplicación que el protocolo de enlace TCP de 3 vías está completo y que ya se estableció 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 la operación correcta de TCP. La mayoría de las aplicaciones solo pueden depender de la devolución de llamada otTcpSendDone() para recuperar los búferes vinculados una vez que la pila de TCP termina de usarse. El propósito de esta devolución de llamada es admitir aplicaciones avanzadas que se beneficien de información más detallada sobre cómo la conexión avanza en la transferencia de datos al par de conexión.
La operación de esta devolución de llamada está estrechamente relacionada con el búfer de envío de TCP. Se puede entender que el búfer de envío tiene dos regiones. En primer lugar, se encuentra la región "en vuelo" en curso en el encabezado (frente) del búfer de envío. Corresponde a los datos que se enviaron al destinatario, pero que aún no se confirmaron. En segundo lugar, está la región de “Tareas pendientes”, que consta de todos los datos en el búfer de envío que no están en la región “en tránsito”. La región de “Tareas 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, la región “en tránsito” del búfer de envío puede reducirse (p.ej., cuando el destinatario reconoce los datos que enviamos anteriormente). En segundo lugar, la región de “Tareas pendientes” del búfer de envío puede reducirse (p.ej., se enviaron datos nuevos). Estas dos condiciones a menudo ocurren 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
en la parte final del búfer de envío; cuando aInSendBuffer
disminuye en una cantidad x, significa que x bytes adicionales que antes estaban a la cabeza 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í misma 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 resume otTcpSendDone(), en el siguiente sentido: las aplicaciones pueden determinar cuándo se pueden reclamar los búferes vinculados si se compara aInSendBuffer
con la cantidad de bytes en cada búfer vinculado. Sin embargo, esperamos que otTcpSendDone(), que transmite directamente qué otLinkedBuffers se puede reclamar, sea mucho más simple de usar. Si las dos devoluciones de llamada están registradas y se activan con el mismo evento (p.ej., si se recibe el mismo segmento ACK), primero se activará la devolución de llamada otTcpSendDone() y, luego, esta devolución de llamada.
Además, esta devolución de llamada proporciona aBacklog
, que indica cuántos bytes de datos aún están en tránsito. En el caso de las aplicaciones que solo desean agregar datos al búfer de envío cuando hay la certeza de que se enviarán pronto, tal vez sea conveniente enviar datos únicamente cuando el valor de aBacklog
sea adecuado (0 o cercano a 0). Por ejemplo, una aplicación puede usar aBacklog
para que pueda reaccionar a la acumulación de cola mediante la eliminación o agregación de datos a fin de evitar la creación de una acumulación de datos.
Después de una llamada a otTcpSendByReference() o 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 se agreguen los bytes al búfer de envío (si algunos de esos bytes se envían inmediatamente, lo que reduce el trabajo pendiente), o en algún momento en el futuro (una vez que la conexión envía algunos o todos los datos, lo que reduce el trabajo pendiente). Cuando hablamos de "inmediato", nos referimos a que la devolución de llamada se programa de inmediato para ejecutarse en un tasklet. Para evitar la complejidad relacionada con la reinvención, nunca se llama directamente a la devolución de llamada otTcpForwardProgress() desde las funciones otTcpSendByReference() u otTcpSendByExtension().
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
otTcpIncomingConnectionAction
enum otTcpIncomingConnectionAction otTcpIncomingConnectionAction
Esta enumeración define las acciones de conexión entrantes.
Se usa en la devolución de llamada otTcpAcceptReady().
otTcpListener
struct otTcpListener otTcpListener
otTcpListenerInitialArgs.
struct otTcpListenerInitializeArgs otTcpListenerInitializeArgs
Esta estructura contiene argumentos para la función otTcpListenerInitial().
otTcpReceiveAvailable
void(* otTcpReceiveAvailable)(otTcpEndpoint *aEndpoint, size_t aBytesAvailable, bool aEndOfStream, size_t aBytesRemaining)
Esta devolución de llamada indica la cantidad de bytes disponibles para el consumo desde el 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 alcanzó el final de la transmisión (es decir, si no habrá más datos disponibles porque el par de conexiones cerró el final de la conexión para escribir), 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 los datos del aData
proporcionado son reconocidos por el par de conexión y que la aplicación puede reclamar 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 realizadas a través de otTcpSendByExtension().
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
Funciones
ottcpAbort
otError otTcpAbort( otTcpEndpoint *aEndpoint )
Fuerza la conexión TCP asociada con este extremo TCP.
Esto hace que el extremo de TCP sea inmediatamente 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 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 de TCP para el búfer de recepción permanecen asociadas con el extremo de 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 de TCP que la aplicación terminó de procesar aNumBytes
bytes de datos al comienzo del búfer de recepción y que no necesita seguir manteniendo esos bytes en el búfer de recepción.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Valores que se muestran |
|
OTTConnect
otError otTcpConnect( otTcpEndpoint *aEndpoint, const otSockAddr *aSockName, uint32_t aFlags )
Registra el host remoto y el puerto para esta conexión.
El emisor debe esperar la devolución de llamada otTcpEstablished
que indica que el protocolo de enlace de establecimiento de conexión TCP se completó antes de que pueda comenzar a enviar datos, p.ej., llamar a otTcpSendByReference()
.
Aún no se admite la Apertura rápida de TCP y se ignora aFlags
.
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 asignó internamente para este extremo de TCP. La aplicación puede volver a usar la memoria que respalda el extremo de TCP como estime conveniente.
Si corresponde a una conexión TCP activa, la conexión se finaliza de forma discreta (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, memoria para el búfer de recepción, la estructura aEndpoint
en sí, etc.) se muestran inmediatamente a la aplicación.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
otTcpEndpointGetContext.
void * otTcpEndpointGetContext( otTcpEndpoint *aEndpoint )
Obtiene el puntero de contexto asociado con aEndpoint
después 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
en la inicialización.
Detalles | |||
---|---|---|---|
Parámetros |
|
||
Qué muestra |
El puntero otInstance asociado con
aEndpoint . |
otTcpEndpointInicializa
otError otTcpEndpointInitialize( otInstance *aInstance, otTcpEndpoint *aEndpoint, const otTcpEndpointInitializeArgs *aArgs )
Inicializa un extremo de TCP.
Llamar a esta función hace que OpenThread realice un seguimiento del extremo de TCP y almacene y recupere 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 de respaldo aEndpoint
, debe llamar a otTcpEndpointDeinitialize().
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Valores que se muestran |
|
otTcpGetLocalAddress
const otSockAddr * otTcpGetLocalAddress( const otTcpEndpoint *aEndpoint )
Obtiene un puntero para el host y el puerto local de un extremo TCP.
El contenido del host y el puerto puede estar inactivo si este socket no está en un estado conectado y no se vinculó después de su ú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 al host y al puerto de un extremo del par de TCP.
El contenido del host y el puerto puede quedar inactivo si este socket no está en un estado conectado.
Detalles | |||
---|---|---|---|
Parámetros |
|
||
Qué muestra |
El host y el puerto del intercambio de tráfico de conexión de
aEndpoint . |
OtTcpEscuchar
otError otTcpListen( otTcpListener *aListener, const otSockAddr *aSockName )
Hace que las conexiones TCP entrantes coincidan con la dirección IP y el puerto especificados para activar las devoluciones de llamada de este objeto de escucha de 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 de TCP y desasigna todos los recursos que asignó internamente para este objeto de escucha de TCP. La aplicación puede volver a usar la memoria que respalda al objeto de escucha de TCP según su criterio.
Si el objeto de escucha de TCP está escuchando, dejará de hacerlo.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Valores que se muestran |
|
otTcpListenerGetContext
void * otTcpListenerGetContext( otTcpListener *aListener )
Obtiene el puntero de contexto asociado con aListener
después 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
en la inicialización.
Detalles | |||
---|---|---|---|
Parámetros |
|
||
Qué muestra |
El puntero otInstance asociado con
aListener . |
otTcpListenerInitial
otError otTcpListenerInitialize( otInstance *aInstance, otTcpListener *aListener, const otTcpListenerInitializeArgs *aArgs )
Inicializa un objeto de escucha de TCP.
Llamar a esta función hace que OpenThread realice un seguimiento del objeto de escucha de TCP y almacene y recupere 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 de respaldo aListener
, 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 que hace referencia a datos que se encuentran actualmente en el búfer de recepción de TCP.
La cadena de búfer vinculada es válida hasta que se invoque la devolución de llamada "recibida lista" o hasta la próxima llamada a otTcpReceiveContiguify() o 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 desviar la cadena de búfer vinculada que se obtuvo llamando a otTcpReceiveByReference
. Algunas aplicaciones pueden 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 a costa del tiempo de 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 por 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 al búfer de envío los datos a los que hace referencia el búfer vinculado al que hace referencia aBuffer
.
Cuando una llamada se realiza correctamente a esta función, la pila de TCP es propietaria del búfer y de los datos a los que hace referencia. La aplicación no debe modificarlos hasta que la devolución de llamada "send done" 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 no se activó la devolución de llamada "send done" de una invocación previa de esta función.
Ten en cuenta que aBuffer
no debe encadenarse, y su campo mNext debe ser NULO. Si se agregan datos adicionales inmediatamente 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 a la app de intercambio de tráfico 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 en el par de conexiones generarán la condición “fin del flujo”, y las escrituras futuras en este extremo de conexión fallarán.
La condición “fin del flujo” solo se aplica una vez 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 |
|
otTcpStopEscuchar
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
PO_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 de modo 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.
PO_TCP_LISTENER_TCB_NUM_PTR
OT_TCP_LISTENER_TCB_NUM_PTR 3
OP_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 de modo 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 es opaco 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 aproximadamente 3 saltos de línea o menos.
En plataformas en las que la memoria tiene restricciones específicas y en situaciones en las que no se necesita un ancho de banda alto, puede ser conveniente 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 atraviesan muchos saltos inalámbricos.
Si la conexión TCP desvía una gran cantidad de saltos (más de 6 o más), es recomendable seleccionar un tamaño de búfer más grande de forma manual.
Recursos
Los temas de referencia de la API de OpenThread se originan a partir del código fuente, disponible en GitHub. Para obtener más información o colaborar con nuestra documentación, consulta la sección Recursos.