DEPARTAMENTO DE ENGENHARIA INFORMÁTICA Introdução às Redes de Comunicação

i Universidade de Coimbra Faculdade de Ciências e Tecnologia DEPARTAMENTO DE ENGENHARIA INFORMÁTICA Introdução às Redes de Comunicação Network Simulator 3 (ns-3) Ano Lectivo de 2009/2010 www.nsnam.org 1. Introdução O Network Simulator 3 (ns-3) é um simulador de rede que pretende ser uma nova alternativa ao popular Network Simulator 2 (ns-2). O ns-3 é um software gratuito, distribuído sob a licença GNU GPLv2 e que é disponibilizado gratuitamente para investigação, desenvolvimento e utilização. O desenvolvimento do ns-3 começou em Julho de 2006 e está programado que dure cerca de quatro anos. O projecto ns-3 é financiado por várias instituições como a Universidade de Washington, o Georgia Institute of Technology e o ICSI Center for Internet Research, tendo ainda o suporte do Planète research group do INRIA Sophia-Antipolis. O ns-3 é escrito em C++ e Python e esta disponível para vários sistema operativos como Linux, OS X e Windows (através utilização do Cygwin). 2. Objectivos Nesta ficha pretende-se explicar o funcionamento geral do simulador ns-3 e o desenvolvimentos de alguns scripts C / Python que simulem topologias simples. Ao mesmo tempo serão mostrados alguns métodos para avaliação dos resultados obtidos, através da utilização do NAM The Network Animator para a visualização gráfica da simulação e também do Wireshark para uma análise mais detalhada dos pacotes. 3. Instalação e documentação As duas principais dependências exigidas para a instalação de ns-3 são: uma instalação actualizada de Python (2.4 ou acima) e um compilador GNU C. Assim como a alternativa de simulação anterior (ns- 2), ns-3 é distribuído de duas formas: em uma versão compacta (all-in-one) e também uma versão do código fonte disponível em repositórios remotos (neste caso Mercurial). Caso a escolha tenha sido pela distribuição compacta, é importante observar os requisitos de software necessários para a devida instalação de ns-3. Essa lista de pré-requisitos pode ser encontrada em: http://www.nsnam.org/wiki/index.php/installation e dependem da distribuição linux em que será feita a instalação. IRC 2009/2010 1

