CENTRO ESTADUAL DE EDUCAÇÃO TECNOLÓGICA PAULA
SOUZA
FACULDADE DE TECNOLOGIA DE LINS PROF. ANTONIO SEABRA
CURSO SUPERIOR DE TECNOLOGIA EM REDES DE COMPUTADORES
RAFAEL FERRAZ DOS SANTOS
RODRIGO NAMBA DAKE
NEHMO
MONITORAMENTO DE HARDWARE POR REDE
LINS/SP
1º SEMESTRE/2013
CENTRO ESTADUAL DE EDUCAÇÃO TECNOLÓGICA PAULA
SOUZA
FACULDADE DE TECNOLOGIA DE LINS PROF. ANTONIO SEABRA
CURSO SUPERIOR DE TECNOLOGIA EM REDES DE COMPUTADORES
RAFAEL FERRAZ DOS SANTOS
RODRIGO NAMBA DAKE
NEHMO
MONITORAMENTO DE HARDWARE POR REDE
Trabalho de Conclusão de Curso apresentado à
Faculdade de Tecnologia de Lins, para obtenção
do Título de Tecnólogo em Redes de
Computadores.
Orientador: Prof. Naylor Garcia Bachiega
LINS/SP
1º SEMESTRE/2013
RAFAEL FERRAZ DOS SANTOS
RODRIGO NAMBA DAKE
NEHMO
MONITORAMENTO DE HARDWARE POR REDE
Trabalho de Conclusão de Curso apresentado à
Faculdade de Tecnologia de Lins, como parte dos
requisitos necessários para a obtenção do título de
Tecnólogo em Redes de Computadores sob
orientação do Prof. Naylor Garcia Bachiega.
Data de aprovação: ___/___/___
_____________________________________
Orientador (Naylor Garcia Bachiega)
_____________________________________
Examinador 1 (Nome do Examinador)
_____________________________________
Examinador 2 (Nome do Examinador)
Aos meus pais, Wilson Ferraz dos Santos
e Maria Cristina Ferraz dos Santos. À minha
esposa, Lilia R. F. Cardoso, pelo apoio e
dedicação.
Rafael Ferraz dos Santos
Dedico este trabalho a toda a minha
família, principalmente à minha esposa, Tatiana
Fernandes Montanha Dake, que tanto me
incentivou e ao meu falecido pai, Minoru Dake, a
quem muito devo em minha vida.
Rodrigo Namba Dake
AGRADECIMENTOS
Nesta oportunidade deixo meu profundo agradecimento à minha esposa, Lilia,
pelo profundo apoio e paciência. Agradeço ao Prof. Naylor Garcia Bachiega pela
orientação e amizade, e também ao Prof. Me. Fábio Lúcio Meira, pela amizade
desenvolvida nos anos de estudo. Agradeço ao meu amigo e parceiro de trabalho,
Rodrigo Namba Dake, pelo esforço conjunto para a produção desta obra.
Rafael Ferraz dos Santos
Agradeço a todos os professores e à família. Em especial ao amigo Maurício
Calligaris que muito me ajudou em vários momentos do trabalho.
Rodrigo Namba Dake
RESUMO
Administrar uma rede de computadores é uma tarefa que envolve várias
rotinas, que vão desde a verificação dos componentes da rede até a criação de uma
documentação contendo informações sobre os mesmos. A proposta desse trabalho
é proporcionar a ideia base para o desenvolvimento de uma ferramenta capaz de
auxiliar o administrador de redes de computadores, na tarefa de manter um
inventário das estações de trabalho que compõem seu ambiente, bem como os
componentes internos e suas características. Visa-se a criação de um sistema
armazenado em um servidor na rede local que obtém informações dos vários
computadores pertencentes à rede, através de um script alocado nas estações
clientes. Tal script foi desenvolvido utilizando a linguagem Perl de programação, que
proporciona uma fácil utilização para implementação e correção. Esse script criará,
assim, um arquivo de texto contendo todas as informações coletadas e enviará a
uma base de dados que permitirá verificar alterações nas configurações físicas de
cada equipamento através da interface do phpmyadmin, uma ferramenta bastante
utilizada para administrar bancos de dados. Este projeto apresenta conceitos
básicos sobre computadores, redes de computadores, e apresenta todas as
tecnologias utilizadas no decorrer da pesquisa e desenvolvimento das partes do
sistema encontradas neste trabalho.
Palavras-chave: Computadores. Administração de Redes.
ABSTRACT
Managing a computer network is a task that involves various routines, ranging
from verification of network components to create a documentation containing
information about them. The purpose of this study is to provide the basic idea for the
development of a tool to assist the networks computer administrator, with the task of
maintaining an inventory of workstations that compose their environment as well as
internal components and their characteristics. The aim is to create a system stored
on a server in the local network that obtains information from multiple computers
within the network through a script allocated on the client stations. This script was
developed using the Perl programming language, which provides an easy to use
implementation and correction. This script creates thus a text file containing all the
information collected and will send it to a database which will allow the administrator
to verify changes of physical configuration of each device through the interface
phpmyadmin a widely used tool to manage databases. This project presents the
basic concepts of computers, computer networks, and features all the technologies
used during the research and development of parts of the system that is found in this
work.
Keywords: Computers. Network Management.
LISTA DE ILUSTRAÇÕES
Figura 1.1 ............................................................................................................. 26
Figura 1.2 ............................................................................................................. 28
Figura 1.3 ............................................................................................................. 28
Figura 1.4 ............................................................................................................. 30
Figura 1.5 ............................................................................................................. 32
Figura 1.6 ............................................................................................................. 35
Figura 2.1 ............................................................................................................. 39
Figura 2.2 ............................................................................................................. 41
Figura 3.1 ............................................................................................................. 55
Figura 3.2 ............................................................................................................. 56
Figura 3.3 ............................................................................................................. 57
Figura 3.4 ............................................................................................................. 57
Figura 3.5 ............................................................................................................. 58
Figura 3.6 ............................................................................................................. 58
Figura 3.7 ............................................................................................................. 59
SUMÁRIO
RESUMO .......................................................................................................... 5
Introdução ....................................................................................................... 11
1 Computadores ............................................................................................. 13
1.1 Hardware ............................................................................................... 14
1.2 Software ................................................................................................ 16
1.3 Sistema Operacional ............................................................................. 16
1.3.1 Windows ......................................................................................... 17
1.3.2 Linux ............................................................................................... 20
1.4 Redes de Computadores ...................................................................... 26
1.4.1 Modelo Cliente-Servidor ................................................................. 27
1.4.2 Modelo de Referência OSI ............................................................. 31
1.4.3 Modelo de Referência TCP/IP ........................................................ 34
2 Tecnologias utilizadas.................................................................................. 38
2.1 HTML .................................................................................................... 38
2.2 Servidor HTTP Apache ......................................................................... 41
2.2.1 Funcionamento ............................................................................... 42
2.3 PHP ....................................................................................................... 44
2.4 Perl ........................................................................................................ 45
2.5 Banco de dados .................................................................................... 49
2.6 Schtasks................................................................................................ 50
3 Implementação ............................................................................................ 51
3.1 LAMP .................................................................................................... 51
3.1.1 Debian Linux ................................................................................... 51
3.1.2 Apache ........................................................................................... 52
3.1.3 PHP ................................................................................................ 54
3.1.4 MariaDB .......................................................................................... 54
3.2 Instalação do módulo mysql no cliente windows ................................... 54
3.3 Agendamento de execução do script .................................................... 55
3.3.1 Agendamento no Windows por Schtask ......................................... 56
3.3.2 Agendamento no Linux por Cron .................................................... 56
3.4 Resultados ............................................................................................ 57
4 Conclusão .................................................................................................... 60
ANEXO A - Script Windows ............................................................................ 62
ANEXO B – Script Linux ................................................................................. 73
ANEXO C – Agendar execução do script no Linux ......................................... 80
ANEXO D – Arquivo de saída do script .......................................................... 83
Referências Bibliográficas .............................................................................. 96
11
INTRODUÇÃO
Atualmente há uma enorme quantidade de tecnologias que auxiliam o homem
nas mais diversas atividades. Todavia, com o surgimento da informática, houve um
grande ganho em certas atividades, pois muitas das tecnologias envolvidas
automatizam processos e executam ciclos de processo de forma extremamente
rápida, acima da capacidade humana. De fato, os recursos computacionais
trouxeram muitos ganhos para a humanidade, e estão atualmente tão infiltrados no
cotidiano que é difícil encontrar uma atividade em que a tecnologia da informação
não esteja envolvida direta ou indiretamente.
É comum no cenário empresarial uma situação em que há muitos
computadores interligados trocando informações entre si e até mesmo com outros
computadores em locais distantes, normalmente controlados por um ou mais
computadores centrais denominados “servidores”, caracterizando assim uma rede
de computadores.
Normalmente, quanto maior uma empresa é, mais computadores e
equipamentos de tecnologia esta tende a possuir, para que a grande quantidade de
funcionários tenha condições de executar suas funções dentro da empresa com
maior desempenho. Todavia, quanto maior o volume de equipamentos de
informática, mais difícil é a tarefa de gerenciar estes equipamentos e manter um
inventário atualizado dos componentes tecnológicos da empresa.
Com base nesse problema, esse trabalho pretende o desenvolvimento de um
sistema que permita criar um inventário dos componentes internos de cada
computador presente em uma rede de computadores, que permitirá, entre outros
recursos, gerar relatórios periódicos para comparação com relatórios anteriores,
visando diferenças nas configurações internas dos computadores desta rede.
O capítulo um apresenta conceitos base sobre computadores e seus
componentes principais, e em seguida apresenta o conceito de redes de
computadores. No capítulo dois são apresentadas as tecnologias de software e
linguagens de programação utilizadas para o desenvolvimento deste trabalho. O
capítulo três dispõe os métodos utilizados para a implementação das tecnologias
apresentadas anteriormente, apresentando exemplos de código e configurações
12
quando necessário. Todos os códigos de implementação estão dispostos na área de
Anexos, no final deste documento.
13
1 COMPUTADORES
Definir o significado de uma palavra pode ser algo complicado, especialmente
porque a definição não depende apenas de quem está falando, mas também de
quando se está falando. Atualmente, um computador é algo que você pode
facilmente carregar, ou ao menos pode prontamente levantar com as próprias mãos.
Há cerca de 30 anos atrás, seria necessária a ajuda de uma ou duas pessoas para
carregar um computador e, há cerca de 60 anos, um computador ocuparia uma sala
inteira. (ROSCH, 2003)
Cada um dos três últimos séculos passados foram marcados por uma
determinada tecnologia. O século XVIII foi marcado pelos grandes sistemas
mecânicos que acompanharam a Revolução Industrial. O XIX foi marcado pelo
surgimento das máquinas a vapor. Quanto ao século XX os avanços tecnológicos
mais marcantes se deram no campo da aquisição, processamento e distribuição de
informações.
Dentre os inúmeros outros desenvolvimentos, a civilização humana
presenciou a instalação das redes de telefonia em escala global, a invenção do rádio
e da televisão, o nascimento e evolução assombrosa da indústria da informática e o
lançamento dos satélites de comunicação na órbita terrestre. (TANENBAUM, 2003)
Estritamente falando, um computador é algo que serve para computar ou
calcular. Todavia, analisando a palavra mais a fundo, ela não designa
necessariamente uma máquina eletrônica. Inicialmente o termo computador foi
aplicado à pessoas cuja função era realizar cálculos matemáticos, utilizando papel,
lápis ou caneta e sua habilidade matemática.
As primeiras máquinas designadas para fins de realizar cômputos eram
chamadas de calculadoras, não importando quão elaboradas elas pudessem ser.
Charles Babbage (1791 – 1871), um cientista e matemático inglês, conceituou uma
máquina que pudesse substituir os computadores humanos. Babbage idealizou sua
máquina, a qual chamou de máquina analítica, como tendo três vantagens sobre os
computadores humanos: a máquina eliminaria os erros de cálculo, seria mais rápida
e mais barata.
Ele estava certo sobre os dois primeiros itens, mas como a máquina dependia
de técnicas bastante avançadas e caras na época, Babbage nunca chegou a ver sua
invenção concretizada. Todavia a máquina não era chamada de computador na
14
época de Babbage, estando o termo reservado às pessoas que desempenhavam a
função de calcular. (ROSCH, 2003)
O termo computador foi primeiramente aplicado à uma máquina somente
depois do surgimento da eletricidade. Uma das primeiras máquinas nessa categoria
foi financiada pela IBM (International Business Machines) e recebeu o nome de
Automatic Sequence Controlled Calculator, popularmente conhecida como Mark I.
Pesava cerca de 5 toneladas e era constituída por 750.000 peças. (ROSCH, 2003)
Desde então, os computadores, agora não mais designando pessoas que
calculavam, mas sim máquinas que calculavam, tiveram uma imensa evolução,
ficando com dimensões cada vez menores e mais leves, e aumentando sua
capacidade de processamento de dados. Deixaram de ser uma exclusividade dos
grandes laboratórios e passaram a fazer parte da vida das pessoas comuns.
Um
computador
pode
ser
dividido
em
dois
componentes
básicos
fundamentais: hardware e software.
1.1 HARDWARE
O termo Hardware designa todo componente físico de um computador, ou
seja, gabinete, monitor, mouse, teclado, processador, placa-mãe, etc. Em outras
palavras, é todo componente ou peça física que pode efetivamente ser tocada.
(FATEC GUARATINGUETÁ, 2011) Um computador possui vários componentes
físicos importantes para o seu funcionamento, que são apresentados nos itens a
seguir:

Processador:
Segundo
Morimoto
(2007),
o
processador
ou
microprocessador, também conhecido como CPU (Central Processing
Unit) pode ser analogamente comparado ao cérebro humano. Esse é o
componente responsável por processar a maior parte das informações
em um computador. Microprocessadores são os componentes físicos
mais complexos de um computador e, muitas vezes, o componente
mais caro.

Memória: Memória pode designar uma placa ou chip com circuitos
eletrônicos cuja função principal é armazenar informações à curto ou
longo prazo. Pode haver diversos tipos diferentes de memória em um
computador, e um dos principais é chamado de Memória RAM
15
(Random Access Memory). Esse tipo de memória é normalmente uma
placa com vários circuitos eletrônicos e chips usada pelo processador
para armazenar dados e programas que estão em execução. A
quantidade de memória RAM disponível tem impacto direto no
desempenho do computador, visto que se não houver memória RAM
suficiente, o processador passa a usar memórias alternativas que
possuem velocidade de leitura e escrita de informações muito inferiores
à memória RAM, como, por exemplo, a memória swap. A principal
característica da memória RAM é que esta é volátil, ou seja, quando há
interrupção na alimentação de energia elétrica, todas as informações
gravadas na memória RAM são permanentemente perdidas. É por
esse motivo que é necessário carregar novamente todas as
informações e programas para a memória RAM sempre que o
computador é ligado. (MORIMOTO, 2007)

Disco Rígido: O disco rígido ou HD (Hard Disk) é outro componente
de grande importância em um computador. Ao passo que a memória
RAM é como uma mesa de trabalho que é limpa sempre que o
computador é desligado, o HD é como um grande arquivo de escritório,
onde todos os programas e demais arquivos do sistema permanecem
armazenados. (MORIMOTO, 2007) Na maioria das vezes até mesmo o
próprio sistema operacional do computador está armazenado no HD. O
disco rígido é, basicamente, uma memória permanente, pois os
arquivos e informações nele gravados permanecem até que sejam
excluídos pela ação de um usuário ou de um programa. O HD mantém
os dados armazenados em discos magnéticos que podem guardar as
informações por vários anos. Esses discos giram à uma velocidade alta
e um conjunto de cabeças de leitura instaladas em braços mecânicos
móveis se encarrega de ler ou gravar informações em toda a extensão
dos discos. (MORIMOTO, 2007)

Placa de Vídeo: Ainda de acordo com o exposto por Morimoto (2007),
a placa de vídeo é um importante componente que, dependendo do
uso do computador, pode afetar diretamente no desempenho do
mesmo, pois concentra todo o trabalho pesado do processamento
gráfico, aliviando assim o processador principal. Atualmente as placas
16
de vídeo fornecem suporte para imagens 3D, e possuem grande
capacidade de processamento de imagens.

Placa-mãe: Ainda de acordo com o exposto por Morimoto (2007), a
placa de vídeo é um importante componente que, dependendo do uso
do computador, pode afetar diretamente no desempenho do mesmo,
pois concentra todo o trabalho pesado do processamento gráfico,
aliviando assim o processador principal. Atualmente as placas de vídeo
fornecem suporte para imagens 3D, e possuem grande capacidade de
processamento de imagens.
1.2 SOFTWARE
Os componentes físicos de um computador são bons para armazenar e
processar informações, mas eles não podem fazer nada sozinhos sem um conjunto
de instruções para seguir. Em todas as situações há uma pessoa fornecendo
instruções para o computador sobre o que fazer e como agir em determinadas
situações, seja o usuário utilizando o mouse ou o teclado ou o programador que
escreveu o conjunto de instruções que compõem o programa ou sistema operacional
que está sendo utilizado.
Para esse fim há a necessidade dos Software, que são um grande conjunto
de instruções que dizem ao hardware quais procedimentos adotar para as próximas
ações, e permitem ao computador executar coisas úteis. (MORIMOTO, 2007)
No dia a dia, ao utilizar um computador, na esfera dos software é utilizado um
sistema operacional, que é o software responsável por passar as informações para o
hardware, e sobre o sistema operacional são utilizados os software aplicativos que
são responsáveis por desempenhar as várias tarefas possíveis em um computador.
1.3 SISTEMA OPERACIONAL
O sistema operacional é normalmente um software de grandes proporções
responsável por receber as instruções de um utilizador ou, na maioria das vezes, de
um software aplicativo que está sendo utilizado por uma pessoa e convertê-las em
instruções para o hardware do computador.
Um bom sistema operacional deve ser invisível para a pessoa que o está
17
utilizando. Sua função é detectar e utilizar o hardware do computador de forma
eficiente, fornecendo uma base sólida e estável sobre a qual os programas utilizados
no dia a dia possam ser executados. Segundo Linus Torvalds, as pessoas não usam
o sistema operacional, usam os programas instalados no computador. Quando se
percebe que está usando um sistema operacional, é sinal de que alguma coisa não
está funcionando como deveria. (MORIMOTO, 2007)
O sistema operacional permite que um programador adicione funções úteis
sem se preocupar com o tipo exato de hardware presente no computador que
executará esse software. O programa apenas informa, por exemplo, que deseja
mostrar uma janela na tela. Qual o modelo de placa de vídeo instalada no
computador e quais os passos para executar a ação desejada ficam por conta do
sistema operacional. (MORIMOTO, 2007) O sistema operacional de um computador
é também responsável por coordenar o uso dos recursos em geral, tal como o uso
da memória RAM e a forma como as informações serão escritas no disco rígido do
computador.
Os sistemas operacionais passaram por uma grande evolução ao longo das
últimas décadas, assim como os computadores em geral. No cenário atual há dois
sistemas operacionais particularmente expressivos: Windows e Linux. O Windows é
sem dúvida alguma muito popular nas estações de trabalho pessoais e
computadores domésticos.
No que se refere ao Linux, apesar de nos últimos anos este sistema ter
ganhado um certo espaço no mercado de computadores pessoais, sua maior
expressividade está na utilização nos mais variados servidores, que são
computadores destinados a fornecer serviços para outros computadores. A seguir há
uma explanação mais detalhada quanto à esses dois sistemas operacionais.
1.3.1 Windows
Em meados da década de 70, época em que era comum a utilização de papel
carbono e mimeógrafos, uma dupla de entusiastas via um futuro próspero na
computação pessoal. No ano de 1975, Bill Gates e Paul Allen formam uma parceria
chamada Microsoft, e como toda parceria, esta se inicia pequena, no entanto, com
uma grande visão, colocar um computador em cada mesa e em cada casa.
(MICROSOFT, 2012)
18
Já no ano de 1980, Gates e Allen contratam um antigo colega de classe de
Gates em Harvard, Steve Ballmer, para que auxiliasse a cuidar da companhia. Ainda
no mesmo ano, a empresa IBM faz contato com a Microsoft sobre um projeto com o
codinome Chess (Xadrez -
traduzido literalmente). Em resposta, concentram-se
num novo sistema operacional (um software que gerencia, ou controla, o hardware
do computador e também serve para fazer a ligação entre o hardware e os
programas a serem utilizados). Eles o chamaram de MS-DOS, Microsoft Disk
Operating System (Sistema Operacional em Disco da Microsoft).
Quando o IBM PC com MS-DOS começou a ser vendido, em 1981, ele
apresentou uma linguagem totalmente nova para o público em geral, tornando
comandos como o “C:” algo comum no dia a dia das pessoas. (MICROSOFT, 2012)
Visando tornar o sistema mais simples à todas as pessoas, a Microsoft
começa a trabalhar num projeto intitulado Interface Manager (Gerenciador de
Interface), no entanto escolhem um outro nome, Windows (Janelas), por descrever
melhor as caixas ou “janelas” que são a grande inovação do novo sistema. O
sistema Windows foi anunciado em 1983, mas leva um grande tempo para ser
desenvolvido, sendo chamado, por muitos, de “vaporware”, um software anunciado,
mas que nunca é/foi desenvolvido.
Em 20 de novembro de 1985, dois anos após o anúncio inicial, a Microsoft
começa a vender o Windows 1.0. Assim, ao invés de digitar comandos, bastaria
mover o mouse (rato – tradução literal) para apontar e clicar nas telas ou “janelas”.
O Windows 1.0 requeria um mínimo de 256 quilobytes (KB), duas unidades de
disquete de dupla face e uma placa adaptadora gráfica. (MICROSOFT, 2012)
Na data de 9 de dezembro de 1987, foi lançado o Windows 2.0, possuindo
ícones na área de trabalho e memória expandida, é nesse momento que os
primeiros Software são programados por desenvolvedores com base no sistema
operacional Windows. E também, é a primeira vez que é utilizado o Painel de
Controle nos sistemas Windows.
O Windows 2.0 foi desenvolvido para a plataforma Intel 286. Quando o
processador Intel 386 foi lançado, o Windows/386 veio logo em seguida, para
aproveitar os recursos de memória estendida. (MICROSOFT, 2012)
No dia 20 de maio de 1990, foi lançado o Windows 3.0 seguido pelo Windows
3.1, em 1992. Já nessa versão 3.0, as características gráficas começam a se
assemelhar ao que vemos atualmente. Graças à utilização da Memória Virtual para
19
melhorar o gráfico, obtém-se um melhor desempenho, com gráfico de 16 cores e
ícones aperfeiçoados. É também, nesta versão, que o Gerenciador de Programas, o
Gerenciador de Arquivos e o Gerenciador de Impressão são apresentados como
ferramentas de inovação. (MICROSOFT, 2012)
A popularidade do sistema aumenta com o lançamento de um kit para
desenvolvimento de software, o SDK (Software Development Kit), que auxiliou os
desenvolvedores a focarem-se mais no desenvolvimento de programas do que no
desenvolvimento de drivers de dispositivo.
E com o lançamento do Windows for Workgroups 3.11, integra-se o suporte a
grupos de trabalho ponto a ponto e redes de domínio, além de demonstrar as
primeiras evoluções da computação cliente/servidor. (MICROSOFT, 2012)
Em 24 de agosto de 1995, é obtido o recorde de 7 milhões de cópias
vendidas com o Windows 95, somente nas primeiras 5 semanas.
Com a ascensão da internet, o Windows 95 já vem com redes dial-up, e no
segundo semestre do mesmo ano, é lançada a primeira versão do navegador
Internet Explorer.
Com uma visão mais voltada a consumidores, a Microsoft lança o Windows
98, o último sistema operacional desenvolvido com base no MS-DOS.
Já visando uma mudança nos aspectos gráficos e técnicos, lançou-se o
Windows Me, no entanto seria o último sistema a ser baseado no kernel do Windows
95, passando assim a utilizar o kernel do Windows NT e Windows 2000, que foi
lançado com o intuito de substituir o Windows 95, Windows 98 e Windows NT
Workstation 4.0, trazendo maior estabilidade, facilidade de uso e suporte a
computação móvel. (MICROSOFT, 2012)
Com disponibilidade em até 25 idiomas, o Windows XP foi lançado em 25 de
outubro de 2001, tendo o sistema de ajuda e suporte unificado e sendo
disponibilizado em versões Home Edition e Professional. Houveram variações com o
passar dos anos, sendo elas a elaboração de um sistema com suporte a
processadores de 64 bits, versão para multimídia e uma versão para Teblet Pc.
(MICROSOFT, 2012)
Com um visual mais moderno, design distinto e combinações de diferentes
recursos, o Windows Vista foi lançado em 2006, visando um público móvel maior,
pois a venda de notebooks e laptops aumentou consideravelmente em relação aos
desktops e em outubro de 2009 foi lançado o Windows 7. Possui suporte a
20
dispositivos touch, alterando a maneira como se interage com as janelas e melhor
suporte a redes sem fio.
Atualmente, há a discussão sobre computação nas nuvens e a tendência
exercida sobre a utilização de e-mails, redes sociais e mensageiros instantâneos,
enquanto uma nova versão intitulada “Windows 8” está sendo desenvolvida.
(MICROSOFT, 2011)
1.3.2 Linux
Em 1991, Linus Torvalds, um estudante finlandês, deu início a um projeto de
escrita de um kernel para um sistema operacional próprio. Seu projeto tinha por
objetivo criar um sistema que substituísse o Minix, sistema amplamente utilizado nas
Universidades da época, com as mesmas funcionalidades e com um pequeno
diferencial, que não custasse nada, inclusive para ele mesmo.
Após escrever o primeiro projeto de kernel, o kernel 0.02, disponibilizou-o na
Usenet, a predecessora da atual internet, para que outras pessoas pudessem baixálo e assim utilizá-lo e, se possível, ajudá-lo a melhorar o projeto. Nesse primeiro
passo, não tão somente, criou um clone substituto do Minix, mas sim uma
verdadeira comunidade de trabalho espalhada pelo mundo todo, o que fez com que
seu tal sistema chegasse a um ponto de estabilidade e usabilidade que o
possibilitava fazer frente a sistemas proprietários dos tipos mais sofisticados, nos
mais diversos campos de atuação, sendo capaz de utilizar seus próprios erros, e os
da concorrência, para se aperfeiçoar.
Por tal motivo, pode-se afirmar que o sistema operacional Linux é um sistema
inteligente, mesmo estando limitado aos recursos atuais de inteligência artificial, bem
como um sistema com desenvolvimento inteligente, devido aos fatores técnicos e
relacionamento das equipes de desenvolvimento.
Por isso, diz-se que o Linux é descendente dos antigos sistemas UNIX, e não
um clone como muitos afirmam que seja. Outro ponto importante a ser abordado
quanto ao Linux é que a nomenclatura correta a ser utilizada é GNU/Linux, dada a
herança de comandos e ferramentas que possui oriundas do sistema GNU,
desenvolvido por Richard Stallman e sua FSF (Free Software Foundation).
Com base em tais fatos, pode-se, também, considerar a ideia de que o Linux
seja a concretização, na forma de um sistema operacional estável, de toda a filosofia
21
da FSF, que se baseia nas quatro “liberdades” do software livre. São essas:

Liberdade número zero: executar o programa, qualquer que seja o
propósito;

Liberdade número um: estudar como o programa funciona para adaptálo às suas necessidades. Para tanto, é pré-requisito ter acesso ao
código fonte do programa, desenvolvido por seus criadores;

Liberdade número dois: redistribuir cópias de modo que você possa
ajudar o seu próximo;

Liberdade número três: aperfeiçoar o programa e disponibilizar os
resultados, de modo que toda a comunidade se beneficie. O acesso ao
código fonte é, novamente, um pré-requisito;
De uma forma abrangente e simples, pode-se ver que as principais
características do Linux satisfazem cada uma das “liberdades” citadas. Sendo um
sistema com código fonte aberto, é possível realizar modificações em um programa,
ou no próprio sistema, visando a otimização ou a correção de falhas de segurança.
Com o fácil acesso ao código, foram criadas comunidades de programadores
independentes que interagem com os desenvolvedores “oficiais”. Dessa forma,
correções e métodos de otimização do software são aplicados em espaço reduzido
de tempo, ao contrário do que ocorre com o software proprietário. A documentação
acessível propicia o fator segurança, pois erros no código são encontrados e
consertados rapidamente. Por fim, o sistema é gratuito e as licenças nele utilizadas
são regidas pelo modelo GPL (General Public License). Mesmo nas situações nas
quais são cobrados os manuais e as mídias com o sistema e seus pacotes, o valor
total do sistema e dos Software agregados chega a representar ¼ do valor de
sistemas proprietários e Software equivalentes.
Atualmente, muitas empresas vêm adotando o uso de sistemas Linux, seja
por sua flexibilidade ou por seu custo-benefício. (CARMONA, 2007)
Uma curiosidade sobre o Linux, não se referindo ao sistema em si ou seu
conteúdo, é o logo adotado por seu criador, Linus Torvalds, um pinguim. Chamado
de TUX, a mascote foi adotada após uma viagem de Linus ao hemisfério sul, onde
encontrou um pinguim (não tão semelhante ao do logo), e quando tentou acariciá-lo,
levou uma bicada no dedo.
Mesmo não possuindo uma referência lógica entre os fatos, o logo simboliza
“the carefree attitude of total movement”. (RHASAN, 2005)
22
1.3.2.1 Distribuições
Ao conjunto constituído pelo kernel, comandos e ferramentas e outros
aplicativos e utilitários dá-se o nome de distribuição.
Uma distribuição Linux, é um projeto que utiliza o kernel do Linux, e possui
diversas modificações e especificações, bem como toda uma diretriz e propósitos
seguidos pelos desenvolvedores, a comunidade e os usuários do sistema.
Existem mais de 350 distribuições conhecidas atualmente, com diversos
propósitos e enfoques. No entanto, a maioria delas é baseada em outras
distribuições conhecidas como mega distribuições, que vêm se mantendo ao longo
dos anos através de patrocinadores e mantenedores dos projetos. Algumas
distribuições que se enquadram como sendo mega distribuições são o Debian,
Slackware, Red Hat e Suse. Oriundas dessas, temos as mais conhecidas Ubuntu e
Linux Mint, baseados em Debian, Vector Linux e Slax, baseados em Slackware,
Fedora, baseado em Red Hat e Open Suse, versão gratuita do Suse. (CARMONA,
2007)
1.3.2.1.1 Red Hat Linux
O Red Hat Linux, assim como o Slackware Linux, é uma das distribuições
mais antigas. Até o mês de dezembro de 2003, manteve-se com o mesmo nome,
mudando apenas o número da versão a que se refere. Após este marco, adotou o
nome de Red Hat Enterprise Linux, sendo recomendado para servidores, passando
a ser mais restritivo e cobrando por suporte ao sistema operacional. Nesse mesmo
tempo, deu origem à distribuição Fedora Core, mais voltado para desktops e
usuários finais, que também possui uma versão paga.
O termo Red Hat refere-se à divisão dos grupos hacker dos Estados Unidos e
Europa, em relação à sua orientação, sendo Black Hats os hackers de má índole, ou
crackers, os White Hats os hackers de boa índole e os Grey Hats os hackers que
não assumiam uma tendência, vivendo assim no limiar entre outros.
Os pacotes de instalação do Red Hat Linux são os RPM, que agem de forma
a tornar a instalação e configuração de aplicativos e ferramentas simples e rápida.
Este padrão de pacotes também é utilizado pelo Fedora Core, Suse Linux e
Mandriva Linux. (CARMONA, 2007)
23
1.3.2.1.2 Suse Linux
A distribuição Suse Linux pertenceu à uma empresa alemã com o mesmo
nome da distribuição, SuSE. Atualmente ela é propriedade da empresa Novell, que a
mantém.
O nome SuSE refere-se ao termo alemão Software und System Entwicklung
(Desenvolvimento de Software e Sistemas) que era o ramo ao qual a antiga
empresa era voltada.
A intenção inicial do Suse quando criado por 4 estudantes universitários em
1992, era criar um sistema customizado para seus clientes, com base no Slackware
Linux. Contudo, pela falta de ferramentas de configuração mais amigáveis no
Slackware, o grupo decidiu basear-se no Jurix Linux, uma distribuição não mais
existente, que possuía muitas ferramentas e aplicações muito mais indutivas e
amigáveis.
A distribuição, atualmente, intercala ferramentas GNU e Software licenciados,
ou que não são regidos pela licença GPL, o que a tornou uma distribuição
GNU/Linux comercial, assim como o Red Hat Enterprise Linux. (CARMONA, 2007)
1.3.2.1.3 Slackware Linux
Uma das mais antigas distribuições ainda existentes, foi idealizada e
desenvolvida por Patrick Volkerding, e foi concebida com a ideia de ser o mais fiel
possível ao kernel original criado por Linus Torvalds.
Baseando-se no conceito KISS (Keep It Simple, Stupid), rejeita ferramentas
de configuração que possam esconder do usuário o real funcionamento do sistema.
Além disso, o Slackware é composto somente por aplicativos estáveis, mesmo que
estes sejam versões bem desatualizadas, mas isso que o faz manter-se estável.
Como dito anteriormente, o mesmo não possui uma ferramenta de instalação
de pacotes automática, tendo que muitas vezes compilar o pacote e instalá-lo de
forma manual, o que também o torna uma das distribuições mais estáveis, pois a
compilação de uma aplicação feita para o próprio sistema e hardware correntes são
as melhores escolhas para quem busca um ganho de desempenho e produtividade
pelo mesmo. No entanto, trabalha com pacotes TGZ, que é um pacote aceito por
todas as distribuições.
24
Devido a esses fatores, o Slackware muitas vezes é tido como uma
distribuição ruim para usuários iniciantes. (CARMONA, 2007)
1.3.2.1.4 Debian Linux
Debian é, ao mesmo tempo, o nome de uma distribuição não comercial do
kernel GNU/Linux e de um grupo de desenvolvedores voluntários espalhados pelo
mundo, que o mantêm. É chamado, usualmente, de Debian GNU/Linux, por ser
fortemente estruturado tanto na filosofia quanto na concepção e utilização de
ferramentas do projeto GNU, o que faz com que seja a distribuição oficial do projeto.
O Debian foi criado em 1993, pelo estudante Ian Murdock, e começou como
um manifesto filosófico antes de se transformar em sistema utilitário. Ian apelava em
seu Manifesto Debian à criação de uma distribuição GNU/Linux que se mantivesse
aberta, de acordo com o espírito do Linux, criado por Linus Torvalds, e do projeto
GNU da FSF de Richard Stallman.
Seu sistema de empacotamento é o dpkg, sendo um sistema que, nos últimos
anos, ganhou muita notoriedade devido à sua alta taxa de compactação. O resultado
da compactação desse sistema é um arquivo DEB.
Em 1996, Bruce Perenes substituiu Ian Murdock como líder do projeto,
deixando o projeto em 1998.
O ciclo de desenvolvimento das versões dessa distribuição passa por três
fases: Unstable (instável), Testing (teste) e Stable (estável).
Uma notação interessante é que quando uma versão está na fase testing é
identificada por nomes retirados dos personagens do filme Toy Story. Quando
promovidas a stable passam a ser conhecidas por números, e toda versão unstable
é conhecida como Sid.
Como exemplo, pode-se encontrar a primeira versão stable do Debian Linux,
a versão 1.1, de 1996 que, quando testing, possuía o nome de Buzz, referenciando
o personagem Buzz Lightyear.
Tudo no Debian tem como princípio a estabilidade. A versão demora muito
tempo para se tornar estável, e é apenas composta por aplicações, pacotes e kernel
que sejam estáveis, mesmo que suas versões não sejam as mais atuais.
(CARMONA, 2007)
25
1.3.2.2 APT (Advanced Package Tool)
Considerando-se os gerenciadores de pacotes, o APT, dentre todos os
existentes, é o mais maduro. Utilizando esta ferramenta pode-se até mesmo
atualizar um sistema inteiro, com seus Software, através de uma única linha de
comando.
Um outro pacote que utiliza os mesmos recursos é o APT-RPM.
Originalmente o APT suporta apenas pacotes.deb, no entanto esta outra possibilita a
utilização de pacotes .rpm como no gerenciador YUM, utilizado pela distribuição
Fedora.
O apt-get faz a cópia e atualização de pré-requisitos de um espelho contido
no arquivo /etc/apt/sources.list, o que auxilia e torna mais fácil a instalação e
atualização de Software e pacotes nos sistemas baseados na distribuição Debian.
Para configurar o arquivo, é necessário editá-lo e inserir as URL's que
apontam para um arquivo, CD-ROM, servidor HTTP ou servidor FTP, onde se
encontram os pacotes.
As URL's podem ser de uma distribuição específica (na verdade, um nome de
versão da distribuição) ou genéricas (sendo divididas entre os pacotes estáveis e
experimentais). (NEMETH; SNYDER; HEIN, 2004)
Assim, compõe-se uma URL com as seguintes informações:
Formato geral: tipo uri / distribuição [componentes]
A Figura 1.1 apresenta um exemplo de arquivo /etc/apt/sources.list.
De
fato,
hardware
e
software
são
conceitos
fundamentais
sobre
computadores modernos e constituem a base desta ciência. Neste capítulo foram
introduzidos estes conceitos fundamentais, assim como foi apresentado um pouco
de sua origem. No capítulo seguinte serão abordados com mais ênfase as
tecnologias que serão utilizadas no desenvolvimento da ferramenta proposta por
esse trabalho.
26
Figura 1.1 - Apresentação do arquivo de configuração de repositórios
Fonte do autor
1.4 REDES DE COMPUTADORES
Nesse capítulo será apresentado um panorama das redes de computadores,
explicando o que é uma rede de computadores, como ela é composta e quais são os
equipamentos mais comuns que compõem uma rede de computadores. Também
será apresentado o conceito de divisão de uma rede de computadores em camadas,
e para isso serão apresentados dois principais modelos de divisão em camadas, o
modelo de referência OSI e o modelo de referência TCP/IP.
Apesar de ser relativamente muito jovem em relação à outros setores
industriais, como o setor de automóveis ou aeronaves, a indústria da informática
vivenciou um desenvolvimento espetacular em um curto intervalo de tempo.
(TANENBAUM, 2003)
Nos vinte primeiros anos de sua existência os sistemas computacionais eram
centralizados. Era comum que uma empresa de médio porte ou uma universidade
possuíssem apenas um ou dois computadores, e as grandes instituições possuíam
não mais do que algumas dezenas deles. Eram equipamentos de grandes
proporções que chegavam a ocupar o espaço de uma sala inteira. A ideia de que em
apenas vinte anos existiriam milhões de computadores igualmente avançados e do
tamanho de um selo postal não passava de ficção científica. (TANENBAUM, 2003)
27
Com a consequente fusão entre computadores e comunicações, o conceito
de “centro de computação” como sendo uma sala com um grande computador para
onde os usuários levam seus trabalhos para serem processados torna-se
completamente obsoleto. Este velho modelo passa a ser substituído pelas
chamadas redes de computadores, onde os trabalhos são realizados por um grande
número de computadores independentes, mas interconectados. (TANENBAUM,
2003)
Uma rede de computadores é um conjunto de dois ou mais computadores
autônomos interligados entre si através de um meio físico. Uma rede de
computadores pode incluir não apenas computadores, mas uma série de outros
equipamentos diferentes. Diz-se que dois computadores estão interconectados
quando podem trocar informações entre si. (TANENBAUM, 2003)
Na realidade de uma empresa de pequeno porte é comum que todos os
computadores estejam em um único escritório ou em um mesmo prédio. No caso de
empresas de grande porte, normalmente os computadores localizam-se em vários
locais separados geograficamente, muitas vezes em cidades ou até mesmo países
diferentes. Ainda no ambiente empresarial é comum que haja computadores com
grande capacidade que armazenam informações ou disponibilizam determinados
serviços na rede para os demais computadores. Esses computadores são chamados
de servidores. Em contrapartida, os funcionários da empresa possuem em suas
mesas computadores menos potentes com os quais executam tarefas básicas e
acessam informações e serviços fornecidos pelos servidores. Esses computadores
mais simples são chamados clientes. Nesses cenários está o conceito de um
modelo de rede de computadores chamado cliente-servidor, que é abordado no
item seguinte.
1.4.1 Modelo Cliente-Servidor
A Figura 1.2 apresenta de uma forma simplificada o modelo cliente-servidor.
Esse modelo é largamente empregado, tanto quando os computadores estão a uma
curta distância geográfica, quanto quando estão separados geograficamente por
longas distâncias. Por exemplo, quando uma pessoa em sua casa utiliza seu
computador para acessar uma página na internet, esse mesmo modelo clienteservidor é empregado. Nesse caso o computador remoto onde a página está
28
armazenada atua como servidor, e o computador pessoal de quem acessou essa
informação atua como cliente. (TANENBAUM, 2003)
Figura1.2 - Modelo Cliente-Servidor
Fonte: Tanenbaum, 2003, p. 20
Analisando o modelo cliente-servidor com maior detalhamento percebe-se
que há basicamente dois processos envolvidos na comunicação, conforme
apresentado pela Figura 1.3. Nesse tipo de comunicação um processo executando
no computador cliente envia uma mensagem através da rede para o computador
servidor e permanece aguardando uma resposta. O servidor, por sua vez, recebe a
mensagem através de um processo sendo executado nele mesmo trata de executar
o trabalho solicitado ou procura pelos dados solicitados, enviando de volta para o
cliente uma resposta. Assim, de forma resumida, no modelo cliente-servidor é
utilizado o método de trabalho com solicitações e respostas.
Figura 1.3 – Solicitação e resposta entre cliente e servidor
Fonte: Tanenbaum, 2003, p. 20
Os dispositivos que se conectam em uma rede o fazem através de um meio
físico, chamado enlace, que pode ser de vários tipos, entre eles cabos coaxiais, fios
29
de cobre, fibras óticas e ondas de rádio. No jargão da Internet, esses dispositivos
são chamados de sistemas finais. (KUROSE; ROSS, 2010)
De forma simples, quando um sistema final necessita enviar dados a outro
sistema final, o sistema responsável por trafegar esses dados segmenta-os e
adiciona bytes de cabeçalho a cada segmento. Esses segmentos, denominados
pacotes, são então enviados ao dispositivo destino através da rede, onde são
reagrupados, reconstruindo assim a informação original. (KUROSE; ROSS, 2010)
No trajeto através da rede, os pacotes passam por comutadores de pacotes,
que são dispositivos responsáveis por receber os pacotes através de um de seus
enlaces de entrada e retransmiti-lo através de um de seus enlaces de saída, de
forma que os pacotes cheguem à seus destinos. Há diferentes tipos de comutadores
de pacotes, mas os mais utilizados na Internet atual são os roteadores e os
comutadores de camada de enlace, também conhecidos como switches. A
sequência de enlaces e comutadores que os pacotes percorrem desde sua origem
até o seu destino é conhecida como rota ou caminho através da rede. (KUROSE;
ROSS, 2010)
Todavia, não basta apenas conectar os dispositivos para que haja
comunicação entre eles. Os sistemas finais, comutadores de pacotes e outros
elementos que compõem uma rede utilizam protocolos que controlam o envio e o
recebimento de informações. Os dois protocolos mais utilizados atualmente nas
redes são o TCP (Transmission Control Protocol) e o IP (Internet Protocol). Por
serem os dois principais protocolos da Internet atual, são comumente conhecidos
coletivamente como TCP/IP. Entretanto há uma enorme quantidade de outros
protocolos responsáveis por serviços específicos em uma rede, como por exemplo o
SMTP (Simple Mail Transfer Protocol) para mensagens de correio eletrônico, entre
outros. (KUROSE; ROSS, 2010)
Conforme rege a regra de etiqueta da comunicação humana, quando se quer
obter uma informação de outra pessoa deve-se primeiramente cumprimentá-la,
como é o caso do primeiro “oi” da Figura 1.4. A resposta comum é um outro “oi”, que
indica que a outa pessoa está receptiva para que o diálogo prossiga. Caso a
resposta recebida seja algo diferente desse cumprimento esperado, como por
exemplo um “Não perturbe” ou um “Eu não falo seu idioma”, ou até mesmo a não
obtenção de resposta, pode ser indício de que a outra pessoa não está receptiva
para conversar no momento ou que há um problema que impeça a comunicação.
30
Nesse caso normalmente a pessoa que iniciou a comunicação desiste de prosseguir
com o diálogo. Porém, no caso da resposta positiva, a pessoa que iniciou o diálogo
pode requisitar uma informação, e poderá (ou não) receber a resposta desejada. Se
as pessoas executarem “protocolos” diferentes, como por exemplo se uma pessoa
tem boas maneiras e a outra não, ou se uma pessoa entende o conceito de horas
mas a outra não, então os protocolos não interagem e nenhuma informação útil é
transmitida. O mesmo vale para redes. É preciso que duas ou mais unidades
comunicantes executem o mesmo protocolo para que possa haver comunicação e
algum trabalho possa ser feito.
Figura 1.4 – Analogia entre comunicação humana e protocolos de rede
Fonte: KUROSE; ROSS, 2010, p. 32
Um protocolo de rede é semelhante ao protocolo de comunicação humano. A
diferença é que a comunicação em redes é realizada por hardware ou software de
algum equipamento eletrônico. Todas as atividades em redes de computadores que
envolvem dois ou mais dispositivos comunicantes são regidas por protocolos
específicos. (KUROSE; ROSS, 2010)
Como exemplo do funcionamento de um protocolo bastante familiar para
quem utiliza a Internet atualmente, a Figura 1.4 apresenta de forma simples o
mecanismo de uma requisição a um servidor Web, ou seja, quando alguém digita
31
um endereço de Internet no navegador de internet de seu computador.
Primeiramente o computador enviará uma mensagem de requisição de conexão ao
servidor Web e permanecerá aguardando uma resposta. O servidor Web, por sua
vez, receberá essa mensagem de requisição de conexão e retornará uma
mensagem de resposta de conexão. Dessa forma o computador que requisitou a
conexão sabe que está tudo OK para prosseguir. Esse computador envia então para
o servidor Web o nome da página que deseja buscar naquele servidor através de
uma mensagem GET. Por fim, o servidor retorna para o computador solicitante um
arquivo que representa a página da Web solicitada.
1.4.2 Modelo de Referência OSI
Conforme mencionado anteriormente, durante o processo de trânsito dos
pacotes através de uma rede há protocolos controlando cada etapa. “Para prover
uma estrutura para o projeto de protocolos de rede, projetistas de rede organizam
protocolos – e o hardware e o software de rede que implementam os protocolos –
em camadas.” (KUROSE; ROSS, 2010) Cada um dos protocolos de rede pertencem
à uma camada, e cada uma das camadas provê determinados serviços necessários
para cada etapa do processo de transporte dos pacotes de rede, executando ações
dentro dela mesma e utilizando serviços da camada diretamente anterior a ela.
(KUROSE; ROSS, 2010)
No final dos anos 1970, a ISO (International Organization for Standardization)
propôs que as redes de computadores fossem organizadas em 7 camadas
diferentes, e este padrão foi denominado de modelo de Interconexão de Sistemas
Abertos, conhecido como Modelo de Referência ISO OSI (Open Systems
Interconection model). (KUROSE; ROSS, 2010) Recebe esse nome por tratar da
interconexão de sistemas abertos, ou seja, sistemas que estão abertos à
comunicação com outros sistemas. Por motivo de abreviação, será abordado nesse
trabalho simplesmente como modelo OSI.
A Figura 1.5 representa de forma simples as sete camadas do modelo OSI,
cujas funcionalidades serão abordadas na sequência.
32
Figura1.5 – Camadas do modelo OSI
Fonte: Ventura, 2002

Camada Física: Trata da transmissão dos bits propriamente ditos
através de um canal de comunicação. O projeto da rede deve garantir
que se um bit com valor 1 for transmitido de um lado, ele deve chegar
com valor 1 do outro lado, não com valor 0. Para isso o mais comum é
definir qual a voltagem utilizada para representar um bit de valor 1 e
um bit de valor 0, quantos nano segundos deve durar a contagem de
um bit, se a transmissão de bits poderá ser realizada em ambos os
sentidos simultaneamente ou se será somente unilateral, como será
estabelecida a conexão inicial e de que forma esta será encerrada
quando ambos os lados tiverem terminado a comunicação, e até
mesmo quantos pinos o conector de rede deverá ter e qual a finalidade
de cada pino. Nessa camada a maioria das questões estão
relacionadas com interfaces mecânicas, elétricas e de sincronização, e
com o meio físico de transmissão que se localiza logo abaixo dessa
camada. (TANENBAUM, 2003)

Camada de Enlace de Dados: Segundo Tanenbaum (2003), “a
principal tarefa da camada de enlace de dados é transformar um canal
de transmissão bruta em uma linha que pareça livre de erros de
transmissão não detectados para a camada de rede”. Para isso, essa
camada faz com que o transmissor divida os dados em quadros de
dados e os transmita sequencialmente, e o receptor confirma a
33
recepção de cada quadro enviando como resposta um quadro de
confirmação. A camada de enlace de dados também tenta impedir que
um transmissor rápido envie uma quantidade excessiva de quadros à
um receptor demasiado lento. (TANENBAUM, 2003)

Camada de Rede: É a camada responsável por controlar as
operações da rede em geral. Uma questão fundamental é determinar
como os dados serão roteados da origem até o destino. Essas rotas
dos pacotes podem se basear em tabelas estáticas de roteamento, que
raramente são alteradas, podem ser determinadas no início de cada
conversação, ou podem ser altamente dinâmicas, sendo determinadas
para cada pacote transmitido. (TANENBAUM, 2003) Caso haja muitos
pacotes trafegando pela rede simultaneamente, dividindo o mesmo
caminho, podem haver congestionamentos na comunicação, e o
controle desses congestionamentos também pertence à camada de
rede. Quando um pacote deve viajar de uma rede para outra para
alcançar seu destino há uma série de problemas que podem ocorrer no
percurso. O endereçamento utilizado pela segunda rede pode ser
diferente do utilizado pela primeira, ou a segunda rede não aceite os
pacotes devido ao tamanho excessivo destes. Ou ainda os protocolos
utilizados pela segunda rede sejam diferentes dos utilizados na
primeira rede. Cabe à camada de rede superar esses e outros
problemas, a fim de permitir a comunicação entre redes heterogêneas.
(TANENBAUM, 2003)

Camada de Transporte: Basicamente a função da camada de
transporte é receber dados da camada anterior a ela (camada de
Sessão), dividi-los em unidades menores caso seja necessário, e
repassá-los para a camada de rede, além de assegurar que todos os
fragmentos cheguem à outra extremidade corretamente e com
eficiência. O tipo de conexão de transporte mais popular é um canal
ponto a ponto praticamente livre de erros que entrega as mensagens
ou bytes na ordem exata em que estes foram enviados. Outros tipos
possíveis de serviço de transporte são as mensagens isoladas, sem
quaisquer garantias de entrega das mensagens ou a ordem de entrega
das mesmas. O tipo de serviço é determinado quando a conexão é
34
estabelecida. (TANENBAUM, 2003)

Camada de Sessão: Esta camada permite que usuário de diferentes
máquinas estabeleçam sessões entre si. Uma sessão oferece vários
serviços, como o controle de quem deve transmitir informações em
cada momento (chamado controle de diálogo), o controle de símbolos,
que impede que duas partes tentem executar a mesma operação
crítica ao mesmo tempo, e a sincronização, que realiza uma verificação
periódica em conexões longas com o intuito de permitir que estas
continuem a partir do ponto em que estavam, caso haja uma falha.

Camada de Apresentação: Diferentemente das camadas mais baixas,
que
estão
mais
preocupadas
com
questões
relacionadas
principalmente à movimentação de bits, a camada de apresentação
está relacionada à sintaxe e semântica das informações transmitidas.
Para tornar possível a comunicação entre computadores com
diferentes representações de dados, as estruturas de dados a serem
transmitidas podem ser definidas de maneira abstrata, ou seja, comum
aos protocolos de rede que irão manusear estes dados, juntamente
com uma codificação padrão que será usada durante a conexão.
(KUROSE; ROSS, 2010)

Camada de Aplicação: Essa camada possui uma série de protocolos
comumente necessários para os usuários. Um exemplo de protocolo
que executa nessa camada e que é muito utilizado é o HyperText
Transfer Protocol (HTTP), que constitui a base para a rede mundial de
computadores. Quando um navegador de internet deseja buscar uma
página de internet, ele envia o nome da página desejada ao servidor
através do protocolo HTTP, e o servidor transmite a página de volta
como resposta. Outros protocolos da camada de aplicação são
utilizados para a transferência de arquivos, correio eletrônico e
transmissão de notícias pela rede, por exemplo. (TANENBAUM, 2003)
1.4.3 Modelo de Referência TCP/IP
O modelo de referência TCP/IP é o modelo utilizado na antiga rede
geograficamente distribuída ARPANET e na sua atual sucessora, a rede mundial de
35
computadores conhecida como Internet.
A ARPANET era uma rede de pesquisa patrocinada pelo Departamento de
Defesa dos Estados Unidos (DoD) que, pouco a pouco, interconectou centenas de
universidades e repartições públicas utilizando cabos de linhas telefônicas
dedicadas. Com o advento das redes de rádio e satélites começaram a surgir
problemas com os protocolos existentes, o que acabou forçando a criação de uma
nova arquitetura de referência. Dessa forma, a habilidade para interconectar várias
redes uniformemente foi um dos focos principais do projeto desde o início. Mais
tarde essa arquitetura ficou conhecida como Modelo de Referência TCP/IP, devido
a seus dois protocolos principais. Esse modelo foi definido pela primeira vez em
(Cerf e Kahn, 1974), e posteriormente uma nova perspectiva foi oferecida em (Leiner
et al., 1985). (TANENBAUM, 2003)
Figura 1.6 – Camadas do modelo TCP/IP
Fonte: Colégio Liceal de Santa Maria de Lamas,
2011

Camada Inter-Redes: Essa camada também é conhecida como
Camada de internet, e é a principal camada do modelo TCP/IP,
pois integra toda a arquitetura do modelo. Sua função é permitir
que os hosts injetem pacotes em qualquer rede e garantir que
eles trafegarão até seu destino, mesmo que esse destino seja
em uma rede diferente. Os pacotes podem até mesmo serem
entregues em ordem diferente da que foram enviados, o que
obriga as camadas superiores a reorganizá-los, caso a entrega
em ordem dos pacotes seja desejável. A camada inter-redes
define um formato de pacote oficial e um protocolo chamado
Internet Protocol (IP). A função dessa camada é entregar
36
pacotes IP onde eles são necessários, e o roteamento desses
pacotes é uma questão de grande importância nessa camada,
bem como evitar o congestionamento da rede.

Camada de Transporte: Essa é a camada localizada acima da
camada de internet. Sua finalidade é permitir que os hosts de
origem e de destino mantenham uma conversação, da mesma
forma que ocorre com a camada de transporte do modelo de
referência OSI. Nessa camada operam dois protocolos. O
primeiro deles, chamado Transmission Control Protocol (TCP),
ou em português Protocolo de Controle de Transmissão, é um
protocolo orientado a conexões confiável, que permite a entrega
sem erros de um fluxo de dados originários de uma máquina
para qualquer máquina da inter-rede. Esse protocolo fragmenta
o fluxo de bytes em mensagens e passa cada uma delas para a
camada de internet. Quando os dados chegam no computador
destino, o protocolo TCP receptor volta a montar as mensagens
recebidas, formando o fluxo de saída. O protocolo TCP também
cuida do controle de fluxo, impedindo que um transmissor rápido
acabe sobrecarregando um receptor mais lento com um volume
de mensagens maior do que esse receptor pode manipular.
(TANENBAUM, 2003) Outro protocolo que executa na camada
de transporte é o User Datagram Protocol (UDP), que da mesma
forma que o TCP divide os dados em pacotes menores e os
envia para a camada de internet, mas sem um controle muito
aprimorado. O protocolo TCP, antes de estabelecer uma
conexão
com
outro
computador,
envia
uma
mensagem
solicitando conexão. Esse outro computador, por sua vez,
responde com uma mensagem autorizando a conexão. Só então
o computador remetente estabelece a conexão. Esse processo é
chamado de handshake, ou aperto de mãos. O protocolo UDP
não executa esse processo, e por essa razão é chamado de não
orientado para conexão. (KUROSE; ROSS, 2010)

Camada de Aplicação: Acima da camada de transporte está a
camada de aplicação. Nela estão todos os protocolos de nível
37
mais alto, como por exemplo o protocolo de terminal virtual
(TELNET), o protocolo de transferência de arquivos (FTP) e o
protocolo de correio eletrônico (SMTP), o protocolo utilizado
para buscar páginas da internet (HTTP), dentre muitos outros.
(TANENBAUM, 2003)

