Page d'accueil>Lié à la programmation>Code source C#
Télécharger

picoTCP

Bienvenue dans le seul et unique référentiel picoTCP.

picoTCP est une pile TCP/IP modulaire à faible encombrement conçue pour les systèmes embarqués et l'Internet des objets. Il est activement développé par Altran Intelligent Systems .

Ce code est publié sous les termes de GNU GPL v2 et GNU GPL v3. Certains droits réservés. D'autres licences peuvent s'appliquer à la seule discrétion des détenteurs des droits d'auteur.

Apprenez à utiliser picoTCP dans votre projet en parcourant le guide de démarrage sur notre wiki GitHub.

Pour plus d'informations, envoyez-nous un e-mail ou contactez-nous sur Twitter, Facebook ou Reddit.

Vous vous interrogez sur la qualité du code de picoTCP ? Consultez notre score TiCS

Intégration continue

Tests fonctionnels : - Tests unitaires : - Conformité RFC : - Qualité TICS : Coverity Scan Build status :

Il fonctionne sur (presque) tout

En gardant les interfaces simples, les efforts de portage vers de nouvelles plates-formes et systèmes d'exploitation sont très faibles. Pour vous donner une indication : le portage sur une nouvelle plateforme peut se faire en 3 jours ou moins, un nouvel OS en une seule journée et si vous devenez vraiment fou, vous pouvez faire un premier portage en une seule soirée. Différentes plates-formes signifient différents compilateurs, c'est pourquoi nous compilons continuellement notre pile avec plusieurs d'entre eux. La liste suivante présente certaines des plates-formes, pilotes de périphériques et compilateurs actuellement pris en charge.

PicoTCP a été utilisé avec

Plateformes picoTCP fonctionne sur : série ARM Cortex-M (ST Micro STM, NXP LPC, TI Stellaris, Freescale K64F), série ARM ARM9 (ST Micro STR9), Texas Instruments (MSP430), Microchip (PIC24, PIC32), Atmel ( AVR 8 bits), Linux (Espace utilisateur (TUN/TAP), Espace noyau), Windows (Espace utilisateur (TAP))

Périphériques réseau avec lesquels picoTCP a travaillé : 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, pilotes virtuels (TUN/TAP, VDE, Libpcap)

(RT)OS picoTCP a été intégré dans : No OS / Bare metal, FreeRTOS, mbed-RTOS, Frosted, linux / POSIX, MS DOS, MS Windows

Bibliothèques picoTCP a été intégré avec : wolfSSL, mbedTLS, bibliothèque Mongoose RESTful, MicroPython

Compilateurs picoTCP compile sous : GCC, Clang, TCC, ARM-RCVT, IAR, XC-16, XC-32, MSP-GCC, AVR-GCC

Malheureusement, nous ne pouvons pas publier tout le code, entre autres parce que certaines parties dépendent de code ou de binaires qui ne sont pas compatibles GPL, certaines parties ont été développées dans le cadre d'un contrat commercial et d'autres sont constituées d'un code de preuve de concept très approximatif. Si vous souhaitez en savoir plus sur la disponibilité sous licence commerciale, ou sur la possibilité de faire appel à nos services experts en portage ou développement de drivers, n'hésitez pas à nous contacter à [email protected].

Votre favori ne figure pas dans la liste ? Consultez le wiki pour obtenir des informations et des exemples sur la façon de porter picoTCP sur une nouvelle plate-forme !

Conception hautement configurable et modulaire

Les fonctionnalités sont développées sous forme de modules dans picoTCP, vous permettant de choisir les fonctionnalités que vous souhaitez dans votre application. Il en résulte la plus petite pile possible qui reste conforme aux normes Internet. Le schéma ci-dessous donne un aperçu de tous les protocoles mis en œuvre.

Exemple simple

Préparations

Cet exemple utilise Ubuntu 14.04. Il fonctionne également sur d'autres distributions Linux, même si vous devrez peut-être modifier certains noms de packages. Voir configuration de l'environnement pour plus d'informations. 

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 ..

Le code

Créez ensuite un nouveau répertoire, par exemple example , et créez un fichier avec le contenu suivant : //: # (Le code ci-dessous est extrait via notre CI - veuillez laisser les commentaires de l'extracteur de code intacts !) //: # (démarrage de l'extracteur de code) 

 #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 ;
}

Construire et faire fonctionner

Nous pouvons maintenant compiler ceci et le lier en exécutant 

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

Nous allons ensuite créer un périphérique Tap persistant : un port réseau virtuel. Vous n'avez pas besoin de répéter cela à chaque fois, le périphérique existera jusqu'à ce que vous redémarriez ou jusqu'à ce que vous alliez sudo tunctl -d tap0 

sudo tunctl -u < username >
sudo ifconfig tap0 192.168.5.5

Maintenant, vous devriez pouvoir exécuter ./main.elf et voir un résultat comme 

 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 !

Pendant que l'application est en cours d'exécution, vous pouvez également exécuter 

 ping 192.168.5.4

pour envoyer des pings dans l'autre sens.

Enquêter sur ce qui s'est passé

Exécutez Wireshark et reniflez l'interface tap0. Ensuite, exécutez à nouveau le ./main.elf et voyez ce qui se passe. Vous devriez voir une requête ARP de picoTCP vers Linux et une réponse. Après cela, vous devriez voir les requêtes ping et les réponses aller et venir.

Notez que parfois vous pouvez voir beaucoup d'autres choses, des sollicitations de routeur IPv6, diverses diffusions, mDNS, DNS-SD, etc. - c'est à ce moment-là que votre Linux remarque que la nouvelle interface réseau est opérationnelle et démarre toutes sortes de découvertes. Avec le périphérique TAP persistant, cela ne se produit généralement qu'au premier démarrage de l'application. Démarrez une nouvelle capture Wireshark et redémarrez l'application, elle devrait être beaucoup plus propre maintenant.

Vous pouvez maintenant apporter quelques modifications au fichier main.c et expérimenter un peu ! Conservez quelques statistiques de vos pings (max, min, temps moyen). Ouvrez un socket UDP, envoyez des éléments à une instance netcat sur votre Linux. Ou créez un scanner de ports rudimentaire, voyez quels ports sont ouverts sur votre machine.

Ceci n'est qu'un aperçu très rapide, plus d'informations peuvent être trouvées sur notre wiki.

Contributeurs

Les contributeurs sont les bienvenus. Signalez un bug, suggérez un moyen d'améliorer notre documentation ou écrivez du nouveau code.

Notez cependant qu'avant d'accepter votre code, nous vous demanderons de signer notre contrat de licence de contributeur. Votre code reste sous vos droits d'auteur et sera toujours disponible sous GPLv2 et GPLv3. Cependant, ce CLA nous permet d'utiliser picoTCP (y compris le code provenant de contributeurs externes comme vous) sous d'autres licences, y compris notre licence commerciale. En réalisant des projets commerciaux, nous pouvons continuer à investir dans la qualité et les fonctionnalités de picoTCP.

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout