microtcp
1.0.0
MicroTCP es una pila de red TCP/IP que comencé a construir como un ejercicio de aprendizaje mientras asistía al curso de redes de computadora en la Università degli Studi di Napoli Federico II. Es solo un proyecto de pasatiempo y está destinado a ser una implementación mínima, pero completa.
En este momento, MicroTCP implementa ARP (RFC 826, Complete), IPv4 (sin fragmentación), ICMP (mínimo necesario para responder a pings) y TCP (completo pero no probado por estrés). Tenga en cuenta que "Complete" no debe pretenderse como "totalmente compatible", sino como una medida de progreso en todas las características principales. Por ejemplo, es lo suficientemente completo como para manejar el tráfico HTTP en una red local (busque ejemplos/microhttp para saber más).
MicroTCP puede ejecutarse en Windows y Linux junto con la pila de red del sistema operativo. Para enrutar el tráfico de red a MicroTCP, el proceso que lo ejecuta se comporta como un host virtual con su propia dirección IP. Esto se realiza con un dispositivo TAP, que viene incorporado en Linux y debe instalarse en Windows. Debería ser muy fácil adaptar MicroTCP para ejecutarse en microcontroladores, pero aún no lo ha intentado. ¡El sueño es servir a mi blog de un tablero STM32!
Si está en Windows, debe instalar el controlador Tap proporcionado por OpenVPN e instanciar una NIC virtual para que MicroTCP pueda conectarse a él cuando se inicie. Para construir el proyecto desde la fuente, asegúrese de clonar el repositorio con submódulos
git clone https://github.com/cozis/microtcp.git --recursivey luego corre
make Necesitará make tanto y cmake para que funcione. Si todo va bien, encontrará los archivos de la biblioteca libtuntap.a , libmicrotcp.a y los archivos de encabezado tuntap.h , tuntap-export.h , microtcp.h in out/ .
MicroTCP utiliza la interfaz de socket habitual con la que cualquier programador de red está familiarizado, la principal diferencia es que necesita instanciar explícitamente la pila de red y pasar su mango.
Aquí hay un servidor de eco simple que muestra el 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 ;
} Esto debería ser bastante sencillo para entender. Una cosa puede valer la pena señalar que microtcp_open se comporta como el socket+bind+listen a la vez para configurar un servidor TCP de escucha.
Hay más de una forma de configurar la pila, la principal forma de microtcp_create que crea una inferencia de red virtual en el sistema operativo host con IP 10.0.0.5/24 y un host virtual para el proceso MicroTCP en 10.0.0.4/24. Puede abrir Wireshark en la NIC virtual para inspeccionar el tráfico entre el host y el proceso.
También es posible configurar la pila utilizando el microtcp_create_using_callbacks , que le permite proporcionar explícitamente los marcos L2 de entrada y recibir los cuadros en un búfer. Así es como uno configuraría la pila para ejecutarse en un microcontrolador.
Cada instancia de MicroTCP (sin considerar las devoluciones de llamada) está completamente aislada de las demás, por lo tanto, si su implementación específica de devolución de llamada lo permite, ¡puede tener tantas instancias como desee!
Todavía no hay infracructura de prueba. La forma en que lo estoy probando es configurando un servidor HTTP o Echo y estresándolo hasta que algo se rompe mientras captura lo que sucedió usando Wireshark.
