Controlador Ethernet ENC28J60

Posted in Uncategorized on outubro 11, 2008 by overmindbr

Eis um chip da Microchip que implementa a camada de Enlace e Física. Tem seu próprio endereço MAC, PHY 10BASE-T, 8KByte de memória ram (buffer) e se comunica utilizando uma interface SPI. Utiliza um cristal de 25 MHz e comunica-se à  Custa cerca de 4 dólares cada e é voltada para dispositivos que necessitam de acesso a internet. Sua única dificuldade, assim como qualquer implementação Ethernet, são os circuitos externos necessários, como alguns indutores e filtros de ferrite.

Saiba mais em: http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en022889

Unix Sockets em C parte 2

Posted in Uncategorized on outubro 10, 2008 by overmindbr

Veremos agora algumas funções úteis para a programação com sockets:

uint16_t htons(uint16_t hostshort);
Converte um short int com o número da porta (no caso de um intel, little endian), para um número de porta utilizando network byte order (big endian).
servidor.sin_port=htons(4050);  // (seta a porta para 4050)

in_addr_t inet_addr(const char *cp);
Seta o endereço do host.
servidor.sin_addr.s_addr=inet_addr(“200.164.72.31”);

struct hostent *gethostbyname(const char *name);
Utilizada para resolução de nomes. A estrtura hostent é:
struct  hostent {
char    *h_name;        /* Nome oficial do host */
char    **h_aliases;    /* Lista de aliases */
int     h_addrtype;     /* Tipo de endereco do host */
int     h_length;       /* Tamanho do endereco */
char    **h_addr_list;  /* Lista de enderecos do
servidor de nomes */
};

ssize_t send(int s, const void *buf, size_t len, int flags);
Envia uma mensagem através da conexão. *buf é a string a ser enviada, len é o tamanho da string e flags são parâmetros para envio da mensagem. Quando flags é igual a 0, ela se comporta como a função write().
send(Novosocket, “HelloWorld!\n”, 12, 0);

Exemplo prático de um cliente que se conecta em um servidor e envia uma mensagem de saudação:

//Headers necessários
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/signal.h>
#include <errno.h>
#include <netdb.h>

int main(){
int sock;
struct sockaddr_in server;
int conn;

//cria o soquete
sock = socket(AF_INET,SOCK_STREAM,0);
if(sock < 0) //verifica erros
{
perror(“Erro ao criar soquete.”);
exit(1);
}

//preenche a estrutra com dados do servidor.
server.sin_family = AF_INET;
server.sin_port = htons(7000);
server.sin_addr.s_addr = inet_addr(“192.168.2.1”);
bzero(&(server.sin_zero),8);

//estabelece a conexão com o host
conn = connect(sock,(struct sockaddr * )&server, sizeof(server));
if(conn < 0) { //checa por erros
perror(“Erro ao conectar”);
exit(1);
} else {
send(Novosocket, “HelloWorld!\n”, 12, 0); //envia a mensagem
}
}
Vimos até agora como criar um cliente que se conecta a um servidor. Um exemplo básico que ilustra como conectar e como enviar mensagens ao mesmo. Apesar de básico, reflita: Se você consegue fazer algo simples, o que te impede de fazer algo complexo?

to be continued…

Unix Sockets em C parte 1

Posted in Uncategorized on outubro 7, 2008 by overmindbr

Irei agora iniciar agora alguns posts sobre programação de Sockets em C para ambientes Unix (utilizei o linux para testes).  Antes de iniciar a programação, será necessário incluir os seguintes cabeçalhos no seus programas, mas dependendo da situação necessitará de outros:

#include <sys/types.h>
#include <sys/sockets.h>
#include <netinet/in.h>
#include <netdb.h>

Os sockets, como a maioria da comunicação de entrada e saída no unix, são declarados utilizando inteiros:

int soquete;

A estrutura que contém os dados relacionados ao host ao qual se quer conectar é a sockaddr_in:

struct sockaddr_in {
short int sin_family;         /* Familia do endereco */
unsigned short int sin_port;  /* Numero da porta */
struct in_addr sin_addr;      /* IP do Host */
unsigned char sin_zero[8];    /* Zera a estrutura, algum espaco como
struct sockaddr */

}

O short int sin_family normalmente será AF_INET, que significa (ARPA INTERNET PROTOCOLS),  sin_port o número da porta e sin_addr o número do ip do host.

Para criar um socket utilizamos a função int socket(int domain, int type, int protocol);

O tipo de socket será SOCK_STREAM ou SOCK_DGRAM, onde o primeiro é utilizado por conexões TCP e o segundo por UDP.

O número do protocolo usado será:

0 – IP – INTERNET PROTOCOL
1 – ICMP – INTERNET CONTROL MESSAGE PROTOCOL
2 – IGMP – INTERNET GROUP MULTICAST PROTOCOL
3 – GGP – GATEWAY-GATEWAY PROTOCOL
6 – TCP – TRANSMISSION CONTROL PROTOCOL
17 – UDP – USER DATAGRAMA PROTOCOL

continua…

A camada de aplicação

Posted in Uncategorized on setembro 14, 2008 by overmindbr

As camadas inferiores têm a função de transmitir os dados enviados pela camada de aplicação de maneira confiável, mas não fornecem serviços diretos ao usuários. Já a camada de aplicação, fornece diretamente estes serviços, sendo assim, “a razão de ser de uma rede de computadores” (Kuroise).