Camada de Rede: O modelo TCP/IP não especifica muito bem
o que ocorre abaixo da camada de inter-redes, exceto que o
computador deve se conectar à rede utilizando algum protocolo
para que seja possível enviar pacotes IP, sendo que esse
protocolo não é definido, podendo variar de computador para
computador, e de rede para rede. “Os livros e a documentação
que tratam do modelo TCP/IP raramente descrevem esse
protocolo.” (TANENBAUM, 2003)
38
2 TECNOLOGIAS UTILIZADAS
Esse
capítulo
apresenta
as
tecnologias
de
software
utilizadas
no
desenvolvimento do trabalho. São apresentados o servidor web Apache, utilizado
para agir como o servidor da interface web do NEHMO, as tecnologias HTML e PHP,
utilizadas na construção das páginas que compõem a interface web do NEHMO, a
linguagem de script Perl, utilizada para agir como o “motor” do NEHMO, e o banco
de dados MySQL, cuja função é armazenar as informações coletadas pelo NEHMO.
2.1 HTML
As páginas de Internet podem conter muitos tipos de conteúdo diferentes tal
como textos, gráficos, formulários, áudio, vídeo e até mesmo jogos interativos. Cada
página de Internet é diferente, mas a maioria delas tem algo em comum: o HTML
(Hypertext Markup Language).
Não importa o tipo de informação que uma página de Internet contenha, ela
será criada utilizando o HTML. O HTML é o que mantém os componentes da página
juntos, como os gráficos, conteúdo e outras informações. (TITTEL, 2005)
Os arquivos HTML que compõem a Internet são arquivos de texto. Por esse
motivo a Internet funciona tão bem, pois arquivos de texto são uma linguagem
universal para os computadores. Qualquer arquivo de texto que seja criado em um
computador executando o sistema operacional Windows, até mesmo um arquivo
HTML, será interpretado perfeitamente igual em qualquer outro computador
executando outros sistemas operacionais. Todavia, as páginas de Internet não são
“meramente” arquivos de texto, e isso se deve ao HTML em si. O HTML é uma
coleção de instruções adicionadas ao longo do texto através de determinadas
marcações, que determinam como a página de Internet deve parecer e se
comportar. (TITTEL, 2005)
Uma dessas instruções especiais em HTML permitem que um texto aponte
para um outro local. Esses ponteiros são chamados hyperlinks. Nos navegadores de
Internet atuais, normalmente os hyperlinks aparecem como uma parte do texto em
azul e sublinhada, e quando se clica sobre esse trecho de texto o usuário é
normalmente levado para uma outra página de Internet, podendo essa página
pertencer ao mesmo site ou à outro site independente. (TITTEL, 2005)
39
As marcações HTML são identificadas por palavras contidas entre o sinal de
menor e o sinal de maior ( < e > ). A Figura 2.1 apresenta um exemplo de um código
HTML e o resultado que será exibido após a interpretação do navegador de Internet.
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”
“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml”>
<head>
<title>Wine Varietals</title>
</head>
<body>
<h1><img src=”red_grapes.jpg” width=”75” height=”100”
alt=”Red Grapes” align=”middle” hspace=”5” />
Understanding Red Wine Varietals
</h1>
<p>Although wines tend to be generically categorized
as
either “white” or “red,” in reality, there is a
collection of wine varietals each with its own
distinguishing characteristics. The red category
includes a robust collection of over 20 varietals,
including:
</p>
<ul>
<li>Barbera</li>
<li>Brunello</li>
<li>Cabernet Franc</li>
<li>Cabernet Sauvignon</li>
<li>Carignan</li>
<li>Carmenere</li>
<li>Charbono</li>
Figura 2.1 – Exemplo de
<li>Dolcetto</li>
<li>Gamay</li>
Internet e seu código HTML
<li>Grenache</li>
<li>Malbrec</li>
Fonte: Tittel, 2005, p. 11
<li>Merlot</li>
<li>Mourvedre</li>
<li>Nebbiolo</li>
<li>Petite Sirah</li>
<li>Pinot Noir</li>
<li>Sangiovese</li>
<li>Syrah</li>
<li>Tempranillo</li>
<li>Zinfandel</li>
</ul>
</body>
</html>
página de
A página de Internet apresentada na Figura 2.1 é composta por vários
elementos diferentes, e uma grande quantidade de marcações HTML. Analisando o
código, apresenta-se inicialmente um cabeçalho que descreve a página, um
parágrafo que discorre sobre vinho tinto e uma lista com as variedades mais comuns
de uva. O cabeçalho apesentado no início do código HTML não produz efeito visível
na página de Internet quando essa é acessada por um navegador de Internet.
Em um arquivo HTML, cada palavra ou letra entre os sinais < e > são
marcações HTML. No exemplo apresentado na Figura 2.1, a marcação <p> indica
ao navegador de Internet que o texto que se segue é um parágrafo. Da mesma
forma, as marcações <li> e </li> indicam que o texto contido entre elas é parte
40
integrante de uma lista de vários elementos. Em termos simples, um arquivo HTML
consiste em adicionar marcações ao longo de um texto para que os navegadores de
Internet saibam como exibir a página de Internet na tela do computador. (TITTEL,
2005)
Todavia uma página de Internet pode não ser muito útil se não houver a
possibilidade de compartilhá-la com o mundo. O que torna isso possível são os
Servidores de Internet. Basicamente, um servidor de Internet é um computador que
se conecta à Internet, executa um software de servidor de Internet e responde às
requisições dos navegadores de Internet, devolvendo-lhes uma página de Internet
ou até mesmo um determinado arquivo solicitado.
Praticamente qualquer computador pode ser um servidor de Internet, até
mesmo os computadores domésticos. Porém geralmente os servidores de Internet
são computadores dedicados a essa tarefa. Não é necessário ser um especialista
para publicar páginas de Internet, mas é necessário que se tenha um servidor de
Internet. (TITTEL, 2005)
A Internet é composta de milhões de recursos, e cada um deles pode ser
referenciado. A exata localização de um recurso é a chave para referenciá-lo. O
mecanismo utilizado para prover essa localização exata é o Uniform Resource
Locator (URL), que em português pode ser traduzido com Localizador Padrão de
Recursos. URLs são o mecanismo padrão para o endereçamento de recursos na
Internet. Cada recurso (páginas de Internet ou arquivos individuais) tem um URL
único. A Figura 2.2 identifica as partes componentes de um endereço URL.
Conforme apresentado na Figura 2.2, essa é a forma como os URLs são
constituídos, e dessa forma é possível localizar de forma precisa os recursos na
Internet. Inicialmente é apresentado o protocolo de comunicação utilizado para a
conexão com o servidor de Internet. O protocolo mais comum utilizado na Internet
atualmente é o HTTP, mas outros protocolos como o FTP, por exemplo, podem ser
utilizados. A seguir vem o domínio, que é o nome do site especificamente que será
acessado. Um domínio pode conter apenas alguns poucos arquivos, como uma
página de Internet pessoal, ou milhões de arquivos, como em um site corporativo de
grandes organizações tal como a Oracle, a Apple ou a Sun. Logo após, há um
caminho de subpastas dentro do domínio especificado no qual pode-se encontrar o
arquivo pretendido, conforme indicado na Figura 2.2. E, por fim, o nome do arquivo
específico que o navegador de Internet irá acessar, normalmente um HTML.
41
(TITTEL, 2010)
Figura 2.2 – Partes que compõem um URL
Fonte: Tittel, 2005, p. 15
2.2 SERVIDOR HTTP APACHE
Sempre que uma pessoa digita o endereço de um site no navegador de
Internet de seu computador está enviando uma mensagem através das redes de
computadores com destino ao computador servidor que hospeda o site desejado. No
uso convencional, normalmente o servidor destino encontra-se em outra rede de
computadores, em outra cidade ou até mesmo em outro país, e a mensagem que
saiu do computador do usuário viaja através da Internet até chegar ao servidor a
qual se destina. Espera-se que este servidor esteja ativo e conectado à Internet,
pronto para receber a mensagem do usuário e agir de acordo com esta solicitação,
na maioria das vezes retornando uma resposta para o navegador de Internet da
pessoa que enviou a mensagem. (LAURIE, 1999)
Em termos simples, o trabalho principal de um servidor de Internet é receber
uma requisição na forma de um URL vinda de um navegador de Internet de alguma
pessoa em algum lugar do mundo, comumente através da Internet, traduzir esse
URL em um nome de arquivo e, então, devolver como resposta o arquivo solicitado,
ou caso o arquivo não tenha sido localizado, devolver uma mensagem informando o
ocorrido. Ainda, em vez de localizar um determinado arquivo, a mensagem que
chega ao servidor de Internet pode solicitar que um determinado software seja
executado no servidor. O servidor executa o software solicitado e pode devolver
como resposta para o computador de origem a saída de processamento realizada
pelo software em questão. (LAURIE, 1999)
42
Um servidor de Internet pode ser um super computador com uma capacidade
de processamento muito poderosa, ou até mesmo um grupo de computadores
poderosos trabalhando em conjunto (esse método é chamado de cluster), ou ainda
um computador bastante humilde. Em todos os casos, o ideal é que o servidor de
Internet esteja executando um tipo de software chamado servidor web, que é
responsável por estar de prontidão para receber as solicitações dos navegadores de
Internet e agir de acordo com a mensagem recebida. (LAURIE, 1999)
Espera-se de um servidor de Internet (tanto o computador quanto o software)
que este seja rápido para poder lidar com várias requisições em um intervalo de
tempo e utilizando o mínimo de recursos do computador possível. Espera-se
também que este seja multitarefa, para que possa lidar com mais de uma requisição
por vez, e para que seja possível efetuar tarefas administrativas no servidor sem ter
que parar o fornecimento do serviço. É ainda desejável que o servidor possua
recursos de autenticação de usuários, pois algumas pessoas podem ter acesso a
determinados serviços e outras não. Outro recurso desejável é que o servidor, ao
encontrar determinadas situações ou erros, responda com uma mensagem que
ajude a determinar a causa do erro. Por exemplo, quando o servidor não consegue
localizar uma determinada página de Internet solicitada por um usuário, espera-se
que ele responda com um erro “404”, que é a especificação definida pelo HTTP que
determina quando uma página de Internet não foi encontrada. Por fim, espera-se de
um servidor de Internet que este seja seguro. Assim como na vida real, na Internet
há pessoas bem e mal intencionadas, e um dos grandes objetivos de um bom
servidor de Internet é garantir a segurança dos dados e dos usuários. (LAURIE,
1999)
Um software servidor de Internet mundialmente conhecido, que reúne todas
as características citadas acima, e muitas outras, é o Apache. Por esse motivo o
Apache foi escolhido como servidor de Internet na implementação desse trabalho.
2.2.1 Funcionamento
Apache é um programa que é executado em um sistema operacional
apropriado com suporte à multitarefa, como por exemplo o Windows ou um sistema
operacional da linhagem do Unix. O arquivo binário do Apache, que é o software
executável em si, é chamado de httpd no Unix e apache.exe no Windows, e
43
normalmente executa em segundo plano. Cada instância do Apache que é
executada tem sua atenção voltada para um determinado site, que é em termos
gerais um diretório. Independentemente do sistema operacional que está sendo
executado, o diretório de um site possui normalmente quatro subdiretórios.
O subdiretório conf contém os arquivos de configuração, sendo o httpd.conf o
mais importante deles.
O subdiretório htdocs contém os scripts HTML que serão fornecidos aos
clientes que requisitarem esse site. Esse diretório e todos os diretórios dentro deste
estão publicamente acessíveis para qualquer pessoa conectada à Internet.
O subdiretório logs contém os arquivos de log de acesso e de erro gerados
pelo Apache.
Por fim, o subdiretório cgi-bin contém scripts CGI. Esses são programas ou
script que podem ser executados pelo Apache. O servidor Apache entende que os
arquivos contidos nesse diretório, em vez de serem simplesmente lidos e enviados,
devem ser executados, e os resultados obtidos com a execução destes podem ser
manipulados e utilizados em favor do cliente. Por razões de segurança, recomendase que este diretório não esteja no espaço acessível publicamente.
Quando inativo, o Apache somente escuta os endereços IP e as portas TCP
de demais portas configuradas em seu arquivo Config. Quando surge uma
requisição em uma das portas válidas, o Apache recebe a requisição e analisa os
cabeçalhos desta, e então aplica as regras encontradas em seu arquivo de
configuração e toma as ações apropriadas. (LAURIE, 1999)
O desenvolvedor pode controlar o Apache através do arquivo de
configuração. Há cerca de 150 diretivas de configuração à disposição. Sob sistemas
operacionais Unix, é possível selecionar quais módulos serão compilados junto com
o Apache. Cada módulo disponibiliza mais algumas diretivas que podem ser
manipuladas para configurar o Apache de acordo com as necessidades. Ainda, é
possível deixar fora da compilação do Apache alguns módulos que não serão
utilizados afim de diminuir o tamanho final do arquivo binário compilado e melhorar o
desempenho de execução do Apache. Sob o sistema operacional Windows, o
Apache é normalmente disponibilizado como executável já previamente compilado,
com os módulos principais já inclusos, e os demais módulos que possam ser
necessário podem ser carregados como bibliotecas dinamicamente durante a
execução do mesmo. (LAURIE, 1999)
44
2.3 PHP
O PHP é uma linguagem de programação open-source largamente utilizada
que possui como estrutura o formato de script. Ele foi pensado inicialmente para ser
utilizado no desenvolvimento de páginas de Internet. De fato, o acrônimo PHP vem
do inglês Personal Home Page tools, que em tradução livre significa algo como
“ferramentas para desenvolvimento de página pessoal”, desenvolvido por Rasmus
Lerdorf para auxiliar as pessoas no desenvolvimento de páginas de Internet. O PHP
se demonstrou tão eficiente que rapidamente se tornou popular e evoluiu para a tão
completa linguagem que é hoje, passando a significar agora PHP Hypertext
Processor, ou, em tradução livre, “Processador de hipertexto PHP”, para melhor
representar as habilidades estendidas que a linguagem adquiriu ao longo do tempo,
a habilidade de processar as páginas de Internet antes de estas serem exibidas.
(VALADE, 2004)
Ainda hoje o PHP continua crescendo em popularidade, devido às suas várias
vantagens. O PHP é rápido, pois está mesclado com código HTML, o que faz om
que o tempo de processamento e carregamento de uma página seja muito curto. O
PHP é gratuito. O PHP é fácil de usar, sua sintaxe é simples e fácil de entender e
usar, mesmo para aqueles que nunca lidaram com programação, além de ter sido
desenvolvido para se mesclar facilmente em um código HTML. O PHP é versátil,
pois consegue executar em uma ampla gama de sistemas operacionais, incluindo
Windows, Linux e Mac OS, além da maioria das variedades do Unix. O PHP possui
suporte técnico amplamente disponível, com várias listas de e-mail disponibilizadas
pelo próprio site do PHP ( www.php.net ) que abordam vários tópicos como o PHP
em geral, PHP no Windows, integração com bancos de dados, etc. Ainda é possível
acessar um site que disponibiliza todas as listas de discussão no endereço
news.php.net. O PHP é seguro, desde que você configure-o corretamente, o usuário
não consegue ver e ter acesso ao código PHP. Por fim, o PHP é customizável, como
está sob uma licença de código fonte aberto, possibilita que programadores
modifiquem o PHP, adicionando ou modificando recursos. (VALADE, 2004)
No início da Internet as páginas eram estáticas, somente apresentavam
documentos. As pessoas acessavam as páginas de Internet unicamente para obter
informações, e as páginas e objetos estavam interligados, de forma a ficar fácil
45
obter-se a informação desejada. Cada pessoa que chegava à uma determinada
página enxergava a mesma coisa, as mesmas informações. Contudo, com o tempo,
os desenvolvedores queriam algo mais, queriam poder interagir com as pessoas,
coletar informações, customizar a página de acordo com as preferências de cada
pessoa. Muitas linguagens de desenvolvimento foram pensadas de modo a tornar as
páginas de Internet mais dinâmicas, e o PHP é uma das mais bem sucedidas delas.
(VALADE, 2004)
Os scripts PHP são executados no servidor que abriga a página, não no
computador da pessoa que está acessando, diferentemente do JavaScript, uma
outra linguagem também destinada ao desenvolvimento de páginas de Internet
dinâmicas, que é executado pelo navegador de Internet da pessoa que está
acessando a página em questão. Por esse motivo, por ser executado diretamente no
servidor, os scripts PHP são capazes de criar dinamicamente os códigos HTML que
compõem a página que será exibida para o visitante. As pessoas que visitam essa
página de Internet verão o resultado do processamento dos scripts PHP, mas não o
código dos scripts em si. (VALADE, 2004)
2.4 PERL
O Perl é, normalmente, referenciado como Practical Extraction and Reporting
Language (Linguagem de Extração Prática e Relatório – tradução literal) ou
Pathologically Eclectic Rubbish Lister (sem tradução). No entanto, não se pode dizer
que seja um acrônimo, pois o nome Perl foi dado por seu criador, Larry Wall, antes
de sua expansão, o que explica condição de a palavra não ser escrita totalmente em
letras maiúsculas. (SCHWARTZ; PHOENIX; D FOY, 2008)
Em geral, encontra-se o “Perl” escrito com a inicial maiúscula para referenciar
a linguagem e “perl” com a inicial minúscula para referenciar o interpretador de
comandos.
Foi criado no ano de 1987, com o intuito de gerar alguns relatórios da Usenet
(uma rede de comunicação eletrônica anterior à conhecida Internet) num sistema de
hierarquia semelhante ao de notícias para um sistema de bug-reporting (relatório de
erros). Como a utilização do comando awk no sistema operacional estava fora de
cogitação, seu criador decidiu solucionar o problema criando uma ferramenta de
propósitos gerais, podendo utilizá-la em outros locais, o que resultou no Perl versão
46
ZERO. (SCHWARTZ; PHOENIX; D FOY, 2008)
Perl é uma linguagem fácil de utilizar, todavia isso não significa que ela seja
fácil de aprender. Da mesma forma, para dirigir um carro é necessário dedicar
bastante tempo no aprendizado, e depois de alguma prática o ato de dirigir se torna
algo fácil, o mesmo ocorre com a linguagem Perl. Durante o desenvolvimento do
Perl, quando Larry Wall teve que escolher entre tornar algo fácil para o programador
ou fácil para quem está estudando, quase sempre Larry optou pelo programador,
pois uma pessoa aprende Perl apenas uma vez, ao passo que um programador
utiliza-o constantemente no dia-a-dia. (SCHWARTZ; PHOENIX; D FOY, 2008)
O Perl é bom para praticamente qualquer tarefa de programação. Desde
programas simples que podem ser escritos em três minutos, até programas mais
complexos e extensos que envolvem vários programadores trabalhando por um
longo período. Perl é otimizado para lidar com problemas que envolvem 90%
trabalho com textos e 10% com outras coisas, o que se enquadra na maioria das
tarefas de programação atuais. Unindo isso com a facilidade de programar torna o
Perl ideal para a maioria das situações de programação.
A linguagem Perl não deve ser escolhida, entretanto, se você busca criar um
código binário opaco. Isso significa distribuir um arquivo de programa fechado, de
forma que a pessoa que o receber não poderá ter acesso aos seus algoritmos
secretos e, em contrapartida, não poderá ajudar em melhorias e correções de erros
no código. Ao criar um código em Perl e distribuir esse programa, normalmente é
distribuído o código fonte do programa, não um binário opaco. Portanto, se a
intenção é manter o código escondido de outros, o Perl não é a escolha ideal.
(SCHWARTZ; PHOENIX; D FOY, 2008)
O Perl já vem embarcado com muitos sistemas operacionais, incluindo Linux,
Unix, Solaris, AIX, HPUX e MacOS X. O sistema operacional Windows, todavia, não
vem com o Perl instalado por padrão. O Download, tanto do instalador quanto dos
códigos fonte do Perl, pode ser feito gratuitamente na página http://www.perl.org. O
Perl é distribuído sob duas licenças diferentes. Para a maioria das pessoas, que
somente irão utilizar o Perl, não há basicamente diferenças entre as licenças. Para
essas pessoas, basicamente, as licenças dizem “O Perl é gratuito e livre, divirta-se.”
Todavia, se pretende modificar o código fonte do Perl em si há algumas restrições de
licença que devem ser seguidas. (SCHWARTZ; PHOENIX; D FOY, 2008)
Devido ao fato de programas escritos em Perl serem simples arquivos de
47
texto, é possível cria-los e editá-los usando apenas um editor de textos comum. Não
é necessário utilizar nenhuma ferramenta de ambiente de desenvolvimento mais
incrementada, embora existam algumas ferramentas comerciais com esse objetivo.
É possível utilizar um editor de textos comum, sem muitos recursos, ou até mesmo
um editor de textos voltado para programadores. A diferença é que os editores de
texto voltados para programadores possuem alguns recursos comuns que podem
ser úteis na rotina de programação, como por exemplo a indentação de um bloco de
códigos para facilitar a leitura do mesmo, ou a associação entre dois parênteses que
envolvem um bloco de código, por exemplo. Nos sistemas derivados do Unix, os
dois editores mais conhecidos são o Emacs e o Vi (e suas variantes e cópias).
Exemplos para o MacOS X são o BBEdit e o TextMate. E para o Windows dois
exemplos são o UltraEdit e o PFE (Programmer’s File Editor). (SCHWARTZ;
PHOENIX; D FOY, 2008)
Um exemplo simples de código escrito em Perl para ser executado em um
sistema operacional de bases no Unix é o programa “Olá Mundo”, conforme segue
abaixo:
#!/usr/bin/perl
print “Olá, mundo!\n”;
O programa acima simplesmente escreve na tela a frase “Olá, mundo!”. Após
escrever o código utilizando o editor de texto escolhido, é necessário salvar o
arquivo de texto como um texto puro. Normalmente não é necessário definir uma
extensão de arquivo para o nome, mas dependendo do sistema operacional onde o
programa será executado pode sim ser necessário definir uma extensão como por
exemplo .plx (que significa PerL eXecutável). Depois que o arquivo foi salvo, basta
tornar o arquivo executável, para que o sistema operacional entenda que esse
arquivo é agora um programa e, assim, possa interpretar as instruções e executálas. Para identificar um arquivo como executável em sistemas de base Unix, basta
executar o comando chmod conforme o exemplo a seguir:
$ chmod a+x nome_do_programa
O símbolo cifrão e o espaço que vem logo em seguida representam o terminal
48
de comandos, e o restante representa o comando propriamente dito com os
parâmetros de execução. Esse comando indicará para o sistema operacional que
esse arquivo é um programa executável. Para executar o programa basta utilizar os
operadores ./ antes do nome do programa, conforme apresentado:
./nome_do_programa
Utilizando o operador ./ antes do nome do programa indica para o sistema
operacional que este deve buscar por esse programa no mesmo diretório atual, em
vez de buscar o executável no diretório padrão do sistema onde os executáveis dos
programas são armazenados. Isso é importante para garantir que o programa que
será executado é exatamente aquele pretendido. Uma situação comum aos
programadores inexperientes é criar seu primeiro programa com o nome de test por
exemplo, e de fato existe um programa chamado test em alguns sistemas baseados
em Unix. Se o ./ inicial não for especificado, o sistema operacional irá buscar o
programa que está nos diretórios padrão em vez do programa escrito pelo
programador em questão. Se ao executar o programa o perl informar que há algum
problema com o código, é necessário editar o arquivo e corrigir os problemas. Se o
comando chmod já foi executado anteriormente, não é necessário executá-lo
novamente, pois as alterações de permissão de execução do arquivo permanecem.
(SCHWARTZ; PHOENIX; D FOY, 2008)
Assim como algumas outras linguagens de programação, o Perl permite a
utilização de espaços em branco, como espaços, tabulações ou linhas em branco,
para melhorar a organização do programa e torna-lo mais fácil de ler. Assim, é boa
prática indentar o código do programa. Outra boa prática ao programar é inserir
comentários no código, que não fazem parte do código em si, mas que auxiliam no
entendimento e análise futura do código, e tornam o programa mais fácil de entender
para uma pessoa que está lendo o código pela primeira vez. No perl os comentários
são identificados pelo caractere cerquilha (#) no início do trecho onde está o
comentário.
No exemplo de código apresentado anteriormente, para o programa Olá
Mundo, pode-se notar que a primeira linha inicia com o sinal #, o que o caracteriza
como um comentário. Mas este é um tipo muito especial de comentário. Em
sistemas baseados em Unix, quando os dois primeiros caracteres na primeira linha
49
de um código de programa são os símbolos #! o que vem logo a seguir indica o
nome do programa que irá interpretar o restante do código. Nesse caso, o programa
está armazenado no arquivo /usr/bin/perl. O local onde o programa está armazenado
pode variar de sistema para sistema, mas na grande maioria dos casos este está
localizado ou no caminho /usr/bin/perl ou em /usr/local/bin/perl, para sistemas
baseados em Unix. Para sistemas que não são baseados em Unix, como o
Windows, por exemplo, é usual configurar essa primeira linha para #!perl apenas,
pois informa para qualquer pessoa que inicie a ler o código do programa de que se
trata de um código escrito na linguagem Perl. (SCHWARTZ; PHOENIX; D FOY,
2008)
2.5 BANCO DE DADOS
Os sistemas de bancos de dados são componentes essenciais no cotidiano
da sociedade moderna. Muitas das atividades corriqueiras envolvem hoje, de
alguma forma, uma interação com bancos de dados. Exemplos de atividades que
podem incluir interação direta ou indireta com bancos de dados incluem a reserva de
passagens aéreas, consulta de saldo em um banco, compras em um supermercado
informatizado, dentre muitas outras. (ELMASRI; NAVATHE, 2005)
Segundo Elmasri; Navathe (2005), em uma definição bastante genérica, “um
banco de dados é uma coleção de dados relacionados”. Os dados podem ser vistos
como fatos, sobre alguém ou algum objeto, que podem ser armazenados e possuem
significado implícito, como por exemplo nome, endereço, cor, peso, etc.
Um banco de dados deve seguir algumas regras que o definem como tal.
Representa alguns aspectos do mundo real. Ainda, um banco de dados deve ser
uma coleção lógica e coerente de informações com significado inerente. Uma
organização de dados aleatórios não pode ser corretamente interpretada como um
banco de dados. Por fim, deve ser projetado, construído e povoado por informações
que atendem a uma proposta específica, possuindo um grupo de usuários definido e
aplicações preconcebidas, de acordo com os interesses desse grupo. (ELMASRI;
NAVATHE, 2005)
Existem ferramentas computacionais que auxiliam na criação e manutenção
de um banco de dados. Um sistema gerenciador de banco de dados (SGBD) é uma
coleção de programas que permitem ao usuário realizar essa tarefa.
50
Atualmente há uma grande oferta de sistemas de bancos de dados no
mercado, para variados propósitos. Há sistemas de banco de dados pagos e
gratuitos, para fins de utilização mais simples ou para sistemas mais complexos. O
sistema de banco de dados escolhido para a implementação do NEHMO é o
MariaDB.
O MariaDB é um sistema de banco de dados avançado, e está disponível sob
os termos da licença GPL v2. Ele é desenvolvido pela comunidade MariaDB e seu
principal mantenedor é a Fundação MariaDB. (MARIADB, 2013)
O MariaDB descende de um outro sistema de banco de dados chamado
MySQL. Como segurança é um fator crucial nos dias atuais, este é um dos principais
focos dos desenvolvedores do MariaDB, que incorporam as atualizações de
segurança do MySQL ao projeto MariaDB e, se necessário, realizam melhorias nas
mesmas, e quando surgem falhas de segurança graves, os desenvolvedores do
MariaDB imediatamente preparam e distribuem uma nova versão do MariaDB, para
que a falha seja corrigida o quanto antes possível. (MARIADB, 2013)
Devido ao MariaDB ser mantido atualizado com os lançamentos do MySQL,
na grande maioria dos casos o MariaDB deve funcionar exatamente como o MySQL.
Todos os comandos, interfaces, bibliotecas e interfacesde desenvolvimento que
existem no MySQL também existem no MariaDB, com o adicional de o MariaDB
implementar melhorias de performance e acrescentar recursos que não estão
presentes por padrão no MySQL. (MARIADB, 2013)
2.6 SCHTASKS
O Schtasks é um serviço que tem a função de agendar a execução de
comandos periodicamente, ou em um determinado momento especificado, em um
computador. Ele tem a capacidade de adicionar e remover tarefas agendadas, iniciar
e interromper tarefas de acordo com a demanda, além de exibir e alterar tarefas
previamente agendadas. O Schtasks executa a mesma função que a opção Tarefas
Agendadas, presente no painel de controle do sistema operacional Windows,
podendo ser utilizado em conjunto com esta ou alternadamente. (MICROSOFT,
2013)
51
3 IMPLEMENTAÇÃO
Esse capítulo foca nos processos de instalação e configuração dos Software
e serviços necessários para o funcionamento do NEHMO, bem como apresentar os
códigos e scripts que o compõem.
3.1 LAMP
O termo LAMP refere-se ao conjunto de Software Linux, Apache, MySQL e
PHP. Esses Software em conjunto são, geralmente, a base de um servidor de
páginas de Internet, podendo serem feitas alterações nesse conjunto. Linux é o
sistema operacional que será executado no computador servidor. O Apache,
conforme apresentado anteriormente, é o software responsável por atual como
servidor de páginas de Internet. O MySQL é o banco de dados que armazenará
informações importantes no servidor, e o PHP é o responsável por construir as
páginas de Internet que serão fornecidas pelo Apache para o usuário final. Na
implementação desse trabalho foi escolhido substituir o banco de dados MySQL pelo
MariaDB, por motivos citados no capítulo anterior.
3.1.1 Debian Linux
A distribuição Linux escolhida para a implementação desse trabalho foi o
Debian GNU/Linux. O Debian pode ser obtido através da página oficial, no link
http://www.debian.org/distrib/. O Debian é fornecido de duas formas. O sistema
completo distribuído em DVD ou vários CDs, que inclui praticamente todos os
pacotes de software e bibliotecas presentes no repositório oficial do Debian, ou em
uma versão muito menor chamada netinst, que consiste apenas no sistema básico
para instalação. Nessa versão, outros pacotes e bibliotecas, como os gerenciadores
de área gráfica, por exemplo, podem ser instalados durante a instalação do Debian
via Internet, ou após o sistema ser instalado.
Após obter o arquivo do CD ou DVD de instalação do Debian, no formato de
arquivo ISO, faça a gravação do mesmo em uma mídia de CD ou DVD. Ara instalar,
é necessário inicia o processo de boot através da mídia gravada, e seguir as
52
solicitações do instalador. Após a instalação do Debian, siga com a configuração dos
demais Software.
3.1.2 Apache
No sistema operacional Debian, execute o terminal de comandos. Faça o
login como super usuário (root). Faça a atualização da base de dados dos
repositórios com o comando:
apt-get update
Para instalar o Apache, digite o comando:
apt-get install apache2 apache2-doc
A seguir habilite o módulo do diretório de usuários para o Apache:
a2enmod userdir
Configure o módulo userdir do apache no arquivo /etc/apache2/modsenabled/userdir.conf conforme descrito abaixo:
<IfModule mod_userdir.c>
UserDir public_html
UserDir disabled root
<Directory /home/*/public_html>
AllowOverride All
Options MultiViews Indexes SymLinksIfOwnerMatch
<Limit GET POST OPTIONS>
Order allow,deny
Allow from all
</Limit>
<LimitExcept GET POST OPTIONS>
53
Order deny,allow
Deny from all
</LimitExcept>
</Directory>
</IfModule>
A seguir, crie o diretório como usuário padrão, não como root:
mkdir /home/$USER/public_html
Em seguida, volte ao usuário root e faça a alteração do grupo para o diretório:
chgrp www-data /home/<username>/public_html
Por fim, reinicie o serviço do Apache.
service apache2 restart
Para configurar o PHP no Apache, verifique o arquivo de configuração
/etc/apache2/mods-available/php5.conf:
<IfModule mod_php5.c>
<FilesMatch "\.ph(p3?|tml)$">
SetHandler application/x-httpd-php
</FilesMatch>
<FilesMatch "\.phps$">
SetHandler application/x-httpd-php-source
</FilesMatch>
# To re-enable php in user directories comment the
following lines
# (from <IfModule ...> to </IfModule>.) Do NOT set it
to On as it
# prevents .htaccess files from disabling it.
#<IfModule mod_userdir.c>
54
#
<Directory /home/*/public_html>
#
#
php_admin_value engine Off
</Directory>
#</IfModule>
</IfModule>
3.1.3 PHP
Para instalar o PHP no Debian utilize o comando:
apt-get install php5 php5-mysql libapache2-mod-php5
3.1.4 MariaDB
Para instalar o MariaDB no Debian, é necessário primeiro configurar seu
repositório no sistema. Para isso, como usuário root, execute:
apt-get install python-software-properties
apt-key adv --recv-keys --keyserver keyserver.ubuntu.com
0xcbcb082a1bb943db
add-apt-repository
http://ftp.osuosl.org/pub/mariadb/repo/10.0/debian
'deb
wheezy
main'
Após adicionar o repositório, execute os comandos seguintes para a
instalação:
apt-get update
apt-get install mariadb-server
3.2 INSTALAÇÃO DO MÓDULO MYSQL NO CLIENTE WINDOWS
55
É necessário, para que haja a comunicação do cliente com o banco de dados
do servidor, que se instale o módulo do Perl que possibilita tal acesso. Isso é feito
individualmente em cada máquina cliente.
Para tal, é necessário iniciar um CMD:
Menu Iniciar > executar > cmd
E então digitar o comando:
ppm install dbi::mysql
Figura 3.1 – Instalação do DBI
Fonte do autor
Lembrando que toda instalação deve ser efetuada com um usuário com
privilégios de administrador.
3.3 AGENDAMENTO DE EXECUÇÃO DO SCRIPT
Existem diversas ferramentas que permitem que a execução de um comando,
de um script, de um programa ou mesmo de uma rotina administrativa seja feita de
forma automatizada e periódica. Essas ferramentas são muito úteis, e são utilizadas
para agendar a execução do script do NEHMO. Tanto o sistema operacional
Windows quanto o Linux possuem suas ferramentas nativas destinadas a esse fim,
que serão abordadas a seguir.
56
3.3.1 Agendamento no Windows por Schtask
Para que se torne algo transparente ao usuário, faz-se a utilização da
ferramenta schtasks, nativa do Sistema Operacional Windows, através da qual podese agendar a execução do script de acordo com a necessidade do administrador de
redes.
No ambiente de testes, o agendamento foi feito de acordo com as seguintes
situações definidas pelo usuário:

executar estando o usuário conectado ou não;

quando qualquer usuário fizer logon;

iniciar no diretório do script.
Assim, após efetuar o agendamento, a tela se parecerá com a captura abaixo:
Figura 3.2 – Agendamento no schtask
Fonte: Elaborada pelo autor, 2013.
3.3.2 Agendamento no Linux por Cron
O cron é um programa de agendamento de tarefas. Com ele você pode
programar para ser executado qualquer coisa numa certa periodicidade ou até
57
mesmo em um exato dia, numa exata hora. Um uso bem comum do cron é o
agendamento de tarefas administrativas de manutenção do seu sistema, como por
exemplo, procura por links simbólicos quebrados, análise de segurança do sistema,
backup, entre outros. A configuração do cron geralmente é chamada de crontab.
O arquivo a ser editado fica em “/etc/crontab, podendo, apenas, ser editado
pelo usuário root do sistema.
Para se inserir uma linha para agendamento de tarefa no cron, deve-se
respeitar seus parâmetros de configuração, como pode ser visto na imagem abaixo.
Figura 3.3 – Agendamento no cron
Fonte: Elaborada pelo autor, 2013.
3.4 RESULTADOS
Nesta seção serão apresentados vislumbres referentes aos resultados obtidos
ao final das pesquisas e desenvolvimento dos scripts, em especial o script para
estações com Windows.
Após ser executado, o script gera um arquivo de texto, contendo as
informações coletadas da estação de trabalho, como pode ser visto na Figura 3.2.
Figura 3.4 – Saída do script
Fonte: do autor
58
Após gerar o arquivo de texto, o script envia as informações ao servidor
remoto, contendo o banco de dados mysql/mariadb, salvando no banco “nehmo”.
Figura 3.5 – Captura de tela do phpmyadmin mostrando tabela hosts
Fonte: Elaborada pelo autor, 2013.
Figura 3.6 – Captura de tela do phpmyadmin mostrando tabela host_user
Fonte: Elaborada pelo autor, 2013.
59
Figura 3.7 – Captura e tela do phpmyadmin mostrando tabela motherboard
Fonte: Elaborada pelo autor, 2013.
Como pode ser visto nas capturas acima, o banco de dados está configurado
para receber inserções de strings’/caracteres na codificação UTF-8, o que torna a
base mais consistente, por permitir acentuações e símbolos não contidos na tabela
ASCII.
Uma coisa importante a ser apontada, é que o script foi testado em, apenas,
versões de Windows, sendo o Windows XP, Windows 7 e Windows 8, por serem as
versões mais comuns encontradas, atualmente, em estações de trabalho. A versão
do Windows 7 foi testada, apenas, em máquina virtual, diferentemente das versões
XP e 8, na qual foram utilizadas máquinas físicas.
O ambiente de testes, foi expandido até 5 máquinas, físicas, acessando o
servidor em máquina virtual, para verificar se o acesso à rede seria comprometedor.
Por ser uma máquina virtual, com características e componentes mais simples e
inferiores a uma máquina física, se comportou deveras bem, mostrando que, no
caso de um servidor físico, não demonstraria problemas ao acesso simultâneo do
banco de dados.
60
4 CONCLUSÃO
Ante a preparação do atual projeto, foi possível analisar diferentes tipos de
tecnologias e disposições gerais em relação à natureza do software proposto.
Assim, tornou-se clara a necessidade de projetos e software, open source, voltados
ao inventário de equipamentos de informática, mais precisamente estações de
trabalho.
Pôde ser notada, também, a dificuldade de se adaptar um software deste
porte aos diversos tipos de hardware e sistemas operacionais encontrados no
mercado.
Assim, a opção de se utilizar scripts para a tarefa de aquisição de
informações tornou-se a melhor proposta, pois torna possível a adaptação e
adequação de acordo com as necessidades de cada ambiente.
Pôde-se, então, a partir dos scripts elaborados, na linguagem Perl, buscar as
devidas informações de uma estação, seja local ou remota, e salvá-las em um banco
de dados remoto. Desta forma pode-se criar uma interface de gerenciamento para
manuseio por parte de usuários, assim como a interface Syslist. Porém, tal interface
mostrou-se instável, após vários usos e testes, bem como, possui inconsistência em
sua base de dados, faltando tabelas e colunas importantes para o desenvolvimento
deste.
Frente à isso, há a percepção de que o desenvolvimento de um software,
aparentemente simples, não é algo tão fácil de ser executado. Vários são os fatores,
os quais determinam o cumprimento do prazo de término do software, dentre estes a
disponibilidade de tempo, semi-integral, para o mesmo.
Como
proposta
e
documentação
para
trabalhos
futuros,
existem
necessidades a serem sanadas e desenvolvidas como: criação de interface para
usuários, para tornar a utilização mais dinâmica; verificação dos scripts Windows e
Linux, para torna-los mais simples, adicionar funcionalidades (i.e. verificação de
data/versão, verificação de dispositivos de armazenamento em massa) e melhorias
nos mesmos (i.e. algoritmo para comparação de arquivos, algoritmo para inserção e
atualização de informações no banco de dados).
Concluindo este, torna-se, assim, imprescindível a disponibilização deste
trabalho, para realizações e projetos futuros, visando melhorias, desenvolvimento e
61
complementação dos scripts, revisão de ideias e desenvolvimento de interface
gráfica.
62
ANEXO A - Script Windows
Foram utilizadas as bibliotecas/módulos WIN do Perl, possibilitando assim a
aquisição de informações das estações por meio do banco de dados WMI, que
contém todas as informações referentes à máquina com Windows instalado.
# Write by Solli Moreira Honorio - Brazil
# [email protected]
# You can use as a GPL license
# Modified by @shundake - Brazil
# [email protected]
# Modified by Naylor Bachiega - Brazil
use Data::Dumper;
use Win32::OLE;
use Win32::OLE::Enum;
use Win32::TieRegistry(Delimiter=>"/");
use File::Compare;
my ($s, $mi, $h, $d,$m,$y,$wd) =
(localtime(time))[0,1,2,3,4,5,6];
my @diames = qw( Dom Seg Ter Qua Qui Sex Sab );
my @mes = qw( Jan Fev Mar Abr Mai Jun Jul Ago Set Out Nov
Dez );
my $date = $diames[$wd]."_".$d."_".$mes[$m]."_".($y+1900);
my $time = $h.":".$mi.":".$s;
##########################################################
######################
# if Verify files
##########################################################
######################
if ( -e $date.".txt" ){
63
if(-e $date."_1.txt"){
my $compare =
compare($date."_1.txt",$date.".txt");
open my $fst, "<", $date.".txt";
my $fstfile = <$fst>;
close $fst;
open my $snd, "<", $date."_1.txt";
my $sndfile = <$snd>;
close $snd;
if ($compare == 1){
if ($sndfile gt $fstfile){
unlink($date.".txt");
rename $date."_1.txt", $date.".txt";
$date = $date."_1";
} else {
unlink($date."_1.txt");
$date = $date."_1";
}
} else {
unlink($date."_1.txt");
$date = $date."_1";
}
} else {
$date = $date."_1";
}
}
##########################################################
######################
# if Print information to file
64
##########################################################
######################
open FILE, ">>", $date.".txt";
print FILE $time."\n\n\n";
%HostUser = &GetHostUserInfo();
%Hardware = &GetHardwareInfo();
%Software = &GetSoftwareInfo();
print FILE "Host and Users Info\n";
foreach my $Key01 ( keys %HostUser ) {
foreach my $Arr (@{$HostUser{$Key01}}) {
print FILE "\n";
foreach my $Key02 (keys %{$Arr}) {
print FILE "\t\t".$Key02." : ".$Arr>{$Key02}."\n";
}
}
}
print FILE "\nHardware Info\n";
foreach my $Key01 ( sort keys %Hardware ) {
foreach my $Arr (@{$Hardware{$Key01}}) {
print FILE "\n$Key01\n";
foreach my $Key02 (keys %{$Arr}) {
print FILE "\t\t".$Key02." : ".$Arr>{$Key02}."\n";
}
}
}
print FILE "\nSoftware Info\n";
foreach my $Key01 ( sort keys %Software ) {
65
print FILE "\t$Key01\n";
foreach my $Arr (@{$Software{$Key01}}) {
foreach my $Key02 (keys %{$Arr}) {
print FILE "\t\t$Key02 : $Arr->{$Key02}\n";
}
}
}
close (FILE);
##########################################################
######################
# Method
GetHostUserInfo
# Get
Server name and hash ref to rerturn
# Return
hash ref
##########################################################
######################
sub GetHostUserInfo {
my ( $Server ) = ".";
my ( $Rtrn, %MetaData, $WMIServices, @Var,
%HostUserInfo );
@{$MetaData{Win32_ComputerSystem}{Properties}}
= qw (Name UserName Workgroup Domain SystemType );
@{$MetaData{Win32_UserAccount}{Properties}}
= qw (Caption Description Disabled Domain Name FullName
LocalAccount PasswordChangeable PasswordExpires
PasswordRequired Status);
if ( $WMIServices = Win32::OLE->GetObject(
"winmgmts:{impersonationLevel=impersonate,(security)}!//$Serve
r/" ) )
{
66
foreach $Instance ( keys %MetaData )
{
undef ( @Var );
foreach my $Properties ( Win32::OLE::in(
$WMIServices->InstancesOf( $Instance ) ) )
{
++$#Var;
foreach my $Property (
@{$MetaData{$Instance}{Properties}} )
{
$Var[$#Var]{$Property} = $Properties>{$Property};
}
}
push ( @{%HostUserInfo->{$Instance}}, @Var );
}
return %HostUserInfo;
}
else
{
return Win32::OLE->LastError();
}
}
##########################################################
######################
# Method
GetHardwareInfo
# Get
Server name and hash ref to rerturn
# Return
hash ref
##########################################################
######################
sub GetHardwareInfo {
my ( $Server ) = ".";
67
my ( $Rtrn, %MetaData, $WMIServices, @Var,
%HardwareInfo );
@{$MetaData{Win32_BIOS}{Properties}}
= qw (Manufacturer Name PrimaryBIOS SerialNumber
SMBIOSBIOSVersion SMBIOSMajorVersion SMBIOSMinorVersion
SMBIOSPresent Status Version);
@{$MetaData{Win32_ComputerSystem}{Properties}}
= qw (Description Manufacturer Model NumberOfProcessors
ThermalState TotalPhysicalMemory);
@{$MetaData{Win32_ComputerSystemProduct}{Properties}}
= qw (Description IdentifyingNumber Name SKUNumber UUID Vendor
Version);
@{$MetaData{Win32_DiskDrive}{Properties}}
= qw (BytesPerSector Description ErrorDescription
ErrorMethodology Index InterfaceType Manufacturer MediaType
Model Name Partitions PNPDeviceID SCSIBus SCSILogicalUnit
SCSIPort SCSITargetId SectorsPerTrack Signature Size Status
StatusInfo TotalCylinders TotalHeads TotalSectors TotalTracks
TracksPerCylinder);
@{$MetaData{Win32_IDEController}{Properties}}
= qw (ConfigManagerErrorCode Manufacturer Name Status
StatusInfo);
@{$MetaData{Win32_LogicalDisk}{Properties}}
= qw (Name DriveType FileSystem Size
SupportsFileBasedCompression VolumeName VolumeSerialNumber);
@{$MetaData{Win32_PageFile}{Properties}}
= qw (Compressed CreationDate InitialSize MaximumSize Name);
@{$MetaData{Win32_PhysicalMemory}{Properties}}
= qw (BankLabel Capacity DeviceLocator MemoryType Speed);
@{$MetaData{Win32_Processor}{Properties}}
= qw (CpuStatus CurrentClockSpeed DeviceID Description
ExtClock SocketDesignation Role Name MaxClockSpeed
Manufacturer LastErrorCode L2CacheSize);
68
@{$MetaData{Win32_SCSIController}{Properties}}
= qw (ConfigManagerErrorCode DriverName DeviceID Manufacturer
Name Status StatusInfo);
@{$MetaData{Win32_NetworkAdapter }{Properties}}
= qw (AdapterType ConfigManagerErrorCode Description DeviceID
Index
LastErrorCode IPAddress MACAddress Manufacturer Name
ProductName ServiceName TimeOfLastReset);
if ( $WMIServices = Win32::OLE->GetObject(
"winmgmts:{impersonationLevel=impersonate,(security)}!//$Serve
r/" ) )
{
foreach $Instance ( keys %MetaData )
{
undef ( @Var );
foreach my $Properties ( Win32::OLE::in(
$WMIServices->InstancesOf( $Instance ) ) )
{
++$#Var;
foreach my $Property (
@{$MetaData{$Instance}{Properties}} )
{
$Var[$#Var]{$Property} = $Properties>{$Property};
}
}
push ( @{%HardwareInfo->{$Instance}}, @Var );
}
return %HardwareInfo;
}
else
{
return Win32::OLE->LastError();
}
69
}
##########################################################
######################
# Method
GetSoftwareInfo
# Get
Server name and hash ref to rerturn
# Return
hash ref
##########################################################
######################
sub GetSoftwareInfo
{
my ( $Server ) = ".";
my ( $Rtrn, %MetaData, $WMIServices, @Var, %Uninstall,
%SoftwareInfo );
@{$MetaData{Win32_OperatingSystem}{Properties}} = qw
(BootDevice BuildNumber BuildType Caption CodeSet CountryCode
CSDVersion CSName CurrentTimeZone ForegroundApplicationBoost
InstallDate LargeSystemCache LastBootUpTime Locale
Manufacturer Organization OSLanguage OSProductSuite Primary
ProductType RegisteredUser SerialNumber
ServicePackMajorVersion ServicePackMinorVersion Version
WindowsDirectory);
@{$MetaData{Win32_NTEventlogFile}{Properties}}
= qw
(Compressed CreationDate FileSize LogfileName MaxFileSize Name
NumberOfRecords OverwriteOutDated OverWritePolicy Status);
if ( $WMIServices = Win32::OLE->GetObject(
"winmgmts:{impersonationLevel=impersonate,(security)}!//$Serve
r/" ) )
{
foreach my $Instance ( keys %MetaData )
{
undef ( @Var );
70
foreach my $Properties ( Win32::OLE::in(
$WMIServices->InstancesOf( $Instance ) ) )
{
++$#Var;
foreach my $Property (
@{$MetaData{$Instance}{Properties}} )
{
$Var[$#Var]{$Property} = $Properties>{$Property};
}
}
push ( @{$SoftwareInfo->{$Instance}}, @Var );
}
# Get the Installed software
%Uninstall = %{ $Registry>{"//$Server/HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Windows/Cur
rentVersion/Uninstall"} };
undef ( @Var );
foreach my $Key ( keys %Uninstall )
{
next if ( $Key =~ m/^\//i );
next if ( $Uninstall{$Key}->{'/DisplayName'}
&&
$Uninstall{$Key}->{'/DisplayName'} eq
'' );
$Var[++$#Var]{Version}
= $Uninstall{$Key}-
>{'/DisplayVersion'};
$Var[$#Var]{DisplayName} = $Uninstall{$Key}>{'/DisplayName'};
$Var[$#Var]{InstallDate} = $Uninstall{$Key}>{'/InstallDate'};
71
$Var[$#Var]{Publisher}
= $Uninstall{$Key}-
$Key
=~ s/\///ig;
$Var[$#Var]{ProdID}
= $Key;
>{'/Publisher'
};
}
push ( @{%SoftwareInfo->{SoftwareInstalled}}, @Var
);
# Get the hotfix
%Uninstall = %{ $Registry>{"//$Server/HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Windows
NT/CurrentVersion/Hotfix"} };
undef ( @Var );
foreach my $Key ( keys %Uninstall )
{
$Var[++$#Var]{Version}
= $Uninstall{$Key}-
$Key
=~ s/\///ig;
$Var[$#Var]{ProdID}
= $Key;
>{'/Comments'};
}
push ( @{%SoftwareInfo->{HotFix}}, @Var );
return %SoftwareInfo;
}
else
{
return Win32::OLE->LastError();
}
return undef;
}
Inicialmente foi cogitada a ideia de se utilizar um arquivo de texto para reter
as informações adquiridas, para assim ser enviado ao servidor para que este se
72
encarregasse de armazenar e monitorar o conteúdo, no entanto, será utilizado um
banco de dados no servidor, e o arquivo de texto permanecerá na máquina cliente.
73
ANEXO B – Script Linux
No que se compete ao scritpt Linux, foram utilizados diretórios, arquivos e
comandos nativos, o que torna o processamento mais rápido e intuitivo.
Da mesma forma que no script para clientes Windows, é gerado um arquivo
de texto contendo as informações do mesmo, e então envia-se as mesmas
informações para o db.
#!/usr/bin/perl
use strict;
use Getopt::Long;
print "\n";
print get_cpu();
print "\n";
print get_mem();
print "\n";
print get_os();
print "\n";
print get_kernel();
print "\n";
print get_shell();
print "\n";
print get_terminal();
print "\n";
print get_disk_total();
print "\n";
sub get_cpu {
my $cpu = undef;
if($^O =~ /.*bsd$/) {
chomp($cpu = `sysctl -a | grep hw.model`);
$cpu =~ s/^hw.model:\s//;
$cpu =~ s/\s{2,}/ /;
74
}
else {
chomp($cpu = `uname -p`);
}
if(!defined($cpu) or($cpu eq 'unknown')) { # ARMs seems
to be 'unknown'
open(my $fh, '<', '/proc/cpuinfo') or die($!);
my @cpuinfo = <$fh>;
close($fh);
for(@cpuinfo) {
if(/^Processor\s+:\s+(.+)/ or
/^model\sname\s+:\s+(.+)/) {
$cpu = $1;
last;
}
}
}
return($cpu);
}
sub get_mem {
my $wanted = shift;
my ($total,$free,$buffers,$cached) = undef;
if(!defined($wanted)) {
$wanted = 'free';
}
if($^O =~ /.*bsd$/) {
open(my $un, '-|', 'sysctl -a') or warn($!);
while(<$un>) {
if(/^hw.realmem:\s+([0-9]+)/) {
$total = to_mb($1/1024);
}
elsif(/^hw.usermem:\s+([0-9]+)/) {
75
$free = to_mb($1/1024);
}
}
}
else {
open(my $fh, '<', '/proc/meminfo') or warn($!);
while(<$fh>) {
if(/^MemTotal:\s+([0-9]+)\s+/) {
$total = to_mb($1);
}
elsif(/^MemFree:\s+([0-9]+)\s+/) {
$free = to_mb($1);
}
elsif(/^Buffers:\s+([0-9]+)\s+/) {
$buffers = to_mb($1);
}
elsif(/^Cached:\s+([0-9]+)/) {
$cached = to_mb($1);
}
}
}
my $avail = $free + ($buffers + $cached);
my $used
= $total - $avail;
return($avail) if($wanted eq 'avail');
return($used)
if($wanted eq 'used');
return($total) if($wanted eq 'total');
}
sub to_mb {
my $kb = shift;
return(sprintf("%d",$kb/1024));
}
sub get_disk_total {
76
my $wanted = shift;
if(!defined($wanted)) {
$wanted = 'size';
}
my $df;
if($^O =~ /.*bsd$/) {
open($df, '-|', 'df -h -c') or warn($!);
}
else {
open($df, '-|', 'df -h --total') or warn($!);
}
my($size,$used,$avail,$percent);
while(<$df>) {
if(/^total\s+([0-9.,MGTP]+)\s+([0-9.,MGTP]+)\s+([09.,MGTP]+)\s+([0-9]+%)/) {
($size,$used,$avail,$percent) = ($1,$2,$3,$4);
$percent =~ s/\%//;
if($percent >= 90) {
$percent = sprintf("%s%%", $percent);
}
else {
$percent = sprintf("%s%%", $percent);
}
for(($size,$used,$avail)) {
#FIXME Make this a callable function
s/([A-Z])//;
my $notation = $1;
next if(!defined($notation));
if($notation eq 'M') {
$_ = sprintf("%s%s", $_, $notation);
}
77
elsif($notation eq 'G') {
$_ = sprintf("%s%s", $_, $notation);
}
elsif($notation eq 'T') {
$_ = sprintf("%s%s", $_, $notation);
}
}
}
}
return($size)
if($wanted eq 'size');
return($used)
if($wanted eq 'used');
return($avail)
if($wanted eq 'avail');
return($percent) if($wanted eq 'percent');
return(-1);
}
sub get_os {
if(-e '/etc/arch-release') {
return("GNU/Linux (Arch Linux)");
}
elsif(-e '/usr/bin/crux') {
return("GNU/Linux (CRUX)");
}
elsif(-e '/etc/grml-version') {
open FILE, "</etc/grml-version";
chomp(my $line = <FILE>);
$line =~ s/\s\[[-0-9]+\]//;
close FILE;
return("GNU/Linux (${line})");
}
elsif(-e '/etc/debian_version') {
open FILE, "</etc/debian_version";
chomp(my $line = <FILE>);
close FILE;
78
return("GNU/Linux (Debian ${line})");
}
elsif(-e '/etc/sabayon-edition') {
open FILE, "</etc/sabayon-edition";
chomp(my $line= <FILE>);
$line=~ s/^.*?(\w+)[.!?]?\s*$/$1/;
close FILE;
return("GNU/Linux (Sabayon ${line})");
}
elsif(-e '/etc/gentoo-release') {
return("GNU/Linux (Gentoo)");
}
elsif($^O eq 'linux') {
return("GNU/Linux"); # be nice
}
elsif($^O eq 'freebsd') {
return("FreeBSD");
}
else {
return("Unknown");
}
}
sub get_kernel {
if($^O =~ /bsd$/) {
return(`uname -r`);
}
else {
open(my $fh, '<', '/proc/version') or warn($!);
my $version = <$fh>;
# extended to match kernels [1-3]
my ($kernel) = $version =~ /([1-3][.][0-9][.0-9\S]+)/;
return($kernel);
}
79
}
sub get_shell {
my $shell = $ENV{SHELL};
return(-1) unless(defined($shell));
$shell =~ s;.+/(.+)$;$1;;
return($shell);
}
sub get_terminal { return($ENV{TERM}); }
De mesma forma que no Windows, foi utilizada uma ferramenta nativa do
sistema operacional para agendar a execução do script, no caso do Linux foi
utilizado o cron, tornando possível a adequação de acordo com as necessidades do
administrador de redes.
80
ANEXO C – Agendar execução do script no Linux
O cron é um programa de agendamento de tarefas. Com ele pode-se
programar qualquer coisa para ser executada em uma certa periodicidade ou até
mesmo em um exato dia, numa exata hora. Um uso bem comum do cron é o
agendamento de tarefas administrativas de manutenção do seu sistema, como por
exemplo, procura por links simbólicos quebrados, análise de segurança do sistema,
backup, entre outros. Estas tarefas são programadas para todo dia, toda semana ou
todo mês, serem automaticamente executadas através do crontab e um script shell
comum. A configuração do cron geralmente é chamada de crontab.
Os sistemas Linux possuem o cron sempre presente. A configuração tem
duas partes: Uma global, e uma por usuário. Na global, que é o root quem controla,
o crontab pode ser configurado para executar qualquer tarefa de qualquer lugar,
como qualquer usuário. Já na parte por usuário, cada usuário tem seu próprio
crontab, sendo restringido apenas ao que o usuário pode fazer (e não tudo, como é
o caso do root).
Para configurar um crontab por usuário, utiliza-se o comando crontab, junto
com um parâmetro, dependendo do que você quiser fazer. Abaixo uma relação:
Comando
Função
crontab -e
Edita o crontab atual do usuário
crontab -l
Exibe o atual conteúdo do crontab do usuário
crontab -r
Remove o crontab do usuário
Se quiser verificar os arquivos crontab dos usuários, é necessário ser root. O
comando crontab coloca os arquivos dos usuários no diretório:
/var/spool/cron/usuario
Onde “usuario” corresponde ao usuário dono do arquivo crontab.
Pode se, também utilizar o crontab global, este fica no arquivo “/etc/crontab“,
e só pode ser manipulado pelo root. Um exemplo de formato da linha do crontab:
0 4 * * * who
81
Então como pode ser observado, a linha é dividida em 6 campos separados
por tabs ou espaço:
Campo
Função
1o.
Minuto
2o.
Hora
3o.
Dia do mês
4o.
Mês
5o.
Dia da semana
6o.
Programa para execução
Todos estes campos, sem contar com o 6º, são especificados por números.
Abaixo encontra-se uma relação para os valores destes campos:
Campo
Valores
Minuto
0-59
Hora
0-23
Dia do mês
1-31
Mês
1-12
Dia da semana
0-6 (o “0″ é domingo), 1 é segunda, etc.
Em
algumas
distribuições,
os
agendamentos
mais
comuns
estão
programados para serem executados, conforme exemplos abaixo.
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly
O programa “run-parts” executa todos os scripts executáveis dentro de um
certo diretório. Então com essas linhas, temos diretórios programados para executar
82
programas de hora em hora, diariamente, semanalmente ou mensalmente. Abaixo a
tabela:
Diretório
Período
/etc/cron.hourly
De hora em hora
/etc/cron.daily
Diariamente
/etc/cron.weekly
Semanalmente
/etc/cron.monthly
Mensalmente
Então todos os arquivos executáveis dentro de cada diretório serão
executados no seu correspondente período. Ou seja, ao colocar um certo conteúdo
no arquivo “/etc/cron.daily/teste“, depois torná-lo executável através do comando
“chmod +x /etc/cron.daily/teste“, e então ele será executado todo dia as 4:02 da
manhã.
83
ANEXO D – Arquivo de saída do script
Através da execução do script, este busca as informações da estação de
trabalho, local ou remota, e salva em um arquivo de texto para, então, enviar as
informações via rede para o banco de dados, localizado no servidor. Segue abaixo o
modelo do arquivo de texto gerado pelo script do Nehmo.
23:9:33
Host and Users Info
Win32_ComputerSystem
Description : AT/AT COMPATIBLE
Domain : WORKGROUP
Name : GRAVE
SystemType : X86-based PC
Workgroup : WORKGROUP
Win32_UserAccount
Caption : grave\Administrador
Description : Conta interna para a administração
do computador/domínio
Disabled : 1
Domain : grave
LocalAccount : 1
Name : Administrador
PasswordRequired : 1
Win32_UserAccount
Caption : grave\Convidado
Description : Conta interna para acesso como
convidado ao computador/domínio
Disabled : 1
Domain : grave
84
LocalAccount : 1
Name : Convidado
PasswordRequired : 0
Win32_UserAccount
Caption : grave\shundake
Description :
Disabled : 0
Domain : grave
LocalAccount : 1
Name : shundake
PasswordRequired : 0
Hardware Info
Win32_BIOS
Manufacturer : innotek GmbH
Name : Default System BIOS
PrimaryBIOS : 1
SMBIOSBIOSVersion : VirtualBox
SerialNumber : 0
Status : OK
Version : ACRSYS - 1
Win32_ComputerSystem
Description : AT/AT COMPATIBLE
Manufacturer : innotek GmbH
Model : VirtualBox
NumberOfProcessors : 1
ThermalState : 2
TotalPhysicalMemory : 1073274880
Win32_ComputerSystemProduct
Description : Computer System Product
85
IdentifyingNumber : 0
Name : VirtualBox
SKUNumber :
UUID : 737D373E-11ED-5C4B-9FBC-05E1E4FD3B8B
Vendor : innotek GmbH
Version : 1.2
Win32_DiskDrive
BytesPerSector : 512
Description : Unidade de disco
ErrorDescription :
ErrorMethodology :
Index : 0
InterfaceType : IDE
Manufacturer : (Unidades de disco padrão)
MediaType : Fixed hard disk media
Model : VBOX HARDDISK ATA Device
Name : \\.\PHYSICALDRIVE0
PNPDeviceID :
IDE\DISKVBOX_HARDDISK___________________________1.0_____\5&33D
1638A&0&0.0.0
Partitions : 2
SCSIBus : 0
SCSILogicalUnit : 0
SCSIPort : 2
SCSITargetId : 0
SectorsPerTrack : 63
Signature : 1901971486
Size : 10733990400
Status : OK
StatusInfo :
TotalCylinders : 1305
TotalHeads : 255
TotalSectors : 20964825
86
TotalTracks : 332775
TracksPerCylinder : 255
Win32_IDEController
ErrorCode :
Manufacturer : (Controladores padrão IDE
ATA/ATAPI)
Name : ATA Channel 1
Status : OK
StatusInfo :
Win32_IDEController
ErrorCode :
Manufacturer : Standard AHCI 1.0 Serial ATA
Controller
Name : Standard AHCI 1.0 Serial ATA Controller
Status : OK
StatusInfo :
Win32_IDEController
ErrorCode :
Manufacturer : Intel
Name : Intel(R) 82371AB/EB PCI Bus Master IDE
Controller
Status : OK
StatusInfo :
Win32_IDEController
ErrorCode :
Manufacturer : (Controladores padrão IDE
ATA/ATAPI)
Name : ATA Channel 0
Status : OK
StatusInfo :
87
Win32_IDEController
ErrorCode :
Manufacturer : (Controladores padrão IDE
ATA/ATAPI)
Name : ATA Channel 0
Status : OK
StatusInfo :
Win32_LogicalDisk
DriveType : 3
FileSystem : NTFS
Name : C:
Size : 10630459392
SupportsFileBasedCompression : 1
VolumeSerialNumber : 9CDBF976
VolumeSize :
Win32_LogicalDisk
DriveType : 5
FileSystem :
Name : D:
Size :
SupportsFileBasedCompression :
VolumeSerialNumber :
VolumeSize :
Win32_LogicalDisk
DriveType : 4
FileSystem : VBoxSharedFolderFS
Name : E:
Size : 695263412224
SupportsFileBasedCompression : 0
VolumeSerialNumber : 00000802
88
VolumeSize :
Win32_NetworkAdapter
AdapterType :
ConfigManagerErrorCode : 0
Description : WAN Miniport (SSTP)
DeviceID : 0
IPAddress :
Index : 0
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : WAN Miniport (SSTP)
ProductName : WAN Miniport (SSTP)
ServiceName : RasSstp
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType :
ConfigManagerErrorCode : 0
Description : WAN Miniport (IKEv2)
DeviceID : 1
IPAddress :
Index : 1
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : WAN Miniport (IKEv2)
ProductName : WAN Miniport (IKEv2)
ServiceName : RasAgileVpn
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType :
89
ConfigManagerErrorCode : 0
Description : WAN Miniport (L2TP)
DeviceID : 2
IPAddress :
Index : 2
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : WAN Miniport (L2TP)
ProductName : WAN Miniport (L2TP)
ServiceName : Rasl2tp
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType :
ConfigManagerErrorCode : 0
Description : WAN Miniport (PPTP)
DeviceID : 3
IPAddress :
Index : 3
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : WAN Miniport (PPTP)
ProductName : WAN Miniport (PPTP)
ServiceName : PptpMiniport
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType :
ConfigManagerErrorCode : 0
Description : WAN Miniport (PPPOE)
DeviceID : 4
IPAddress :
90
Index : 4
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : WAN Miniport (PPPOE)
ProductName : WAN Miniport (PPPOE)
ServiceName : RasPppoe
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType :
ConfigManagerErrorCode : 0
Description : WAN Miniport (IPv6)
DeviceID : 5
IPAddress :
Index : 5
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : WAN Miniport (IPv6)
ProductName : WAN Miniport (IPv6)
ServiceName : NdisWan
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType :
ConfigManagerErrorCode : 0
Description : WAN Miniport (Network Monitor)
DeviceID : 6
IPAddress :
Index : 6
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
91
Name : WAN Miniport (Network Monitor)
ProductName : WAN Miniport (Network Monitor)
ServiceName : NdisWan
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType : Ethernet 802.3
ConfigManagerErrorCode : 0
Description : Intel(R) PRO/1000 MT Desktop
Adapter
DeviceID : 7
IPAddress :
Index : 7
LastErrorCode :
MACAddress : 08:00:27:3F:B9:47
Manufacturer : Intel
Name : Intel(R) PRO/1000 MT Desktop Adapter
ProductName : Intel(R) PRO/1000 MT Desktop
Adapter
ServiceName : E1G60
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType :
ConfigManagerErrorCode : 0
Description : WAN Miniport (IP)
DeviceID : 8
IPAddress :
Index : 8
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : WAN Miniport (IP)
ProductName : WAN Miniport (IP)
92
ServiceName : NdisWan
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType : Tunnel
ConfigManagerErrorCode : 0
Description : Adaptador do Microsoft ISATAP
DeviceID : 9
IPAddress :
Index : 9
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : Adaptador do Microsoft ISATAP
ProductName : Adaptador do Microsoft ISATAP
ServiceName : tunnel
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType :
ConfigManagerErrorCode :
Description : RAS Async Adapter
DeviceID : 10
IPAddress :
Index : 10
LastErrorCode :
MACAddress :
Manufacturer :
Name : RAS Async Adapter
ProductName : RAS Async Adapter
ServiceName :
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
93
AdapterType : Tunnel
ConfigManagerErrorCode : 0
Description : Adaptador de Túnel Teredo da
Microsoft
DeviceID : 11
IPAddress :
Index : 11
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : Teredo Tunneling Pseudo-Interface
ProductName : Adaptador de Túnel Teredo da
Microsoft
ServiceName : tunnel
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType : Tunnel
ConfigManagerErrorCode : 0
Description : Adaptador do Microsoft ISATAP
DeviceID : 12
IPAddress :
Index : 12
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : Adaptador do Microsoft ISATAP
ProductName : Adaptador do Microsoft ISATAP
ServiceName : tunnel
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType : Ethernet 802.3
ConfigManagerErrorCode : 0
94
Description : Intel(R) PRO/1000 MT Desktop
Adapter
DeviceID : 13
IPAddress :
Index : 13
LastErrorCode :
MACAddress : 08:00:27:72:6D:A2
Manufacturer : Intel
Name : Intel(R) PRO/1000 MT Desktop Adapter #2
ProductName : Intel(R) PRO/1000 MT Desktop
Adapter
ServiceName : E1G60
TimeOfLastReset : 20130620195038.489985-180
Win32_NetworkAdapter
AdapterType : Tunnel
ConfigManagerErrorCode : 0
Description : Adaptador do Microsoft ISATAP
DeviceID : 14
IPAddress :
Index : 14
LastErrorCode :
MACAddress :
Manufacturer : Microsoft
Name : Adaptador do Microsoft ISATAP #3
ProductName : Adaptador do Microsoft ISATAP
ServiceName : tunnel
TimeOfLastReset : 20130620195038.489985-180
Win32_Processor
CpuStatus : 0
CurrentClockSpeed : 1475
Description : x64 Family 6 Model 15 Stepping 13
DeviceID : CPU0
95
ExtClock :
L2CacheSize :
LastErrorCode :
Manufacturer : GenuineIntel
MaxClockSpeed : 1475
Name : Intel(R) Core(TM)2 Duo CPU
2.00GHz
Role : CPU
SocketDesignation :
Software Info
T5750
@
96
REFERÊNCIAS BIBLIOGRÁFICAS
APACHE.
About
Apache.
2012.
Disponível
<http://httpd.apache.org/ABOUT_APACHE.html> Acesso em: 16 dez. 2012.
em:
CARMONA, Tadeu. Universidade Linux. 1ª Ed. São Paulo: Digerati Books. 2007.
DGN STÚDIO. Glossário de Termos de Informática. 2007. Disponível em:
<http://webmaster.dgnstudios.com.br/manuais/glossarioinfo.htm> Acesso em: 22 mar.
2012
ELMASRI, Ramez; NAVATHE, Shamkant B.; Sistemas de banco de dados. 4. Ed.
São Paulo: Pearson Addison Wesley. 2005
FATEC
GUARATINGUETÁ.
Hardware.
2012.
Disponível
em:
<http://www.fatecguaratingueta.com.br/blog/?p=123> Acesso em: 26 mar. 2012.
KUROSE, James F.; ROSS, Keith W. Redes de computadores e a Internet: uma
abordagem top-down. 5. ed. São Paulo: Pearson Addison Wesley. 2010
LAURIE, Ben; LAURIE, Peter. The Apache Definitive Guide. 2. ed. O'Reilly, 1999
LIMA, Pedro. COLÉGIO LICEAL. Redes de Comunicação. 2012. Disponível em:
<http://redescomunicacao10.blogspot.com.br> Acesso em: 23 set. 2012.
MARIADB FOUNDATION. MariaDB. 2013. Disponível em <https://mariadb.org/>
Acesso em: 04 jun. 2013.
MICROSOFT.
História
do
Windows.
2012.
Disponível
em:
<http://windows.microsoft.com/pt-BR/windows/history> Acesso em: 14 abr. 2012.
______. Schtasks. 2013. Disponível em: <http://technet.microsoft.com/ptbr/library/cc725744(v=ws.10).aspx> Acesso em: 04 jun. 2013.
MORIMOTO, Carlos E. Hardware: O guia definitivo. 1. ed. GdH Press e Sul
Editores. 2007.
NEMETH, Evi; SNYDER, Garth; HEIN, Trent R. Manual Completo do Linux: Guia
do Administrador. 1ª Ed. São Paulo: Pearson Makron Books. 2004.
RHASAN,
Ragib.
History
of
Linux.
2005.
http://ragibhasan.com/linux/ Acesso em: 05 mar. 2013.
Disponível
em:
ROSCH, Winn L. Hardware Bible. 1. ed. Que Publishing. 2003.
SCHWARTZ, Randal L.; PHOENIX, Tom; D FOY, Brian. Learning Perl. 5. ed.
Sebastopol: O’Reilly, 2008.
SIEVER, Ellen et al. Perl In A Nutshell. 1. ed. O’Reilly, 1998.
97
TANENBAUM, Andrew S. Redes de Computadores. 4. ed. Campus. 2003
TITTEL, Ed; BURMEISTER, Mary. HTML 4 For Dummies. 5. ed. Indianapolis: Wiley
Publishing, 2005.
VALADE, Janet. PHP 5 For Dummies. Indianapolis: Wiley Publishing, 2004.
VENTURA, Plínio. O modelo OSI e suas 7 camadas. iMasters, 2002. Disponível em
<http://imasters.com.br/artigo/882/redes-e-servidores/o-modelo-osi-e-suas-7camadas> Acesso em: 30 out. 2012.
WALL, Larry et al. Programming Perl. 2. ed. O’Reilly, 1996.