Inicio>Relacionado con la programación>código fuente c#
Descargar

picoTCP

Bienvenido al único repositorio de picoTCP.

picoTCP es una pila TCP/IP modular de tamaño reducido diseñada para sistemas integrados e Internet de las cosas. Altran Intelligent Systems lo está desarrollando activamente.

Este código se publica bajo los términos de GNU GPL v2 y GNU GPL v3. Algunos derechos reservados. Se pueden aplicar otras licencias a exclusivo criterio de los titulares de los derechos de autor.

Aprenda a utilizar picoTCP en su proyecto consultando la guía de introducción en nuestra wiki de GitHub.

Para más información envíanos un correo electrónico o contáctanos en Twitter, Facebook o Reddit.

¿Se pregunta sobre la calidad del código de picoTCP? Consulta nuestra puntuación TiCS

Integración continua

Pruebas funcionales: - Pruebas unitarias: - Cumplimiento de RFC: - Calidad TICS: Coverity Scan Estado de compilación:

Funciona con (prácticamente) todo

Al mantener las interfaces simples, el esfuerzo de migración a nuevas plataformas y sistemas operativos es muy bajo. Para darte una indicación: la portabilidad a una nueva plataforma se puede realizar en 3 días o menos, un nuevo sistema operativo en un solo día y si realmente te vuelves loco, puedes hacer una portabilidad inicial en una sola tarde. Diferentes plataformas significan diferentes compiladores, es por eso que compilamos continuamente nuestra pila con varios de ellos. La siguiente lista muestra algunas de las plataformas, controladores de dispositivos y compiladores admitidos actualmente.

PicoTCP se ha utilizado con

Plataformas en las que se ejecuta picoTCP : serie ARM Cortex-M (ST Micro STM, NXP LPC, TI Stellaris, Freescale K64F), serie ARM ARM9 (ST Micro STR9), Texas Instruments (MSP430), Microchip (PIC24, PIC32), Atmel ( AVR de 8 bits), Linux (espacio de usuario (TUN/TAP), espacio de kernel), Windows (espacio de usuario (TAP))

Dispositivos de red con los que picoTCP ha trabajado : BCM43362 (IEEE 802.11), MRF24WG (IEEE 802.11), LPC Ethernet ENET/EMAC (IEEE 802.3), Stellaris Ethernet (IEEE 802.3), STM32 Ethernet (IEEE 802.3), Wiznet W5100 (IEEE 802.3), USB CDC-ECM (CDC1.2), PPP, controladores virtuales (TUN/TAP, VDE, Libpcap)

(RT)OS picoTCP se ha integrado en : Sin sistema operativo/Bare metal, FreeRTOS, mbed-RTOS, Frosted, Linux/POSIX, MS DOS, MS Windows

Bibliotecas picoTCP se ha integrado con : wolfSSL, mbedTLS, biblioteca Mongoose RESTful, MicroPython

Compiladores picoTCP compila bajo : GCC, Clang, TCC, ARM-RCVT, IAR, XC-16, XC-32, MSP-GCC, AVR-GCC

Lamentablemente no podemos publicar todo el código, entre otras cosas porque algunas partes dependen de código o binarios que no son compatibles con GPL, algunas partes se desarrollaron bajo un contrato comercial y otras consisten en un código de prueba de concepto muy aproximado. Si desea obtener más información sobre la disponibilidad bajo la licencia comercial o la posibilidad de utilizar nuestros servicios expertos para la portabilidad o el desarrollo de controladores, no dude en contactarnos en [email protected].

¿Tu favorito no está en la lista? ¡Consulte la wiki para obtener información y ejemplos sobre cómo portar picoTCP a una nueva plataforma!

Diseño modular y altamente configurable

Las funciones se desarrollan como módulos en picoTCP, lo que le permite elegir las funciones que desea en su aplicación. Esto da como resultado la pila más pequeña posible que cumple con los estándares de Internet. El siguiente esquema proporciona una descripción general de todos los protocolos implementados.

Ejemplo sencillo

Preparativos

Este ejemplo utiliza Ubuntu 14.04. También funciona en otras distribuciones de Linux, aunque es posible que deba cambiar algunos nombres de paquetes. Consulte configuración del entorno para obtener más información. 

sudo apt-get install git check vde2 libvdeplug2-dev libpcap0.8-dev openvpn wireshark
git clone https://github.com/tass-belgium/picotcp
cd picotcp
make TAP=1
cd ..

el codigo

Luego cree un nuevo directorio, por ejemplo example , y cree un archivo con el siguiente contenido: //: # (El código siguiente se extrae a través de nuestro CI; ¡deje intactos los comentarios del extractor de código!) //: # (inicio del extractor de código) 

 #include 
#include 
#include 
#include 
#include 

#define NUM_PING 10

static int finished = 0 ;

/* gets called when the ping receives a reply, or encounters a problem */
void cb_ping ( struct pico_icmp4_stats * s )
{
    char host [ 30 ];
    pico_ipv4_to_string ( host , s -> dst . addr );
    if ( s -> err == 0 ) {
        /* if all is well, print some pretty info */
        printf ( "%lu bytes from %s: icmp_req=%lu ttl=%lu time=%lu msn" , s -> size ,
                host , s -> seq , s -> ttl , ( long unsigned int ) s -> time );
        if ( s -> seq >= NUM_PING )
            finished = 1 ;
    } else {
        /* if something went wrong, print it and signal we want to stop */
        printf ( "PING %lu to %s: Error %dn" , s -> seq , host , s -> err );
        finished = 1 ;
    }
}