Antes de citar os protocolos, veremos 2 arquiteturas de aplicação bastante utilizadas. A primeira é a Cliente-Servidor, onde um servidor fornece um serviço e os clientes se conectam ao servidor e utilizam este serviço. Um exemplo é quando abrimos um cliente FTP e nos conectamos a um servidor: ao conectarmos podemos listar os arquivos no servidor e assim copiarmos para nosso computador. Este trabalho de receber uma mensagem, arquivo, ou até vídeo e transmitir a outro cliente é realizado pelo servidor (ou servidores).

Outra arquitetura de aplicação é o P2P (peer-to-peer), onde nem sempre há servidores funcionando mediando a comunicação entre os clientes. Assim temos sempre pares de clientes que se comunicam entre si, gerando uma comunicação par-a-par (peer-to-peer). O principal exemplo desta arquitetura é o de transferência de arquivos utilizada, por exemplo, pelo Gnutella e afins.

Outra arquitetura utilizada seria uma híbrida cliente/servidor-P2P. Esta arquitetura utiliza, por exemplo, para transferência de arquivos o P2P e a arquitetura cliente/servidor para pesquisar quais peers contêm o arquivo desejado.

Como disse anteriormente, a principal arma do modelo TCP/IP é a implementação dos protocolos. Então não poderia deixar de fora alguns deles, que funcionam na camada de Aplicação:

  • DNS – Serviço de resolução de nomes. Serviço responsável por traduzir um nome em um IP. O contrário também acontece, dado um IP é possível traduzir um nome (apesar de que não é obrigatório um servidor fazer o DNS reverso).
  • HTTP – Protocolo de transferência de hipertexto. É o responsável por você estar vendo esta página. Ele recebe/trata das requisições de páginas aos servidores e envia ao cliente (navegador WEB).
  • FTP – Protocolo de transferência de arquivos implementado utilizando TCP.
  • TFTP – Protocolo de transferência de arquivos triviais que é implementado utilizando UDP.
  • POP3/IMAP/SMTP – Protocolos que cuidam de correio eletrônico. São responsáveis por enviar e receber e-mails.

A Camada de Rede, o Protocolo IP e a Internet

Posted in Uncategorized on setembro 3, 2008 by overmindbr

Como disse no post anterior, o IP é o protocolo que mantém a Internet unida. O objetivo do protocolo, desde o início, era fornecer uma maneira de transportar os datagramas da origem para o destino, independente da rede.

O datagrama IP é formado pelo cabeçalho  e por uma parte de dados. O cabeçalho consiste em no mínimo 20 bytes e uma parte opcional de tamanho variável. Ele é enviado do último byte para o primeiro, do bit mais significante para o menos significante.  Isso o torna Big Endian, enquanto que os processadores da intel são Little Endian. Isso torna a implementação de soquetes de rede diferentes para cada arquitetura, pois numa arquitetura Intel, o software terá que realizar shift dos bytes.

O formato do datagrama IP é:

 

 

Veja que este cabeçalho é gerado por software ao se enviar um pacote pela rede. Logo, os campos do cabeçalho podem ser forjados de maneira maliciosa…

A Internet e seus Protocolos

Posted in Uncategorized on setembro 2, 2008 by overmindbr

Posso ouvir o Tanenbaum dizendo “A internet não é de forma alguma uma rede”. Isso acontece porque a Internet é um conjunto de várias redes interligadas, que se comunicam através de protocolos bem definidos e assim oferecem serviços comuns aos internautas.

Tradicionalmente, dizemos que um computador está conectado a Internet quando executa a pilha de protocolos TCP/IP (Tanenbaum et. al., 2003). Essa pilha está encapsulada em quatro camadas:

 

 

 

Na camada superior, a Aplicação,  funcionam os protocolos que estão disponíveis ao usuário da Internet, como HTTP (servidor web), DNS (servidor de nomes),  FTP (servidor de transferência de arquivos), IRC (internet relay chat) e outros.

Na camada de Transporte os principais protocolos usados são TCP e UDP. O primeiro é orientado a conexão, isto é, um host (cliente) se conecta a um outro host (servidor) de maneira que os pacotes existe a certeza de que os pacotes enviados de um para o outro serão recebidos no destino.  Já o protocolo UDP, não é orientado a conexão, assim não se há a garantia de que os pacotes serão recebidos pelo destino, tornando os dados inseguros. Você, se for como eu, estaria se perguntando: Para quê eu usaria um protocolo de transporte que não me garante a entrega dos pacotes?
A resposta é simples: velocidade. O protocolo UDP, por não precisar de confirmação no recebimento dos dados, é um protocolo mais rápido do que o TCP. Isso torna as aplicações, onde não é necessário se ter a certeza de recebimento do pacote, mais rápidas. Isso é útil, por exemplo, em transmissões de Streams, como vídeo e áudio, onde a perda de pacotes não interfere na execução de vídeo, mas a velocidade de transmissão é crucial.

O camada que mantém a Internet interligada é a camada de Redes, especificamente, o protocolo IP. Com ele, temos a certeza de que nosso pacote poderá ser entregue ao nosso computador de destino e também que este computador terá a possibilidade de nos responder. Dizemos então que ele é roteável.

A camada inferior da pilha TCP/IP é a camada Física, que determina fisicamente (ao contrário das outras que são lógicas) como os pacotes serão recebidos e enviados. Um exemplo, mais comum, é o Ethernet.