Página Inicial>Relacionado com a programação>Código-fonte C#
Baixar

picoTCP

Bem-vindo ao único repositório picoTCP.

picoTCP é uma pilha TCP/IP modular de pequeno porte projetada para sistemas embarcados e a Internet das Coisas. Está sendo desenvolvido ativamente pela Altran Intelligent Systems .

Este código é lançado sob os termos da GNU GPL v2 e GNU GPL v3. Alguns direitos reservados. Outras licenças podem ser aplicadas a critério exclusivo dos detentores dos direitos autorais.

Aprenda como usar o picoTCP em seu projeto acessando o guia de primeiros passos em nosso wiki do GitHub.

Para mais informações envie-nos um email ou entre em contato conosco no Twitter, Facebook ou Reddit.

Quer saber sobre a qualidade do código do picoTCP? Verifique nossa pontuação TiCS

Integração contínua

Testes funcionais: - Testes unitários: - Conformidade com RFC: - Qualidade TICS: Coverity Scan Build status:

Funciona em (praticamente) tudo

Ao manter as interfaces simples, o esforço de portabilidade para novas plataformas e sistemas operacionais é muito baixo. Para te dar uma indicação: a portabilidade para uma nova plataforma pode ser feita em 3 dias ou menos, um novo sistema operacional em um único dia e se você realmente enlouquecer, pode fazer uma portabilidade inicial em uma única noite. Plataformas diferentes significam compiladores diferentes, é por isso que compilamos continuamente nossa pilha com vários deles. A lista a seguir mostra algumas das plataformas, drivers de dispositivo e compiladores atualmente suportados.

PicoTCP tem sido usado com

Plataformas em que o picoTCP é executado : 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 (Espaço do usuário (TUN/TAP), Espaço do kernel), Windows (Espaço do usuário (TAP))

Dispositivos de rede com os quais o picoTCP trabalhou : 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, drivers virtuais (TUN/TAP, VDE, Libpcap)

(RT)SOs picoTCP foi integrado em : No OS / Bare metal, FreeRTOS, mbed-RTOS, Frosted, linux / POSIX, MS DOS, MS Windows

Bibliotecas picoTCP foram integradas com : wolfSSL, mbedTLS, biblioteca Mongoose RESTful, MicroPython

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

Infelizmente não podemos liberar todo o código, até porque algumas partes dependem de código ou binários que não são compatíveis com GPL, algumas partes foram desenvolvidas sob um contrato comercial e algumas consistem em um código de prova de conceito muito aproximado. Se quiser saber mais sobre a disponibilidade da licença comercial, ou a possibilidade de utilizar os nossos serviços especializados para portabilidade ou desenvolvimento de drivers, não hesite em contactar-nos em [email protected].

Seu favorito não está na lista? Confira o wiki para obter informações e exemplos sobre como portar o picoTCP para uma nova plataforma!

Design altamente configurável e modular

Os recursos são desenvolvidos como módulos no picoTCP, permitindo que você escolha os recursos que deseja em sua aplicação. Isso resulta na menor pilha possível que permanece compatível com os padrões da Internet. O esquema abaixo fornece uma visão geral de todos os protocolos implementados.

Exemplo simples

Preparativos

Este exemplo usa Ubuntu 14.04. Ele também funciona em outras distribuições Linux, embora possa ser necessário alterar alguns nomes de pacotes. Consulte configurando o ambiente para obter mais informações. 

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

O código

Em seguida, crie um novo diretório, por exemplo, example e crie um arquivo com o seguinte conteúdo: //: # (O código abaixo é obtido através de nosso CI - por favor, deixe os comentários do extrator de código intactos!) //: # (início do extrator 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 ;
}

Construindo e funcionando

Agora podemos compilar isso e vinculá-lo, executando 

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

A seguir, criaremos um dispositivo de toque persistente – uma porta de rede virtual. Você não precisa repetir isso todas as vezes, o dispositivo existirá até você reiniciar ou até você usar sudo tunctl -d tap0 

sudo tunctl -u < username >
sudo ifconfig tap0 192.168.5.5

Agora, você deve ser capaz de executar ./main.elf e ver resultados 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 !

Enquanto o aplicativo está em execução, você também pode executar 

 ping 192.168.5.4

para enviar pings na outra direção.

Investigando o que aconteceu

Execute o wireshark e detecte a interface tap0. Em seguida, execute ./main.elf novamente e veja o que acontece. Você deverá ver uma solicitação ARP do picoTCP para Linux e uma resposta. Depois disso, você deverá ver as solicitações e respostas de ping indo e voltando.

Observe que às vezes você pode ver muitas outras coisas, solicitações de roteadores IPv6, várias transmissões, mDNS, DNS-SD, etc. - é quando o Linux percebe que a nova interface de rede está ativa e inicia todos os tipos de descobertas. Com o dispositivo TAP persistente, isso geralmente só acontece na primeira vez que você inicia o aplicativo. Inicie uma nova captura do wireshark e reinicie o aplicativo, ele deve estar muito mais limpo agora.

Agora você pode fazer algumas alterações no arquivo main.c e experimentar um pouco! Mantenha algumas estatísticas de seus pings (tempo máximo, mínimo, médio). Abra um soquete UDP, envie algumas coisas para uma instância do netcat no seu Linux. Ou construa um scanner de porta rudimentar, veja quais portas estão abertas em sua máquina.

Esta é apenas uma visão geral muito rápida. Mais informações podem ser encontradas em nosso wiki.

Colaboradores

Contribuintes são muito bem-vindos. Relate um bug, sugira uma maneira de melhorar nossa documentação ou escreva algum código novo.

Observe, entretanto, que, antes de aceitar seu código, pedimos que você assine nosso Contrato de Licença de Colaborador. Seu código permanece sob seus direitos autorais e estará sempre disponível sob GPLv2 e GPLv3. No entanto, este CLA nos permite usar picoTCP (incluindo código de colaboradores externos como você) sob outras licenças, incluindo nossa licença comercial. Ao realizar projetos comerciais, podemos continuar investindo na qualidade e nas funcionalidades do picoTCP.

Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos