microtcp
1.0.0
O MicroTCP é uma pilha de rede TCP/IP que comecei a construir como um exercício de aprendizado enquanto participava do curso de rede de computadores no Università degli Studi di Napoli Federico II. É apenas um projeto de hobby e pretende ser apenas uma implementação mínima, mas completa.
Nesse momento, o MicroTCP implementa ARP (RFC 826, completo), IPv4 (sem fragmentação), ICMP (mínimo necessário para responder aos pings) e TCP (completo, mas não testado por estresse). Observe que "completo" não deve ser destinado a "totalmente compatível", mas como uma medida de progresso em todos os principais recursos. Por exemplo, é completo o suficiente para lidar com o tráfego HTTP em uma rede local (procure exemplos/microhttp para saber mais).
O MicroTCP pode ser executado no Windows e Linux ao lado da pilha de rede do sistema operacional. Para rotear o tráfego de rede para o MicroTCP, o processo executando -o se comporta como um host virtual com seu próprio endereço IP. Isso é feito usando um dispositivo TAP, que vem embutido no Linux e precisa ser instalado no Windows. Deve ser muito fácil adaptar o MicroTCP para executar em microcontroladores, mas ainda não tentei. O sonho é servir meu blog em uma placa STM32!
Se você estiver no Windows, precisará instalar o driver da torneira fornecido pelo OpenVPN e instanciar uma NIC virtual para que o MicroTCP possa se conectar a ele quando iniciado. Para construir o projeto a partir da fonte, certifique -se de clonar o repositório com submódulos
git clone https://github.com/cozis/microtcp.git --recursivee depois corra
make Você precisará make e cmake para que funcione. Se tudo correr bem, você encontrará os arquivos da biblioteca libtuntap.a , libmicrotcp.a e arquivos de cabeçalho tuntap.h , tuntap-export.h , microtcp.h em out/ .
O MicroTCP usa a interface de soquete usual com a qual qualquer programador de rede está familiarizado, a principal diferença é que você precisa para instigar explicitamente a pilha de rede e passar sua alça.
Aqui está um servidor de eco simples que mostra o uso básico:
#include <microtcp.h>
int main ( void )
{
microtcp_t * mtcp = microtcp_create ( "10.0.0.5" , "10.0.0.4" , NULL , NULL );
if ( mtcp == NULL )
return -1 ; // Couldn't create MicroTCP instance
uint16_t port = 8081 ;
microtcp_socket_t * server = microtcp_open ( mtcp , port );
if ( server == NULL ) {
microtcp_destroy ( mtcp );
return -1 ;
}
while ( 1 ) {
microtcp_socket_t * client = microtcp_accept ( server );
if ( client == NULL )
break ;
char buffer [ 1024 ];
int num = microtcp_recv ( client , buffer , sizeof ( buffer ));
if ( num > 0 ) {
microtcp_send ( client , "echo: " , 6 );
microtcp_send ( client , buffer , num );
}
microtcp_close ( client );
}
microtcp_close ( server );
microtcp_destroy ( mtcp );
return 0 ;
} Isso deve ser bastante direto para entender. Uma coisa pode valer a pena notar é que microtcp_open se comporta como o socket+bind+listen de uma só vez para configurar um servidor TCP auditivo.
Há mais de uma maneira de configurar a pilha, a principal maneira de microtcp_create que cria uma parte de redes virtual no sistema operacional host com IP 10.0.0.5/24 e um host virtual para o processo MicroTCP em 10.0.0.4/24. Você pode abrir o Wireshark na NIC virtual para inspecionar o tráfego entre o host e o processo.
Também é possível configurar a pilha usando o microtcp_create_using_callbacks , o que permite fornecer explicitamente os quadros de entrada L2 e receber os quadros em um buffer. É assim que se configuraria a pilha para executar em um microcontrolador.
Cada instância do microtCP (sem considerar os retornos de chamada) é completamente isolada dos outros; portanto, se a sua implementação específica de retorno de chamada permitir, você poderá ter quantas instâncias quiser!
Ainda não há infractructure de teste. A maneira como estou testando é configurando um servidor HTTP ou Echo e estressando -o até que algo quebre enquanto captura o que aconteceu usando o Wireshark.