Caso a escolha tenha sido a distribuição compacta, a instalação dá-se pela execução das seguintes instruções: tar xvf ns-allinone-3.6.tar.bz2 cd ns-allinone-3.6./build.py Posteriormente, torna-se necessário configurar o ambiente ns. Embora a maioria das aplicações linux se baseiem no uso de make para este propósito, o ns-3 baseia-se na aplicação waf que é um sistema de build específico para python. Desta forma, o próximo passo será:./waf configure Um último passo para avaliar se a instalação ocorreu correctamente é o teste da instalação. Este teste pode ser feito pela execução da seguinte instrução:./test.py Uma peculiaridade para esta versão do simulador ns-3 são os distintos formatos permitidos para o trace de pacotes e tráfego das simulações. Os ficheiros de trace gerados no ns-2 não são mais lidos nesta versão. Para este novo formato de ficheiros de trace, deve-se utilizar uma aplicação que é capaz de analisar e animar as ligações point-to-point peculiares ao ns-3. Esta aplicação é a NetAnim (http://www.nsnam.org/wiki/index.php/netanim). Conforme será observado nos exemplos posteriores, ns-3 trata a construção de ligações entre nós de uma topologia através de ligações conhecidas como point-to-point. Essas ligações diferem-se do formato dos canais estabelecidos em ns- 2. Outra estratégia comum em ns-3 e analisar o tráfego pela inspeção de pacotes. Essa é uma técnica bastante comum entre os analisadores de protocolos tais como o Wireshark (http://www.wireshark.org/) ou o tcpdump. Para este fim, conforme será discutido no segundo script, podem ser gerados ficheiros com a extensão pcap que representam uma inspeção detalhada de pacotes em modo promíscuo. Com o intuito de diminuir a complexidade do processo de instalação, configuração e teste, provemos para esta ficha uma máquina virtual gerada a partir do sistema operativo Linux Ubuntu 9.10. Nesta máquina virtual já estão instalados o ns-3 e o NetAnim e pode ser obtido a partir do seguinte link: https://193.136.212.206/irc/irc_vmware_ubuntu_20091111.tar.bz2. Para aceder à máquina virtual utiliza-se o seguinte utilizador: Username: irc Password: IRC$2009 Após o download, a máquina virtual pode ser descompactada e através de um player para máquinas virtuais pode-se aceder ao ambiente já preparado. Para este efeito, sugere-se o uso do ambiente VMWare Player ou Sun VirtualBox. Conforme observado na Figura 1, para o início da execução a partir do player, basta escolher a pasta onde foi foi executado o desempacotamento. A partir desse ponto, uma nova sessão terá início. Nessa sessão usar-se-á as seguintes credenciais: Username: ircuser Password: ircuser IRC 2009/2010 2

Figura 1 - Diálogo inicial do VMWare Player. Abaixo seguem links para documentação ns-3: NS-3 overview: http://www.nsnam.org/docs/ns-3-overview.pdf Tutoriais NS-3: http://www.nsnam.org/tutorials.html Documentação para as classes NS-3: http://www.nsnam.org/doxygen-release/index.html Introdução ao NS-3: http://www.nsnam.org/getting_started.html 4. Criação do primeiro script O ns-3 suporta scripts escritos nas linguagem C e Python. Neste exemplo, optou-se pela criação do script utilizando a linguagem Python. 4.1. Criação do cenário O nosso cenário será composto por dois nós que vão comunicar utilizando o protocolo UDP. Neste exemplo, deve guardar o seu código num ficheiro com o nome primeiro.py. #Inicializa o modulo ns3 import ns3 #Activa os logs para os vários componentes ns3.logcomponentenable("udpechoclientapplication", ns3.log_level_info) ns3.logcomponentenable("udpechoserverapplication", ns3.log_level_info) #Criação de dois nós nodes = ns3.nodecontainer() nodes.create(2) O diagrama apresentado na Figura 2 ilustra a criação dos dois nós no nosso cenário. nodes: NodeContainer Node 0 Node 1 Figura 2 Ilustração da criação dos dois nós do cenário IRC 2009/2010 3

4.2. Criação do canal físico de comunicação Neste momento o nosso cenário tem dois nós mas, no entanto, não existe nenhum meio físico para que esses mesmo nós possam comunicar. Vamos então estabelecer a ligação física entre os nós. #Criação de um objecto PointToPointHelper para a ligação ponto a ponto entre dois nós. pointtopoint = ns3.pointtopointhelper() #Definição das característica da ligação pointtopoint.setdeviceattribute("datarate", ns3.stringvalue("10mbps")) pointtopoint.setchannelattribute("delay", ns3.stringvalue("2ms")) #Instalação da ligação nos nós criados anteriormente devices = pointtopoint.install(nodes) A Figura 3 representa o estado actual do nosso cenário. Neste momento já possuímos os dois nós ligados através de uma ligação física. Devices: NetDeviceContainer 10Mpbs, 5ms Node 0 Node 1 PointToPointNetDevice Figura 3 Criação da ligação física entre dos dois nós da rede 4.3. Instalação do interface de rede Depois da ligação física, vamos agora criar os interfaces de rede para os vários nós. Neste exemplo iremos utilizar uma stack IPv4(o ns-3 suporta também IPv6). #Agrega as funcionalidades da stack TCP/IP aos nós stack = ns3.internetstackhelper() stack.install(nodes) #Criação do endereço IPv4 address = ns3.ipv4addresshelper() #Definição da rede e respectiva mascara de rede address.setbase(ns3.ipv4address("192.168.1.0"), ns3.ipv4mask("255.255.255.0")) #Atribuição dos endereços aos respectivos nós #Como anteriormente foi definida a rede 192.168.1.0/255.255.255.0, os nós Node0 e Node1 vão ter os endereços 192.168.1.1 e 192.168.1.2, respectivamente interfaces = address.assign(devices) 4.4. Criação de aplicações IRC 2009/2010 4

Neste momento temos todo o cenário pronto até ao nível da camada de rede. No entanto, não existem aplicações a utilizar a nossa rede. Assim, é necessário criar uma aplicação. Neste exemplo vamos utilizar uma aplicação cliente-servidor, em que o cliente envia pacotes UDP ao servidor e o servidor responde ao cliente com uma cópia desse mesmo pacote. #Cria uma aplicação que espera por pacotes UDP num determinado porto (neste caso o porto 5000, que é passado como parâmetro) e envia esse pacote para o remetente original echoserver = ns3.udpechoserverhelper(5000) #Instala a aplicação no servidor (i.e. no Node 1, que é referenciado através da instrução nodes.get(1) ). serverapps = echoserver.install(nodes.get(1)) serverapps.start(ns3.seconds(1.0)) serverapps.stop(ns3.seconds(10.0)) #Cria uma aplicação que envia pacotes UDP e que espera pela resposta echoclient = ns3.udpechoclienthelper(interfaces.getaddress(1), 5000) echoclient.setattribute("maxpackets", ns3.uintegervalue(1)) echoclient.setattribute("interval", ns3.timevalue(ns3.seconds (1.5))) echoclient.setattribute("packetsize", ns3.uintegervalue(2048)) #Instala a aplicação anterior no nó que irá actuar como remetente (i.e. Node 0 ) e em seguida inicia a mesma aplicação. clientapps = echoclient.install(nodes.get(0)) clientapps.start(ns3.seconds(1.5)) clientapps.stop(ns3.seconds(10.0)) 4.5. Iniciar a simulação Depois da criação do cenário e respectivas aplicações, é agora necessário recorrer as primitivas que irão fazer com a simulação inicie e termine. ns3.simulator.run() ns3.simulator.destroy() Para correr a simulação deverá colocar o ficheiro criado na pasta scratch na raiz do simulador e correr o seguinte comando:./waf - pyrun scratch/primeiro.py 5. NetAnim Como mencionado anteriormente, em NS-3 ficheiros de trace não possuem o mesmo formato dos ficheiros produzidos em ns-2. Desta forma, tornou-se necessária uma aplicação que permitisse a leitura e gerasse animações para ficheiros deste formato. A ferramenta NetAnim é uma aplicação que dá suporte à execução desta tarefa. Em nossa máquina virtual NetAnim já está instalada e pode ser automaticamente executada desde que o ficheiro de trace esteja no formato ns-3. IRC 2009/2010 5

Apresentaremos NetAnim através de um exemplo, disponível também na máquina virtual usada nesta ficha. Aproveitamos para também apresentar as funcionalidades de ns-3 em linguagem C. 5.1. Captura dos parâmetros iniciais Para informar a aplicação dos valores dos parâmetros (quantidade de nós na disposição esquerda e direita do plano) basta utilizar a seguinte instrução:./waf --run 'src/contrib/net-anim/test-dumbbell --nleftleaf=5 --nrightleaf=5 -- animfile=dumbbell.tr' Config::SetDefault ("ns3::onoffapplication::packetsize", UintegerValue (512)); Config::SetDefault ("ns3::onoffapplication::datarate", StringValue ("500kb/s")); uint32_t nleftleaf = 5; uint32_t nrightleaf = 5; uint32_t nleaf = 0; // Se diferente de zero é o número de nós esquerdo e direito uint16_t port = 0; // Porto para onde se executa o bind dessa animação std::string animfile; // Nome que será dado ao ficheiro de saída CommandLine cmd; cmd.addvalue ("nleftleaf", "Número de nós à esquerda", nleftleaf); cmd.addvalue ("nrightleaf","número de nós à direita", nrightleaf); cmd.addvalue ("nleaf", "Numero total de nós", nleaf); cmd.addvalue ("port", "Porto para animação remota", port); cmd.addvalue ("animfile", "Nome do ficheiro de saída para posterior trace", animfile); cmd.parse (argc,argv); if (nleaf > 0) { nleftleaf = nleaf; nrightleaf = nleaf; 5.2. Criação das ligações ponto-a-ponto Da mesma forma que nos exemplos anteriores um objecto PointToPoint é utilizado para se criarem as ligações entre os nós, neste exemplo essas ligação são associadas a um objecto NetAnim PointToPointDumbellHelper. PointToPointHelper pointtopointrouter; pointtopointrouter.setdeviceattribute ("DataRate", StringValue ("10Mbps")); pointtopointrouter.setchannelattribute ("Delay", StringValue ("1ms")); PointToPointHelper pointtopointleaf; pointtopointleaf.setdeviceattribute ("DataRate", StringValue ("10Mbps")); pointtopointleaf.setchannelattribute ("Delay", StringValue ("1ms")); PointToPointDumbbellHelper d(nleftleaf, pointtopointleaf, nrightleaf, pointtopointleaf, pointtopointrouter); Endereçamento e aplicação cliente O endereçamento é feito através de um objecto Ipv4AddressHelper. E a aplicação cliente, baseada em UDP, é disparada e finalizada numa distribuição uniforme. InternetStackHelper stack; d.installstack (stack); IRC 2009/2010 6

d.assignaddresses(ipv4addresshelper("10.1.1.0", "255.255.255.0"), Ipv4AddressHelper("10.2.1.0", "255.255.255.0"), Ipv4AddressHelper("10.3.1.0", "255.255.255.0")); OnOffHelper clienthelper ("ns3::udpsocketfactory", Address ()); clienthelper.setattribute("ontime", RandomVariableValue (UniformVariable (0, 1))); clienthelper.setattribute("offtime", RandomVariableValue (UniformVariable (0, 1))); ApplicationContainer clientapps; for (uint32_t i = 0; i < d.rightcount(); ++i) { // Pacotes são gerados e enviados para o nós correspondente da direita AddressValue remoteaddress(inetsocketaddress(d.getleftaddress(i), 1000)); clienthelper.setattribute("remote", remoteaddress); clientapps.add(clienthelper.install(d.getright(i))); clientapps.start (Seconds (0.0)); clientapps.stop (Seconds (10.0)); // Configuração da area onde dar-se-á a animação d.boundingbox(1, 1, 10, 10); 5.3. Inicio da animação O NetAnim possui uma classe que permite a configuração da animação da simulação a classe AnimationInterface. A partir de um objecto desta classe inicia-se a visualização desta simulação. AnimationInterface anim; if (port > 0) { anim.setserverport(port); else if (!animfile.empty()) { anim.setoutputfile(animfile); anim.startanimation(); Ipv4GlobalRoutingHelper::PopulateRoutingTables (); std::cout << "Running the simulation" << std::endl; Simulator::Run (); std::cout << "Destroying the simulation" << std::endl; Simulator::Destroy (); std::cout << "Stopping the animation" << std::endl; anim.stopanimation(); 5.4. Resultados Os resultados são animações similares às previamente obtidas em ns-2, conforme observa-se na Figura 4. O resultado da Figura 4 é automaticamente obtido a partir da execução da instrução NetAnim dumbbell.tr. IRC 2009/2010 7

Figura 4 - Animação através de NetAnim. 6. Segundo script Neste segundo exemplo vamos explorar o uso de sockets em conjunto com o protocolo TCP. Criaremos uma topologia simples, como pode ser observado na Figura 5. Nosso intuito é enviar pacotes até um tamanho máximo (estipulado no script) de forma que o nó n2 já não possa mais responder ao nó requisitante (nó 0). Figura 5 - Topologia de teste para o segundo exemplo. 6.1. Definição da topologia #include <ctype.h> #include <iostream> #include <fstream> #include <string> #include <cassert> #include "ns3/core-module.h" #include "ns3/helper-module.h" #include "ns3/node-module.h" #include "ns3/simulator-module.h" using namespace ns3; /* Primeiro passo: criar containers para os nós e isolar o nó n2 para que ele possa tornar-se nosso terminador */ NodeContainer n0n1; n0n1.create (2); NodeContainer n1n2; n1n2.add (n0n1.get (1)); n1n2.create (1); /* Assim como no script anterior, lançamos mão de PointToPointHelper para criar o canal de comunicação que vai abrigar os nós criados anteriormente */ IRC 2009/2010 8

PointToPointHelper p2p; p2p.setdeviceattribute ("DataRate", DataRateValue (DataRate(10000000))); p2p.setchannelattribute ("Delay", TimeValue (MilliSeconds(10))); /* Embora tenhamos criados os nós, estes ainda não foram associados a nenhum tipo de dispositivo. Dessa forma cada container de nós torna-se um container de dispositivos de rede, podendo, posteriormente incorporar características típicas destes dipositivos */ NetDeviceContainer dev0 = p2p.install (n0n1); NetDeviceContainer dev1 = p2p.install (n1n2); 6.2. Incorporação da pilha de protocolos TCP/IP Para que quaisquer testes possam ser feitos, é necessário associar endereços e os comportamentos associados aos protocolos dessa pilha. Para que o teste possa ser feito cada um dos nós estará associado a um endereço IP. //As seguintes instruções instala a pilha de protocolos TCP/IP em todos os nós InternetStackHelper internet; internet.installall (); /* Agora cada container de dispositivos recebe um endereço base, de onde o script poderá obter endereços para os nós */ Ipv4AddressHelper ipv4; ipv4.setbase ("10.1.3.0", "255.255.255.0"); ipv4.assign (dev0); ipv4.setbase ("10.1.2.0", "255.255.255.0"); Ipv4InterfaceContainer ipinterfs = ipv4.assign (dev1); //Para que ambos conjuntos de endereços sejam alcançáveis, popula-se as tabelas de roteamento Ipv4GlobalRoutingHelper::PopulateRoutingTables (); 6.3. Definição dos comportamentos esperados para os nós Conforme descrito anteriormente, o nó n2 comportar-se-á como um terminador das requisições. Para tanto, associa-se a esse nó um objecto PacketSinkHelper. Por outro lado, por se tratar de um cenário baseado no protocolo TCP, o requisitante (n1) passa a estar associado a um socket para onde n2 confirma as requisições efectuadas. //Como recurso da linguagem de programação associamos servport a um valor de porto fixo uint16_t servport = 8007; /* Cria-se um objecto PacketSinkHelper, com as intrínsecas funcionalidades esperadas para um nó que comporte o protocolo de transporte TCP */ PacketSinkHelper sink ("ns3::tcpsocketfactory", InetSocketAddress (Ipv4Address::GetAny (), servport)); /* Uma aplicação hipotética é associada ao nó n2. Supõe-se, dessa maneira, que o nó n0 possa fazer requisições a essa aplicação. */ ApplicationContainer apps = sink.install (n1n2.get (1)); apps.start (Seconds (0.0)); apps.stop (Seconds (3.0)); /* Agora devemos criar uma fonte para o envio de pacotes a partir de n0. A criação do socket e a associação ao nó n0 permitirá à nossa aplicação identificar o endereço para onde encaminhar a resposta a alguma requisição. */ Ptr<Socket> localsocket = Socket::CreateSocket (n0n1.get (0), TcpSocketFactory::GetTypeId ()); localsocket->bind (); IRC 2009/2010 9

/* Para simular o envio de requisições uma nova função foi criada StartFlow. Essa função é disparada quando do início da simulação (Simulator::ScheduleNow). */ Simulator::ScheduleNow (&StartFlow, localsocket,ipinterfs.getaddress (1), servport); 6.4. Implementação do envio de pacotes Conforme mencionado anteriormente, espera-se que o nó n2 receba requisições do nó n0. Essas requisições devem cessar quando atingirem um limite máximo (2000000 bytes). Para explicar como o envio foi produzido e o limite testado, esta etapa foi dividida em duas subetapas: definição dos elementos básicos para envio e teste do tamanho dos pacotes e posteriormente as funções. Elementos básicos para o envio e teste // limite máximo de bytes que se pretende enviar static const uint32_t totaltxbytes = 2000000; static uint32_t currenttxbytes = 0; static const uint32_t writesize = 1040; //buffer do nó n0 de onde serão enviados dados para o nó n2 uint8_t data[writesize]; /* Para efeitos de teste, algum conteúdo é colocado em data para que possa ser enviado ao nó n2 */ for(uint32_t i = 0; i < writesize; ++i) { char m = toascii (97 + i % 26); data[i] = m; Funções void StartFlow(Ptr<Socket> localsocket,ipv4address servaddress, uint16_t servport) { // o socket que foi enviado é automaticamente conectado ao servidor localsocket->connect (InetSocketAddress (servaddress, servport)); /* Sucessivas chamadas serão feitas e logo após um teste da quantidade de informação enviada é feito, dessa forma, quando atingir-se o limite esperado, as chamadas são cessadas. */ localsocket->setsendcallback (MakeCallback (&WriteUntilBufferFull)); WriteUntilBufferFull (localsocket, localsocket->gettxavailable ()); /* o buffer (data) previamente ocupado com algum conteúdo, será constantemente utilizado. Essa função retornará o fim da conexão socket ao nó n0 assim que a quantidade de bytes enviada atingir o valor totaltxbytes e já não houver dados a serem enviados para o nó n2. */ void WriteUntilBufferFull (Ptr<Socket> localsocket, uint32_t txspace) { while (currenttxbytes < totaltxbytes && localsocket->gettxavailable () > 0) { uint32_t left = totaltxbytes - currenttxbytes; uint32_t dataoffset = currenttxbytes % writesize; uint32_t towrite = writesize - dataoffset; towrite = std::min (towrite, left); towrite = std::min (towrite, localsocket->gettxavailable ()); int amountsent = localsocket->send (&data[dataoffset], towrite, 0); if(amountsent < 0) { return; currenttxbytes += amountsent; localsocket->close (); 6.5. Avaliação do resultado IRC 2009/2010 10

Ainda torna-se necessário definir em que formato o resultado dessa simulação vai ser averiguada. Como dito anteriormente, o ns-3 dá a possibilidade de desviar o comportamento das topologias de teste para ficheiros pcap, ou seja, permite a monitorização dos pacotes em modo promíscuo, o qual pode posteriormente ser analisado por um analisador de tráfego como o Wiresharck. Para que esse script pudesse comportar-se dessa forma, as seguintes instruções foram adicionadas ao script. // uma alternativa para monitorizar o tráfego é através de um ficheiro de trace std::ofstream ascii; ascii.open ("segundo.tr"); PointToPointHelper::EnableAsciiAll (ascii); /* o canal previamente estabelecido pode ser colocado em modo promíscuo de forma que toda comunicação possa ser monitorizada e armazenada em ficheiros no formato segundo-x- X.pcap */ PointToPointHelper::EnablePcapAll ("segundo"); /* Apenas para resguardar de possíveis falhas o simulador força uma parada a um determinado momento para o caso de nunca atingir-se o limite de bytes estipulado. */ Simulator::Stop (Seconds(1000)); Simulator::Run (); Simulator::Destroy (); Como parte da avaliação do resultado, pode-se utilizar do Wireshark para averiguar todo o tráfego do segundo script que foi direccionado para ficheiros pcap. Observe pela Figura 6 que como tratase de uma aplicação TCP inúmeros acknowledgments foram necessários. Figura 6 - Captura dos primeiros pacotes enviados pelo segundo script no Wireshark. IRC 2009/2010 11