int main ( void ){
    int id ;
    struct pico_ip4 ipaddr , netmask ;
    struct pico_device * dev ;

    /* initialise the stack. Super important if you don't want ugly stuff like
     * segfaults and such! */
    pico_stack_init ();

    /* create the tap device */
    dev = pico_tap_create ( "tap0" );
    if (! dev )
        return -1 ;

    /* assign the IP address to the tap interface */
    pico_string_to_ipv4 ( "192.168.5.4" , & ipaddr . addr );
    pico_string_to_ipv4 ( "255.255.255.0" , & netmask . addr );
    pico_ipv4_link_add ( dev , ipaddr , netmask );

    printf ( "starting pingn" );
    id = pico_icmp4_ping ( "192.168.5.5" , NUM_PING , 1000 , 10000 , 64 , cb_ping );

    if ( id == -1 )
        return -1 ;

    /* keep running stack ticks to have picoTCP do its network magic. Note that
     * you can do other stuff here as well, or sleep a little. This will impact
     * your network performance, but everything should keep working (provided
     * you don't go overboard with the delays). */
    while ( finished != 1 )
    {
        usleep ( 1000 );
        pico_stack_tick ();
    }

    printf ( "finished !n" );
    return 0 ;
}

Construyendo y ejecutando

Ahora podemos compilar esto y vincularlo ejecutando 

gcc -c -o main.o -I../picotcp/build/include main.c
gcc -o main.elf main.o ../picotcp/build/lib/libpicotcp.a

A continuación crearemos un dispositivo de toque persistente: un puerto de red virtual. No es necesario que repita esto cada vez, el dispositivo existirá hasta que reinicie o hasta que acceda sudo tunctl -d tap0 

sudo tunctl -u < username >
sudo ifconfig tap0 192.168.5.5

Ahora, debería poder ejecutar ./main.elf y ver un resultado como 

 Protocol ethernet registered (layer: 2).
Protocol ipv4 registered (layer: 3).
Protocol ipv6 registered (layer: 3).
Protocol icmp4 registered (layer: 4).
Protocol icmp6 registered (layer: 4).
Protocol igmp registered (layer: 4).
Protocol udp registered (layer: 4).
Protocol tcp registered (layer: 4).
Device tap0 created.
Assigned ipv4 192.168.5.4 to device tap0
starting ping
64 bytes from 192.168.5.5: icmp_req=1 ttl=64 time=5 ms
64 bytes from 192.168.5.5: icmp_req=2 ttl=64 time=0 ms
64 bytes from 192.168.5.5: icmp_req=3 ttl=64 time=0 ms
64 bytes from 192.168.5.5: icmp_req=4 ttl=64 time=0 ms
64 bytes from 192.168.5.5: icmp_req=5 ttl=64 time=0 ms
64 bytes from 192.168.5.5: icmp_req=6 ttl=64 time=0 ms
64 bytes from 192.168.5.5: icmp_req=7 ttl=64 time=0 ms
64 bytes from 192.168.5.5: icmp_req=8 ttl=64 time=0 ms
64 bytes from 192.168.5.5: icmp_req=9 ttl=64 time=0 ms
64 bytes from 192.168.5.5: icmp_req=10 ttl=64 time=0 ms
finished !

Mientras la aplicación se está ejecutando, también puedes ejecutar 

 ping 192.168.5.4

para enviar pings en la otra dirección.

Investigando lo que pasó

Ejecute Wireshark y huela la interfaz tap0. Luego ejecute ./main.elf nuevamente y vea qué sucede. Debería ver una solicitud ARP de picoTCP a Linux y una respuesta. Después de eso, debería ver las solicitudes y respuestas de ping yendo y viniendo.

Tenga en cuenta que a veces puede ver muchas otras cosas, solicitudes de enrutador IPv6, varias transmisiones, mDNS, DNS-SD, etc. Aquí es cuando su Linux se da cuenta de que la nueva interfaz de red está activa y comienza todo tipo de descubrimientos. Con el dispositivo TAP persistente, esto normalmente sólo ocurre la primera vez que inicia la aplicación. Inicie una nueva captura de Wirehark e inicie la aplicación nuevamente; debería estar mucho más limpia ahora.

¡Ahora puedes hacer algunos cambios en el archivo main.c y experimentar un poco! Mantenga algunas estadísticas de sus pings (tiempo máximo, mínimo, promedio). Abra un socket UDP, envíe algunas cosas a una instancia de netcat en su Linux. O construya un escáner de puertos rudimentario y vea qué puertos están abiertos en su máquina.

Esta es solo una descripción general muy rápida; puede encontrar más información en nuestra wiki.

Colaboradores

Los contribuyentes son muy bienvenidos. Informar un error, sugerir una forma de mejorar nuestra documentación o escribir algún código nuevo.

Sin embargo, tenga en cuenta que, antes de aceptar su código, le pediremos que firme nuestro Acuerdo de licencia de colaborador. Su código permanece bajo su copyright y siempre estará disponible bajo GPLv2 y GPLv3. Sin embargo, este CLA nos permite utilizar picoTCP (incluido el código de contribuyentes externos como usted) bajo otras licencias, incluida nuestra licencia comercial. Al realizar proyectos comerciales, podemos seguir invirtiendo en la calidad y las características de picoTCP.

Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo