TCP
Esse módulo inclui funções que controlam a comunicação TCP.
Resumo
Enumerações |
|
---|---|
anonymous enum
|
enum Define as sinalizações transmitidas para otTcpConnect(). |
anonymous enum
|
enum Define as sinalizações transmitidas para o otTcpSendByReference . |
otTcpDisconnectedReason
|
enum |
otTcpIncomingConnectionAction{
|
enum Define as ações de conexão de entrada. |
Typedefs |
|
---|---|
otLinkedBuffer
|
typedefstruct otLinkedBuffer
Uma estrutura de buffer vinculada para uso com TCP. |
otTcpAcceptDone)(otTcpListener *aListener, otTcpEndpoint *aEndpoint, const otSockAddr *aPeer)
|
typedefvoid(*
Esse callback indica que a conexão TCP está pronta para comunicação bidirecional. |
otTcpAcceptReady)(otTcpListener *aListener, const otSockAddr *aPeer, otTcpEndpoint **aAcceptInto)
|
typedef Esse callback indica que uma conexão de entrada que corresponde a esse listener TCP chegou. |
otTcpDisconnected)(otTcpEndpoint *aEndpoint, otTcpDisconnectedReason aReason)
|
typedefvoid(*
Esse callback indica que a conexão foi interrompida e não precisa mais ser usada ou que uma conexão entrou no estado TIME-WAIT. |
otTcpDisconnectedReason
|
typedefenum otTcpDisconnectedReason
|
otTcpEndpoint
|
typedefstruct otTcpEndpoint
|
otTcpEndpointInitializeArgs
|
typedefstruct otTcpEndpointInitializeArgs
Contém argumentos para a função otTcpEndpointInitialize(). |
otTcpEstablished)(otTcpEndpoint *aEndpoint)
|
typedefvoid(*
Esse callback informa ao aplicativo que o handshake de três vias do TCP foi concluído e que a conexão foi estabelecida. |
otTcpForwardProgress)(otTcpEndpoint *aEndpoint, size_t aInSendBuffer, size_t aBacklog)
|
typedefvoid(*
Esse callback informa ao aplicativo se houve progresso na transferência de dados do buffer de envio para o destinatário. |
otTcpIncomingConnectionAction
|
typedef Define as ações de conexão de entrada. |
otTcpListener
|
typedefstruct otTcpListener
|
otTcpListenerInitializeArgs
|
typedefstruct otTcpListenerInitializeArgs
Contém argumentos para a função otTcpListenerInitialize(). |
otTcpReceiveAvailable)(otTcpEndpoint *aEndpoint, size_t aBytesAvailable, bool aEndOfStream, size_t aBytesRemaining)
|
typedefvoid(*
Esse callback indica o número de bytes disponíveis para consumo do buffer de recebimento. |
otTcpSendDone)(otTcpEndpoint *aEndpoint, otLinkedBuffer *aData)
|
typedefvoid(*
Esse callback informa ao aplicativo que os dados no aData fornecido foram confirmados pelo peering da conexão e que o aData e os dados que ele contém podem ser recuperados pelo aplicativo. |
remotas |
|
---|---|
otTcpAbort(otTcpEndpoint *aEndpoint)
|
Encerra à força a conexão TCP associada a este endpoint TCP.
|
otTcpBind(otTcpEndpoint *aEndpoint, const otSockAddr *aSockName)
|
Vincula o endpoint TCP a um endereço IP e uma porta.
|
otTcpCommitReceive(otTcpEndpoint *aEndpoint, size_t aNumBytes, uint32_t aFlags)
|
Informa à pilha TCP que o aplicativo terminou de processar
aNumBytes bytes de dados no início do buffer de recebimento e que a pilha TCP não precisa continuar mantendo esses bytes no buffer de recebimento. |
otTcpConnect(otTcpEndpoint *aEndpoint, const otSockAddr *aSockName, uint32_t aFlags)
|
Registra o host remoto e a porta para esta conexão.
|
otTcpEndpointDeinitialize(otTcpEndpoint *aEndpoint)
|
Desinicializa este endpoint TCP.
|
otTcpEndpointGetContext(otTcpEndpoint *aEndpoint)
|
void *
Extrai o ponteiro de contexto que foi associado ao
aEndpoint na inicialização. |
otTcpEndpointGetInstance(otTcpEndpoint *aEndpoint)
|
Recebe a otInstance que foi associada ao
aEndpoint na inicialização. |
otTcpEndpointInitialize(otInstance *aInstance, otTcpEndpoint *aEndpoint, const otTcpEndpointInitializeArgs *aArgs)
|
Inicializa um endpoint TCP.
|
otTcpGetLocalAddress(const otTcpEndpoint *aEndpoint)
|
const otSockAddr *
Recebe um ponteiro para o host local e a porta de um endpoint TCP.
|
otTcpGetPeerAddress(const otTcpEndpoint *aEndpoint)
|
const otSockAddr *
Recebe um ponteiro para o host e a porta do peering de um endpoint TCP.
|
otTcpListen(otTcpListener *aListener, const otSockAddr *aSockName)
|
Faz com que as conexões TCP de entrada que correspondem à porta e ao endereço IP especificados acionem os callbacks deste listener TCP.
|
otTcpListenerDeinitialize(otTcpListener *aListener)
|
Desinicializa esse listener TCP.
|
otTcpListenerGetContext(otTcpListener *aListener)
|
void *
Extrai o ponteiro de contexto que foi associado ao
aListener na inicialização. |
otTcpListenerGetInstance(otTcpListener *aListener)
|
Recebe a otInstance que foi associada ao
aListener na inicialização. |
otTcpListenerInitialize(otInstance *aInstance, otTcpListener *aListener, const otTcpListenerInitializeArgs *aArgs)
|
Inicializa um listener TCP.
|
otTcpReceiveByReference(otTcpEndpoint *aEndpoint, const otLinkedBuffer **aBuffer)
|
Fornece ao aplicativo uma cadeia de buffer vinculada que faz referência aos dados atualmente no buffer de recebimento do TCP.
|
otTcpReceiveContiguify(otTcpEndpoint *aEndpoint)
|
Reorganiza o buffer de recebimento para que ele fique totalmente contíguo na memória.
|
otTcpSendByExtension(otTcpEndpoint *aEndpoint, size_t aNumBytes, uint32_t aFlags)
|
Adiciona dados ao buffer de envio estendendo o comprimento do otLinkedBuffer final pelo valor especificado.
|
otTcpSendByReference(otTcpEndpoint *aEndpoint, otLinkedBuffer *aBuffer, uint32_t aFlags)
|
Adiciona dados referenciados pelo buffer vinculado apontado por
aBuffer ao buffer de envio. |
otTcpSendEndOfStream(otTcpEndpoint *aEndpoint)
|
Informa ao peering de conexão que esse endpoint TCP não vai enviar mais dados.
|
otTcpStopListening(otTcpListener *aListener)
|
Faz com que este listener TCP pare de detectar conexões de entrada.
|
Estruturas |
|
---|---|
otLinkedBuffer |
Uma estrutura de buffer vinculada para uso com TCP. |
otTcpEndpoint |
Representa um endpoint TCP. |
otTcpEndpointInitializeArgs |
Contém argumentos para a função otTcpEndpointInitialize(). |
otTcpListener |
Representa um listener TCP. |
otTcpListenerInitializeArgs |
Contém argumentos para a função otTcpListenerInitialize(). |
Enumerações
enumeração anônima
anonymous enum
Define as sinalizações transmitidas para o otTcpSendByReference
.
otTcpDisconnectedReason
otTcpDisconnectedReason
otTcpIncomingConnectionAction
otTcpIncomingConnectionAction
Define as ações de conexão de entrada.
Isso é usado no callback otTcpAcceptReady().
Propriedades | |
---|---|
OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT
|
Aceite a conexão de entrada. |
OT_TCP_INCOMING_CONNECTION_ACTION_DEFER
|
Adiar (ignorar silenciosamente) a conexão de entrada. |
OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE
|
Recusar a conexão de entrada. |
Typedefs
otLinkedBuffer
struct otLinkedBuffer otLinkedBuffer
Uma estrutura de buffer vinculada para uso com TCP.
Uma única estrutura otLinkedBuffer faz referência a uma matriz de bytes na memória usando mData e mLength. O campo "mNext" é usado para formar uma cadeia de estruturas otLinkedBuffer.
otTcpAcceptDone
void(* otTcpAcceptDone)(otTcpListener *aListener, otTcpEndpoint *aEndpoint, const otSockAddr *aPeer)
Esse callback indica que a conexão TCP está pronta para comunicação bidirecional.
No caso de TCP Fast Open, isso pode ocorrer antes da conclusão do handshake de conexão TCP. O aplicativo recebe os ponteiros de contexto tanto para o listener TCP que aceitou a conexão quanto para o endpoint TCP em que ela foi aceita. O contexto fornecido é aquele associado ao listener TCP.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
otTcpAcceptReady
otTcpIncomingConnectionAction(* otTcpAcceptReady)(otTcpListener *aListener, const otSockAddr *aPeer, otTcpEndpoint **aAcceptInto)
Esse callback indica que uma conexão de entrada que corresponde a esse listener TCP chegou.
A resposta típica é que o aplicativo aceite a conexão de entrada. Isso é feito preenchendo aAcceptInto
com um ponteiro para o otTcpEndpoint, em que a conexão de entrada será aceita. Esse otTcpEndpoint já precisa ser inicializado usando otTcpEndpointInitialize(). Em seguida, o aplicativo retorna OT_TCP_INCOMING_CONNECTION_ACTION_ Accept.
Como alternativa, o aplicativo pode se recusar a aceitar a conexão de entrada. O aplicativo pode fazer isso de duas maneiras. Primeiro, se o aplicativo retornar OT_TCP_INCOMING_CONNECTION_ACTION_DEFER, o OpenThread ignorará silenciosamente a solicitação de estabelecimento da conexão. O ponto de conexão provavelmente retransmitirá a solicitação e, nesse ponto, o callback será chamado novamente. Isso é valioso se os recursos não estiverem disponíveis no momento para aceitar a conexão, mas podem estar disponíveis quando o ponto de conexão retransmite a tentativa de estabelecimento da conexão. Em segundo lugar, se o aplicativo retornar OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE, o OpenThread enviará uma mensagem de "conexão recusada" para o host que tentou estabelecer uma conexão. Se o aplicativo recusar a conexão de entrada, ele não será necessário preencher aAcceptInto
.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Retorna |
Descrição de como lidar com a conexão de entrada.
|
otTcpDisconnected
void(* otTcpDisconnected)(otTcpEndpoint *aEndpoint, otTcpDisconnectedReason aReason)
Esse callback indica que a conexão foi interrompida e não precisa mais ser usada ou que uma conexão entrou no estado TIME-WAIT.
Ela pode ocorrer se uma tentativa de estabelecimento de conexão (iniciada chamando otTcpConnect()) falhar ou em qualquer ponto depois disso (por exemplo, se o tempo limite da conexão se esgotar ou se um segmento RST for recebido do peering de conexão). Quando esse callback for acionado, todos os recursos fornecidos pelo aplicativo para essa conexão (ou seja, qualquer otLinkedBuffers
e memória referenciadas, mas não o próprio endpoint TCP ou o espaço para os buffers de recebimento) poderão ser recuperados. No caso de uma conexão entrar no estado TIME-WAIT, esse callback é chamado duas vezes: uma vez quando entra no estado TIME-WAIT (com OT_TCP_DISCONNECTED_REASON_TIME_WAIT e novamente quando o estado TIME-WAIT expira (com OT_TCP_DISCONNECTED_REASON_NORMAL).
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
otTcpDisconnectedReason
enum otTcpDisconnectedReason otTcpDisconnectedReason
otTcpEndpoint
struct otTcpEndpoint otTcpEndpoint
otTcpEndpointInitializeArgs
struct otTcpEndpointInitializeArgs otTcpEndpointInitializeArgs
Contém argumentos para a função otTcpEndpointInitialize().
otTcpEstablished
void(* otTcpEstablished)(otTcpEndpoint *aEndpoint)
Esse callback informa ao aplicativo que o handshake de três vias do TCP foi concluído e que a conexão foi estabelecida.
Detalhes | |||
---|---|---|---|
Parâmetros |
|
otTcpForwardProgress
void(* otTcpForwardProgress)(otTcpEndpoint *aEndpoint, size_t aInSendBuffer, size_t aBacklog)
Esse callback informa ao aplicativo se houve progresso na transferência de dados do buffer de envio para o destinatário.
Esse callback não é necessário para a operação TCP correta. A maioria dos aplicativos pode confiar apenas no callback otTcpSendDone() para recuperar os buffers vinculados quando a pilha TCP termina de usá-los. O objetivo desse callback é oferecer suporte a aplicativos avançados que se beneficiam de informações mais refinadas sobre como a conexão está progredindo na transferência de dados para o peering de conexão.
A operação desse callback está intimamente ligada ao buffer de envio do TCP. O buffer de envio pode ser entendido como tendo duas regiões. Primeiro, há a região "em trânsito" no cabeçalho (à frente) do buffer de envio. Ele corresponde a dados que foram enviados ao destinatário, mas ainda não foram confirmados. Em segundo lugar, há a região "backlog", que consiste em todos os dados no buffer de envio que não estão na região "em trânsito". A região "backlog" corresponde aos dados que estão na fila para envio, mas ainda não foram enviados.
O callback é invocado em resposta a dois tipos de eventos. Primeiro, a região "em trânsito" do buffer de envio pode diminuir (por exemplo, quando o destinatário confirma os dados que enviamos anteriormente). Em segundo lugar, a região do "backlog" do buffer de envio pode diminuir (por exemplo, novos dados foram enviados). Essas duas condições geralmente ocorrem ao mesmo tempo, em resposta a um segmento ACK do ponto de conexão, e é por isso que elas são combinadas em um único callback.
A pilha TCP usa apenas os bytes aInSendBuffer
na cauda do buffer de envio. Quando aInSendBuffer
diminui em um valor x, isso significa que x bytes adicionais que estavam anteriormente no cabeçalho do buffer de envio não fazem mais parte do buffer de envio e agora podem ser recuperados (ou seja, substituídos) pelo aplicativo. A estrutura otLinkedBuffer só pode ser recuperada quando todos os bytes aos quais ela faz referência não fizerem mais parte do buffer de envio.
Esse callback inclui otTcpSendDone() no seguinte sentido: os aplicativos podem determinar quando os buffers vinculados podem ser recuperados ao comparar aInSendBuffer
com a quantidade de bytes em cada buffer vinculado. No entanto, esperamos que otTcpSendDone(), que transmite diretamente quais otLinkedBuffers possam ser recuperados, seja muito mais simples de usar. Se os dois callbacks forem registrados e acionados pelo mesmo evento (por exemplo, o mesmo segmento ACK recebido), o callback otTcpSendDone() será acionado primeiro, seguido por esse callback.
Além disso, esse callback fornece aBacklog
, que indica quantos bytes de dados no buffer de envio ainda não estão em trânsito. Para aplicativos que só querem adicionar dados ao buffer de envio quando há uma garantia de que eles serão enviados em breve, pode ser desejável enviar dados apenas quando aBacklog
for adequadamente pequeno (0 ou próximo de 0). Por exemplo, um aplicativo pode usar aBacklog
para reagir ao acúmulo de fila descartando ou agregando dados para evitar a criação de um backlog.
Após uma chamada para otTcpSendByReference() ou otTcpSendByExtension() com um número positivo de bytes, o callback otTcpForwardProgress() garante que ele será chamado para indicar quando os bytes adicionados ao buffer de envio forem enviados. A chamada para otTcpForwardProgress() pode ser feita imediatamente após a adição dos bytes ao buffer de envio (se alguns desses bytes forem enviados imediatamente, reduzindo o backlog) ou em algum momento no futuro (quando a conexão enviar alguns ou todos os dados, reduzindo o backlog). Por "imediatamente", queremos dizer que o callback é imediatamente programado para execução em um tasklet. Para evitar a complexidade relacionada à reentração, o callback otTcpForwardProgress() nunca é chamado diretamente das funções otTcpSendByReference() ou otTcpSendByExtension().
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
otTcpIncomingConnectionAction
enum otTcpIncomingConnectionAction otTcpIncomingConnectionAction
Define as ações de conexão de entrada.
Isso é usado no callback otTcpAcceptReady().
otTcpListener
struct otTcpListener otTcpListener
otTcpListenerInitializeArgs
struct otTcpListenerInitializeArgs otTcpListenerInitializeArgs
Contém argumentos para a função otTcpListenerInitialize().
otTcpReceiveAvailable
void(* otTcpReceiveAvailable)(otTcpEndpoint *aEndpoint, size_t aBytesAvailable, bool aEndOfStream, size_t aBytesRemaining)
Esse callback indica o número de bytes disponíveis para consumo do buffer de recebimento.
Ele é chamado sempre que bytes são adicionados ao buffer de recebimento e quando o fim do stream é alcançado. Se o fim do stream tiver sido alcançado, ou seja, se não houver mais dados disponíveis para leitura porque o peering fechou a conexão para gravação, aEndOfStream
será verdadeiro. Por fim, aBytesRemaining
indica a capacidade restante no buffer de recebimento para armazenar outros dados que chegam.
Detalhes | |||||||||
---|---|---|---|---|---|---|---|---|---|
Parâmetros |
|
otTcpSendDone
void(* otTcpSendDone)(otTcpEndpoint *aEndpoint, otLinkedBuffer *aData)
Esse callback informa ao aplicativo que os dados no aData
fornecido foram confirmados pelo peering da conexão e que o aData
e os dados que ele contém podem ser recuperados pelo aplicativo.
Os aData
são idênticos aos transmitidos para o TCP via otTcpSendByReference(), incluindo quaisquer extensões aplicadas por otTcpSendByExtension().
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
remotas
otTcpAbort
otError otTcpAbort( otTcpEndpoint *aEndpoint )
Encerra à força a conexão TCP associada a este endpoint TCP.
Isso imediatamente libera o endpoint TCP para uso em outra conexão e esvazia os buffers de envio e recebimento, transferindo a propriedade de quaisquer dados fornecidos pelo aplicativo em chamadas otTcpSendByReference() e otTcpSendByExtension() de volta para o aplicativo. Os callbacks e a memória do endpoint TCP permanecem associados ao endpoint TCP para o buffer de recebimento.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Valores de retorno |
|
otTcpBind
otError otTcpBind( otTcpEndpoint *aEndpoint, const otSockAddr *aSockName )
Vincula o endpoint TCP a um endereço IP e uma porta.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Valores de retorno |
|
otTcpCommitReceive
otError otTcpCommitReceive( otTcpEndpoint *aEndpoint, size_t aNumBytes, uint32_t aFlags )
Informa à pilha TCP que o aplicativo terminou de processar aNumBytes
bytes de dados no início do buffer de recebimento e que a pilha TCP não precisa continuar mantendo esses bytes no buffer de recebimento.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Valores de retorno |
|
otTcpConnect
otError otTcpConnect( otTcpEndpoint *aEndpoint, const otSockAddr *aSockName, uint32_t aFlags )
Registra o host remoto e a porta para esta conexão.
O TCP Fast Open precisa ser ativado ou desativado usando aFlags
. Se estiver desativada, o handshake de estabelecimento da conexão TCP será iniciado imediatamente. Se ela for ativada, essa função apenas registrará o host e a porta remotos, e o handshake de estabelecimento da conexão TCP só acontecerá na primeira chamada para otTcpSendByReference()
.
Se o TCP Fast Open estiver desativado, o autor da chamada precisará aguardar o callback otTcpEstablished
indicando que o handshake de estabelecimento da conexão TCP foi feito antes de começar a enviar dados, por exemplo, chamando otTcpSendByReference()
.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Valores de retorno |
|
otTcpEndpointDeinitialize
otError otTcpEndpointDeinitialize( otTcpEndpoint *aEndpoint )
Desinicializa este endpoint TCP.
Isso significa que o OpenThread não monitora mais esse endpoint TCP e desaloca todos os recursos alocados internamente para esse endpoint TCP. O aplicativo pode reutilizar a memória com suporte ao endpoint do TCP conforme necessário.
Se corresponder a uma conexão TCP ativa, a conexão será encerrada sem cerimônias (como em otTcpAbort()). Todos os recursos fornecidos pelo aplicativo para esse endpoint TCP (buffers de envio, memória para o buffer de recebimento, a própria estrutura aEndpoint
etc.) são imediatamente retornados ao aplicativo.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Valores de retorno |
|
otTcpEndpointGetContext
void * otTcpEndpointGetContext( otTcpEndpoint *aEndpoint )
Extrai o ponteiro de contexto que foi associado ao aEndpoint
na inicialização.
Detalhes | |||
---|---|---|---|
Parâmetros |
|
||
Retorna |
O ponteiro de contexto associado a
aEndpoint . |
otTcpEndpointGetInstance
otInstance * otTcpEndpointGetInstance( otTcpEndpoint *aEndpoint )
Recebe a otInstance que foi associada ao aEndpoint
na inicialização.
Detalhes | |||
---|---|---|---|
Parâmetros |
|
||
Retorna |
O ponteiro otInstance associado a
aEndpoint . |
otTcpEndpointInitialize
otError otTcpEndpointInitialize( otInstance *aInstance, otTcpEndpoint *aEndpoint, const otTcpEndpointInitializeArgs *aArgs )
Inicializa um endpoint TCP.
Chamar essa função faz com que o OpenThread monitore o endpoint TCP e armazene e recupere dados TCP dentro do aEndpoint
. O aplicativo precisa evitar acessar ou modificar diretamente os campos em aEndpoint
. Se o aplicativo precisar recuperar a memória de apoio aEndpoint
, ele precisará chamar otTcpEndpointDeinitialize().
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Valores de retorno |
|
otTcpGetLocalAddress
const otSockAddr * otTcpGetLocalAddress( const otTcpEndpoint *aEndpoint )
Recebe um ponteiro para o host local e a porta de um endpoint TCP.
O conteúdo do host e da porta poderá ficar desatualizado se o soquete não estiver conectado e não tiver sido vinculado após a última desconexão.
Detalhes | |||
---|---|---|---|
Parâmetros |
|
||
Retorna |
O host local e a porta de
aEndpoint . |
otTcpGetPeerAddress
const otSockAddr * otTcpGetPeerAddress( const otTcpEndpoint *aEndpoint )
Recebe um ponteiro para o host e a porta do peering de um endpoint TCP.
O conteúdo do host e da porta poderá ficar desatualizado se o soquete não estiver conectado.
Detalhes | |||
---|---|---|---|
Parâmetros |
|
||
Retorna |
O host e a porta do peering de conexão de
aEndpoint . |
otTcpListen
otError otTcpListen( otTcpListener *aListener, const otSockAddr *aSockName )
Faz com que as conexões TCP de entrada que correspondem à porta e ao endereço IP especificados acionem os callbacks deste listener TCP.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Valores de retorno |
|
otTcpListenerDeinitialize
otError otTcpListenerDeinitialize( otTcpListener *aListener )
Desinicializa esse listener TCP.
Isso significa que o OpenThread não monitora mais esse listener TCP e desaloca todos os recursos alocados internamente para esse listener TCP. O aplicativo pode reutilizar a memória que dá suporte ao listener TCP como achar melhor.
Se o listener TCP estiver ouvindo no momento, ele para de detectar.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Valores de retorno |
|
otTcpListenerGetContext
void * otTcpListenerGetContext( otTcpListener *aListener )
Extrai o ponteiro de contexto que foi associado ao aListener
na inicialização.
Detalhes | |||
---|---|---|---|
Parâmetros |
|
||
Retorna |
O ponteiro de contexto associado a
aListener . |
otTcpListenerGetInstance
otInstance * otTcpListenerGetInstance( otTcpListener *aListener )
Recebe a otInstance que foi associada ao aListener
na inicialização.
Detalhes | |||
---|---|---|---|
Parâmetros |
|
||
Retorna |
O ponteiro otInstance associado a
aListener . |
otTcpListenerInitialize
otError otTcpListenerInitialize( otInstance *aInstance, otTcpListener *aListener, const otTcpListenerInitializeArgs *aArgs )
Inicializa um listener TCP.
Chamar essa função faz com que o OpenThread monitore o listener TCP e armazene e recupere dados TCP dentro de aListener
. O aplicativo precisa evitar acessar ou modificar diretamente os campos em aListener
. Se o aplicativo precisar recuperar a memória de apoio aListener
, ele precisará chamar otTcpListenerDeinitialize().
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Valores de retorno |
|
otTcpReceiveByReference
otError otTcpReceiveByReference( otTcpEndpoint *aEndpoint, const otLinkedBuffer **aBuffer )
Fornece ao aplicativo uma cadeia de buffer vinculada que faz referência aos dados atualmente no buffer de recebimento do TCP.
A cadeia de buffers vinculada é válida até que o callback "receive Ready" seja invocado ou até a próxima chamada para otTcpReceiveContiguify() ou otTcpCommitReceive().
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Valores de retorno |
|
otTcpReceiveContiguify
otError otTcpReceiveContiguify( otTcpEndpoint *aEndpoint )
Reorganiza o buffer de recebimento para que ele fique totalmente contíguo na memória.
Isso é opcional. Um aplicativo pode simplesmente percorrer a cadeia de buffers vinculada recebida chamando otTcpReceiveByReference
. Alguns aplicativos podem querer chamar essa função para tornar o buffer de recebimento contíguo a fim de simplificar o processamento de dados, mas isso prejudica o tempo de CPU para reorganizar os dados no buffer de recebimento.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Valores de retorno |
|
otTcpSendByExtension
otError otTcpSendByExtension( otTcpEndpoint *aEndpoint, size_t aNumBytes, uint32_t aFlags )
Adiciona dados ao buffer de envio estendendo o comprimento do otLinkedBuffer final pelo valor especificado.
Se o buffer de envio estiver vazio, a operação falhará.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Valores de retorno |
|
otTcpSendByReference
otError otTcpSendByReference( otTcpEndpoint *aEndpoint, otLinkedBuffer *aBuffer, uint32_t aFlags )
Adiciona dados referenciados pelo buffer vinculado apontado por aBuffer
ao buffer de envio.
Após uma chamada para essa função, o buffer vinculado e os dados aos quais ele faz referência são de propriedade da pilha TCP. Eles não devem ser modificados pelo aplicativo até que um callback de "envio concluído" retorne a propriedade desses objetos ao aplicativo. É aceitável chamar essa função para adicionar outro buffer vinculado à fila de envio, mesmo que o retorno de chamada "send concluído" de uma invocação anterior dessa função ainda não tenha sido disparado.
Observe que aBuffer
não pode ficar encadeado. O campo mNext dele precisa ser NULL. Se mais dados forem adicionados logo após essa chamada, a sinalização OT_TCP_SEND_MORE_TO_COME deve ser usada como uma dica para a implementação do TCP.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Valores de retorno |
|
otTcpSendEndOfStream
otError otTcpSendEndOfStream( otTcpEndpoint *aEndpoint )
Informa ao peering de conexão que esse endpoint TCP não vai enviar mais dados.
Use quando o aplicativo não tiver mais dados para enviar ao peering de conexão. Para essa conexão, leituras futuras no peering de conexão resultarão na condição "fim do stream", e gravações futuras nesse endpoint de conexão falharão.
A condição "fim do stream" só se aplica depois que os dados fornecidos anteriormente à pilha TCP para envio forem recebidos pelo peering de conexão.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Valores de retorno |
|
otTcpStopListening
otError otTcpStopListening( otTcpListener *aListener )
Faz com que este listener TCP pare de detectar conexões de entrada.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Valores de retorno |
|
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 392
OT_TCP_ENDPOINT_TCB_SIZE_BASE e OT_TCP_ENDPOINT_TCB_NUM_POINTERS são escolhidos de modo que o campo mTcb de otTcpEndpoint tenha o mesmo tamanho que struct tcpcb em TCPlp.
Isso é necessário porque o campo mTcb, embora opaco na declaração, é tratado como struct tcpcb na implementação do 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
OT_TCP_LISTENER_TCB_SIZE_BASE e OT_TCP_LISTENER_TCB_NUM_POINTERS são escolhidos de modo que o campo mTcbListener de otTcpListener tenha o mesmo tamanho de struct tcpcb_listen em TCPlp.
Isso é necessário porque o campo mTcb Listen, embora opaco na declaração, é tratado como struct tcpcb na implementação do TCP.
OT_TCP_RECEIVE_BUFFER_SIZE_FEW_HOPS
OT_TCP_RECEIVE_BUFFER_SIZE_FEW_HOPS 2598
Tamanho de buffer recomendado para conexões TCP que percorrem cerca de três saltos sem fio ou menos.
Em plataformas em que a memória é particularmente restrita e em situações em que uma alta largura de banda não é necessária, pode ser desejável selecionar manualmente um tamanho de buffer menor.
OT_TCP_RECEIVE_BUFFER_SIZE_MANY_HOPS
OT_TCP_RECEIVE_BUFFER_SIZE_MANY_HOPS 4157
Tamanho de buffer recomendado para conexões TCP que passam por muitos saltos sem fio.
Se a conexão TCP passar por um grande número de saltos (mais de seis ou mais), pode ser aconselhável selecionar manualmente um tamanho de buffer grande.
Recursos
Os tópicos de Referência da API OpenThread são originados do código-fonte, disponível no GitHub. Para mais informações ou para contribuir com nossa documentação, consulte Recursos.