Internet 0
Introdução
Internet das coisas é o conceito que reúne diversas tecnologias de forma a conectar e comunicar diferentes objetos através da internet. Ela foi desenvolvida no Centro de bits e átomos do MIT por Neil Gershenfeld, Raffi Krikorian, e Danny Cohen.
7 principios já existentes, juntos, possibilitam a internet 0.
- IP to leaf nodes
Cada dispositivo tem o seu próprio IP.
- Compiled standards
Simplificar o Modelo OSI, juntando as camadas.
- Peers don't need servers
Cada dispositivo é responsável pelas coisas que controla e pelas quais é controlado.
- Physical identity
Tres identificações:
- IP - Proveniente de um servidor de DNS, ou aleatório.
Ex (“192.168.1.100”) .
- Hardware - Parecido com um endereço MAC, porem gerado aleatoriamente. Ex {“AA-BB-CC-DD-EE-FF”}.
- Endereço Funcional - Descreve, em linguagem corrente, o que é e onde está. Ex (“O interruptor perto da porta”).
- Open standards
Para que todos os dispositivos falem a mesma linguagem e as várias redes possam falar umas com as outras.
- Big bits
Um bit de uma rede representa uma unidade de informação (um 1 ou um 0), e é representada por alguns tipo de excitação(elétrons em um fio, fótons em uma fibra).
Se, um bit é maior do que a rede, então ele vai encher a rede independente de como ele está configurado. Para um de 100m isto corresponde a cerca de um milhão de bits por segundo, o equivalente a uma conexão DSL, que é bastante para uma lâmpada. Se os bits são enviados a este ritmo então eles têm tempo para resolver sobre a rede, o que simplifica como eles podem ser codificados.
- End-to-end modulation
Para dois dispositivos se comunicarem eles têm de concordar em como irão enviar/receber a informação.
Solução Proposta
Será implementado o protocolo Internet zero, estando contido dentro do IPv6, no campo de FlowLabel. Conforme a rfc2460 o campo FlowLabel é utilizado para a qualidade do serviço. Como no nosso caso o requisito não suportará esse tipo de serviço, decidimos por implementar todo o protocolo internet 0 dentro do mesmo, minimizando assim o tamanho dos pacotes. Por padrão deixaremos o campo Traffic com valor default 0, pois a RFC2460 não prevê valor padrão para o caso de desconsiderar a utilização do campo FlowLabel nos roteadores.
Este protocolo será capaz de reconhecer dados enviados pela rede, realizando assim os comandos desejados em um sensor de temperatura, caso estes dados sejam validados nos testes.
A camada de enlace será feita utilizado o Network Interface Card (NIC) juntamente com a familiía de classe Network, já implementado no EPOS, que realizam a comunicação com o meio físico.
O reconhecimento das mensagens será feito através de comparações,analisando o tamanho e os valores dos campos afim de identificar o protocolo Internet0, descartando assim a mensagens que nao passarem nos testes de verificação.
Requisitos
Funcionais
- Responder a comandos solicitados de forma rápida.
- Garantir a interoperabilidade com a internet
Não funcionais
- Menor utilização de banda da rede possível.
- Baixo consumo de energia
Protocolos:
Protocolo de Rede.
Como cada objeto deverá ter um ip fixo, será utilizado o protocolo IPv6 permitindo assim endereçar uma maior quantidade de objetos.
Os campos que constituem então o cabeçalho IPv6 são:
- Version (4 bits) - Versão do IP utilizada. No caso no IPv6, este campo vale 0110.
- Priority (4 bits) - Indica a prioridade com a qual o pacote deve ser tratado.
- Flow label (24 bits) - Identifica, juntamente com os campos Source Address e Destination Address, o fluxo ao qual o pacote pertence.
- Payload Length (16 bits) - Tamanho, em octetos, do restante do pacote, após o cabeçalho.
- Next Header (8 bits) - Indica o tipo do possível cabeçalho de extensão que segue o cabaçalho IPv6. Caso não esteja se utilizando cabeçalho de extensão, este campo indica a qual protocolo de transporte o pacote deve ser repassado.
- Hop Limit (8 bits) - Número máximo de roteamentos que o pacote pode sofrer. O valor deste campo é decrementado a cada roteamento. Quando seu valor chega a zero o pacote é descartado. Similar ao campo Time to live do IPv4.
- Source Address (128 bits) - Endereço do remetente.
- Destination Address (128 bits) - Endereço de destino.
Protocolo de Transporte
Para representar a cada de transporte será utilizado o protoclo UDP devido a sua simplicidade.
Os campos que constituem então o protocolo UDP são:
- Porta Origem(16 bits): trata-se do número de porta que corresponde à aplicação emissora do segmento UDP. Este campo representa um endereço de resposta para o destinatário. Assim, este campo é opcional, isto significa que se não se precisar da porta fonte, os 16 bits deste campo serão zero, neste caso o destinatário não poderá responder (isto não é necessariamente necessário, nomeadamente para mensagens unidirecionais.
- Porta Destino(16 bits): Este campo contém a porta que corresponde à aplicação da máquina destinatário à qual nos dirigimos.
- Comprimento(16 bits): Este campo precisa o comprimento total do segmento, incluindo o cabeçalho, ora o cabeçalho tem um comprimento de 4 x 16 bits (são 8 x 8 bits), então o campo comprimento é necessariamente superior ou igual a 8 bytes.
- Checksum(16 bits): Trata-se de uma soma de controlerealizada de maneira a poder controlar a integridade do segmento.
Protocolo Internet 0
O protocolo Internet 0 será definido no protocolo IPV6, no campo FlowLabel com tamanho fixo, que irá representar os comandos dos equipamentos. Assim como o protocolo HTTP, esse protocolo será baseado no paradigma requisição e resposta.
O protocolo internet zero será composto por 24 bits, sendo eles:
Tipo de serviço (8 bits): Campo com os tipos de serviços oferecidos pelos objetos. Abaixo temos alguns exemplos de possíveis valores para uma lampada.
0x1 - Acender uma lampada.
0x2 - Apagar uma lampada.
0x3 - Piscar uma lampada 1 vez.
0x4 - Piscar uma lampada 2 vez.
flag de comando(8 bits): Campo com os possíveis comandos que poderão ser solicitados. Abaixo temos alguns exemplos de possíveis valores.
0x1 - Pedido para executar comando
0x2 - Resposta de sucesso ao executar comando.
0x3 - Resposta de falha ao executar comando.
0x4 - Estado do objeto.
dados(8 bits): campo com o comando ou a resposta feito por um objeto.
Pilha do Protocolo Final:
Para o sistema reconhecer que um pacote está destinado a ele, o pacote deve atender as seguintes condições:
O tamanho do pacote deve ser de 384 bits, sendo os seguintes campos com os seguintes valores:
Version: 0110
Pay Load: 0x08
Next Header: 0x11
Destination Address: Meu ip
Porta Origem: A ser definida
Comprimento: 0x08
Implementação I0 no Epos:
O Envio de pacotes foi implementado com sucesso conforme o codigo abaixo:
Implementação IPV6.cc
#include "ipv6.h"
#include <network.h>
__BEGIN_SYS
#define MAXRECVSTRING 255
#define DEST "127.0.0.1"
IPv6::IPv6() {
_meu_ip.setaddress(Traits<IPv6>::ADDRESS);
_header = new Header(_meu_ip);
}
IPv6::~IPv6() {
}
char* IPv6::receive(){
Network net;
Network::Address from;
Network::Protocol prot;
char pacote[320];
int result = net.receive(&from, pacote, 320);
if(result > 0 && validar(pacote)){
return pacote;
}
}
return null;
}
bool IPv6::validar(char *pacote){
if(sizeof(pacote) != 320) //tamanho do pacote
return false;
else if(pacote[0] != 0x60) //verifica version/traffic
return false;
else if(pacote[4] != 0x00) //verifica payload (tamanho pacote)
return false;
else if(pacote[5] != 0x08) //verifica payload (tamanho pacote)
return false;
else if(pacote[6] != 0x11) //next header (UDP)
return false;
else if(pacote[7] !=0x04) //valida hop limit
return false;
else if( (pacote[40] !=0xdb) || (pacote[41] !=0xcd) ) //valida porta Destino UDP
return false;
else if(ehMeuIp(pacote) == false)
return false;
return true;}
void IPv6::send(Address & toIPv6, char flag, char tiposervico, short dados) {
Network net;
Network::Address from;
unsigned char *src = _meu_ip.address();
Network::Address to(dst[0], dst[1], dst[2], dst[3], dst[4], dst[5], dst[6], dst[7], dst[8], dst[9], dst[10], dst[11], dst[12], dst[13], dst[14], dst[15]) ;
Network::Protocol prot;
char data[1500];
char packet[] = {
0x60, // VERSAO (4) , PRIORIDADE (4)
this->_header->flowlabel().tiposervico(),this->_header->flowlabel().flag(), this->_header->flowlabel().dados(), // FLOWLABEL I0 - TIPODESERVICO (4), FLAGDECOMANDO(4) , DADOS (16)
0x00, 0x08, // Payload Length/TAMANHO DOS DADOS (16)
this->_header->nextheader(), //NEXT HEADER (8)
this->_header->hoplimit(), // HOPLIMIT (8)
src[0], src[1], src[2], src[3], src[4], src[5], src[6], src[7], src[8], src[9], src[10], src[11], src[12], src[13], src[14], src[15], // END FONTE (128)
dst[0], dst[1], dst[2], dst[3], dst[4], dst[5], dst[6], dst[7], dst[8], dst[9], dst[10], dst[11], dst[12], dst[13], dst[14], dst[15], // END dest (128)
0xda, 0xd3, // PORTA ORIGEM (16)
0xdb, 0xcd, // PORTA DESTINO (16)
0x0, 0x08, // COMPRIMENTO (16)
0xFF, 0xFF // CHECKSUM (16)
};
net.send(to, packet, 320,PROT_IPV6);
}
__END_SYS
Implementação Ipv6.h
#ifndef __ipv6_h
#define __ipv6_h
#include <nic.h>
#include <router.h>
#include <utility/malloc.h>
#include <utility/debug.h>
#include <utility/buffer.h>
#include <utility/string.h>
#include <system/meta.h>
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned long u32;
typedef signed long s32;
typedef unsigned int u128;
const int LENGTH = 16;
__BEGIN_SYS
class IPv6_Address {
private:
unsigned char _address[LENGTH];
public:
IPv6_Address(unsigned short addr[LENGTH]) {
_address[0] = addr[0];
_address[1] = addr[1];
_address[2] = addr[2];
_address[3] = addr[3];
_address[4] = addr[4];
_address[5] = addr[5];
_address[6] = addr[6];
_address[7] = addr[7];
_address[8] = addr[8];
_address[9] = addr[9];
_address[10] = addr[10];
_address[11] = addr[11];
_address[12] = addr[12];
_address[13] = addr[13];
_address[14] = addr[14];
_address[15] = addr[15];
}
IPv6_Address(u128 addr) {
}
IPv6_Address(unsigned char a0 = 0x0, unsigned char a1 = 0x0, unsigned char a2 = 0x0, unsigned char a3 = 0x0, unsigned char a4 = 0x0, unsigned char a5 = 0x0, unsigned char a6 = 0x0, unsigned char a7 = 0x0, unsigned char a8 = 0x0, unsigned char a9 = 0x0, unsigned char a10 = 0x0, unsigned char a11 = 0x0, unsigned char a12 = 0x0, unsigned char a13 = 0x0, unsigned char a14 = 0x0, unsigned char a15 = 0x0) {
_address[0] = a0;
_address[1] = a1;
_address[2] = a2;
_address[3] = a3;
_address[4] = a4;
_address[5] = a5;
_address[6] = a6;
_address[7] = a7;
_address[8] = a8;
_address[9] = a9;
_address[10] = a10;
_address[11] = a11;
_address[12] = a12;
_address[13] = a13;
_address[14] = a14;
_address[15] = a15;
}
void setaddress(unsigned char a0 = 0x0, unsigned char a1 = 0x0, unsigned char a2 = 0x0, unsigned char a3 = 0x0, unsigned char a4 = 0x0, unsigned char a5 = 0x0, unsigned char a6 = 0x0, unsigned char a7 = 0x0, unsigned char a8 = 0x0, unsigned char a9 = 0x0, unsigned char a10 = 0x0, unsigned char a11 = 0x0, unsigned char a12 = 0x0, unsigned char a13 = 0x0, unsigned char a14 = 0x0, unsigned char a15 = 0x0) {
_address[0] = a0;
_address[1] = a1;
_address[2] = a2;
_address[3] = a3;
_address[4] = a4;
_address[5] = a5;
_address[6] = a6;
_address[7] = a7;
_address[8] = a8;
_address[9] = a9;
_address[10] = a10;
_address[11] = a11;
_address[12] = a12;
_address[13] = a13;
_address[14] = a14;
_address[15] = a15;
}
IPv6_Address(char _addr[]) {
char addr[LENGTH];
addr[0] = 0x0;
addr[1] = 0x0;
addr[2] = 0x0;
addr[3] = 0x0;
addr[4] = 0x0;
addr[5] = 0x0;
addr[6] = 0x0;
addr[7] = 0x0;
addr[8] = 0x0;
addr[9] = 0x0;
addr[10] = 0x0;
addr[11] = 0x0;
addr[12] = 0x0;
addr[13] = 0x0;
addr[14] = 0x0;
addr[15] = 0x0;
int i;
for (i = 0; i < LENGTH; ++i) {
char * sep = strchr(_addr, ':');
addr[i] = atol(_addr);
if (!sep) break;
_addr = ++sep;
}
memcpy(this, addr, sizeof (this));
}
operator u128() {
return *reinterpret_cast<u128 *> (this);
}
operator u128() const {
return *reinterpret_cast<const u128 *> (this);
}
unsigned char* address() {
return _address;
}
};
class IPv6{
public:
typedef IPv6_Address Address;
typedef u8 NextHeader;
static const Address BROADCAST;
class Header {
public:
class I0 {
public:
I0() :
_tiposervico(0x4), _flag(0x2), _dados(0x9) {
}
private:
char _tiposervico;
char _flag;
char _dados;
};
Header() {
}
Header(Address dst) :
_version(6), _traffic(0), _payload(8),
_nextheader(0x11), _hoplimit(4), _dst_ip(dst) {
}
private:
u8 _version : 6;
u8 _traffic;
I0 _flowlabel;
u16 _payload : 8;
u8 _nextheader; //= 0x11;
u8 _hoplimit; // = 0x4;
Address _src_ip; // Source IP address
Address _dst_ip; // Destination IP addres
};
enum {
PROT_IPV6 = Ethernet::IPV6,
};
void send(Address & to, char flag, char tiposervico, short dados);
char* receive(char* portaOrigem);
bool validar(char* pacote);
IPv6();
~IPv6();
private:
Header * _header;
IPv6_Address _meu_ip;
char _packet[];
bool ehMeuIp(char* pacote);
};
__END_SYS
#endif
Teste Envio
int main(){
IPv6 net;
IPv6_Address to(0,0,0,0,0,0,0,0,0,0,0,0,192,168,0,10);
IPv6_Address from;
char data[1500];
short dados = 2;
char flag = 0x23;
char servico = 0x21;
char a = 0x12;
net.send(to, flag, servico, dados);
};
Classe network.h
class Network: public NIC_Common::Observer
{
public:
// Network logical address
class Address: public NIC_Common::Address<16> {
public:
Address() {}
Address(int a) { *reinterpret_cast<int *>(this) = a; }
Address(unsigned char a0, unsigned char a1 = 0,
unsigned char a2 = 0, unsigned char a3 = 0,
unsigned char a4 = 0, unsigned char a5 = 0,
unsigned char a6 = 0, unsigned char a7 = 0,
unsigned char a8 = 0, unsigned char a9 = 0,
unsigned char a10 = 0, unsigned char a11 = 0,
unsigned char a12 = 0, unsigned char a13 = 0,
unsigned char a14 = 0, unsigned char a15 = 0)
: NIC_Common::Address<16>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) {}
operator int() { return *reinterpret_cast<int *>(this); }
operator int() const { return *reinterpret_cast<const int *>(this); }
};
static const Address BROADCAST;
// Network phisical address
typedef NIC::Address MAC_Address;
// Network protocol numbers
typedef NIC::Protocol Protocol;
enum {
PROT_ELP = Ethernet::ELP,
PROT_IP = Ethernet::IP,
PROT_IPV6 = Ethernet::IPV6,
PROT_ARP = Ethernet::ARP,
PROT_RARP = Ethernet::RARP
};
// Network statistics
typedef NIC::Statistics Statistics;
// ARP
typedef class ARP<NIC, Network> ARP;
public:
Network() {
db<Network>(TRC) << "Network(unit=0)\n";
_arpt.update(BROADCAST, NIC::BROADCAST);
_nic.attach(this, PROT_ARP);
_nic.attach(this, PROT_RARP);
_address = rarp(_nic.address());
}
template<unsigned int UNIT>
Network(unsigned int unit) : _nic(UNIT) {
db<Network>(TRC) << "Network(unit=" << unit << ")\n";
}
~Network() {
db<Network>(TRC) << "~Network()\n";
}
int send(const Address & to, const void * data, unsigned int size, Protocol prot);
int receive(Address * from, void * data, unsigned int size);
MAC_Address arp(const Address & addr);
Address rarp(const MAC_Address & addr);
void update(NIC_Common::Observed * o, int p);
void reset() { _nic.reset(); }
const Address & address() { return _address; }
const Statistics & statistics() { return _nic.statistics(); }
private:
NIC _nic;
Address _address;
static ARP::Table _arpt;
};
__END_SYS
Referencias
IPv6 - Redes de Computadores I -
/>
Protocolo IPv6 - Cabeçalho -
/>
Internet 0 -
/>
Internet 0: Past, Present, and future -
/>Internet 0: Enabling IP Over Anything - http://rbeverly.net/research/current/i0/draft-gershenfeld-i0-00.html