twitcam

campus party 2016

windows 10

4G

quinta-feira, 26 de novembro de 2015

Vazam novas imagens do primeiro celular da Nokia pós-Microsoft


Há alguns meses, rumores indicam que a Nokia tem interesse em voltar ao mercado de smartphones quando seu acordo com a Microsoft, que comprou a divisão de celulares da empresa em 2014, chegar ao fim. Imagens do C1, suposto primeiro aparelho com sistema Android da fabricante, vazaram na web essa semana.
As imagens conceituais, e não fotos do produto final, começaram a circular numa rede social da China chamada Weibo (equivalente ao Twitter). Nas artes, é possível ver o celular exibindo um menu típico do sistema Android e também uma versão com Windows.
Isso reforça recentes rumores de que o C1 será capaz de rodar ambos os sistemas operacionais, a partir da preferência do usuário. Contudo, não se sabe ainda se o aparelho terá dual-boot - isto é, se o dono poderá trocar de Android para Windows e vice-versa a qualquer momento - ou se a escolha do sistema será feita no momento da compra e não poderá ser alterada depois.
De qualquer modo, o contrato com a Microsoft impede que a Nokia lance seus próprios smartphones no mercado antes do fim de 2016. Ou seja, mesmo que essas imagens sejam reais, ainda deve demorar até que o C1 seja oficialmente revelado.

EUA são avisados de ataques de hackers iranianos pelo Facebook

Oficiais do Departamento de Estado dos Estados Unidos foram vítimas de um cibertaque vindo de hackers iranianos recentemente e, de acordo com o jornal The New York Times, o governo tomou conhecimento da invasão de uma maneira inusitada: por um aviso do Facebook.

A descoberta aconteceu graças a um sistema de alerta a ataques governamentais implantado pelo Facebook no mês de outubro. Os oficiais receberam mensagens que diziam que eles estavam sendo vítimas de ataques de "atores patrocinados pelo Estado".

A intenção dos hackers era atacar primeiro as contas do pessoal mais jovem de dentro do Departamento, para, a partir daí, alcançarem os seus superiores.

Entenda o caso

Após um acordo que limita as pretensões atômicas que foi assinado pelos dois países, o Irã parece ter se voltado para a ciberespionagem, já tendo realizado ataques anteriores.

A diferença entre os primeiros ataques e esse é que o último foi mais elaborado, afinal, enquanto os primeiros envolviam coisas como sites falsos, nesse eles quebraram e-mails e contas dos oficiais em redes sociais.

WhatsApp ganha atualização definitiva com novas funções para Android


O WhatsApp acaba de ganhar uma nova atualização nas versões que rodam no sistema Android. Entre as facilidades implementadas estão as marcações de mensagens como não lidas e a inclusão definitiva do emoji de dedo do meio ao pacote gráfico do aplicativo.

Outras novidades que os usuários atualizados perceberão é a possibilidade de editar notificações de cada conversa e um modo que reduz o consumo de dados do aparelho durante as ligações telefônicas realizadas pelo aplicativo. Anteriormente isso só era possível depois de uma "gambiarra" no sistema, onde um arquivo APK era baixado e liberava os recursos. 

Embora algumas dessas funções já estivessem disponíveis de modo oficial em algumas versões BETA, que foram disponibilizadas para serem testados por uma série de usuários ao redor do mundo, agora é oficial: todas as versões do Android em operação receberam a atualização do aplicativo.

Mozilla não precisa mais do dinheiro do Google



A decisão de trocar o Google por outros buscadores no Firefox deu certo para a Mozilla e hoje a fundação pode afirmar que não precisa mais do dinheiro da antiga parceira - tanto que não recebe mais nenhum centavo de lá.
A Mozilla divulgou dados financeiros referentes a 2014, revelando ter movimentado US$ 330 milhões naquele ano - e boa parte veio do Google, que era o buscador padrão oficial do Firefox. No final do ano, a fundação acabou com o acordo para gerar mais competição, abrindo espaço para serviços como Yahoo (que assumiu nos EUA), Baidu (China) e Yandex (Rússia).
Embora o Google permaneça como buscador padrão na Europa, isso não gera receita para a Mozilla, segundo afirmou a diretora de negócios da fundação, Denelle Dixon-Thayer, à CNET. “Não temos uma relação comercial com o Google neste momento.”
Os US$ 330 milhões são uma alta em relação à receita de US$ 314 reportada em 2013. E o diretor financeiro, Jim Cook, aposta que o crescimento será mantido justamente graças às parcerias fechadas com outros buscadores. “Estamos ansiosos para divulgar nossos resultados no ano que vem”, disse ele.

Direito ao esquecimento obriga Google a sumir com milhares de links



Desde que passou a ser obrigado a respeitar o direito ao esquecimento na Europa, em maio de 2014, o Google recebeu mais de 348 mil requisições no continente. Dados divulgados pela empresa na última quarta-feira, 25, revelam que o Google teve de analisar, individualmente, mais de 1,2 milhão de URLs, porque é comum que uma única requisição envolva vários sites.
Quarenta e dois porcento dos links analisados acabaram sendo retirados do sistema de buscas, o que equivale a cerca de 518 mil páginas.
Não se sabe quais critérios o Google usa para julgar se deve ou não sumir com um resultado, mas a empresa deu pistas de como age dando exemplos de casos que passaram pelo seu crivo. Fica claro que pessoas públicas têm chances menores de ter seus pedidos aceitos devido ao grau de interesse da sociedade nos assuntos.
Mas os julgamentos não são simples arbitrariedades do Google. A empresa dá o exemplo de um caso em que após remover links sobre um “crime pequeno” cometido no Reino Unido, o Google foi obrigado pela Justiça a remover também links que levavam a um jornal que noticiou a primeira ação.
A maioria dentre os dez sites mais afetados até agora atua na área das redes sociais, tanto que o topo da lista fica com o Facebook, que teve 10,2 mil URLs removidas do Google. YouTube, Badoo, Google+ e Twitter também aparecem com destaque.

Nova lei não afeta briga entre operadoras, Whatsapp e Netflix, diz governo


 


O lançamento por parte do governo federal, nesta segunda-feira (23), de uma consulta pública sobre mudanças no modelo de concessões de telecomunicações do país não deverá resolver recentes polêmicas das empresas do setor contra o aplicativo Whatsapp e o serviço de streaming de vídeos Netflix, diz o ministro André Figueiredo Lima.
Ambas as empresas são criticadas pelas companhias telefônicas por não estarem sujeitas ao mesmo nível de tributos que elas e por isso representarem concorrência desleal --uma discussão semelhante à briga entre taxistas e o Uber.
"Eu acho que uma regulação brasileira por si só não vai resolver. Acho que tem que ter alguma ação internacional, multilateral, para que a gente possa discutir algo que aflige todos os países", afirmou o ministro.
A consulta pública, que pode ser acessada no site do Ministério das Comunicações, tem o objetivo de rediscutir o atual modelo de prestação de serviços de telecomunicações e a importância dos serviços de suporte à banda larga.
A consulta vai até 23 de dezembro e o governo quer que o modelo pronto seja levado ao Congresso até o primeiro trimestre do próximo ano, para que sua aprovação ocorra ainda em 2016.

Saiba mais

Algumas das principais operadoras de telefonia móvel do país iniciaram --ainda que de forma velada-- uma disputa contra o WhatsApp em uma "tentativa desesperada" de nomear culpados aos seus próprios prejuízos, na visão de especialistas em telecomunicação e em direito digital ouvidos pelo UOL.
O Netflix chegou ao Brasil em 2011. Dois estudos independentes sugerem que o país se transformou no quarto maior mercado para a empresa, logo depois de Estados Unidos, Canadá e Grã-Bretanha. São 69 milhões de usuários no mundo todo.
A conexão de internet no Brasil, que frequentemente é de baixa qualidade, também testou a tecnologia da empresa --que ajusta a qualidade da transmissão de vídeo de acordo com a banda larga disponível.
Segundo Lima, em termos de recolhimento de impostos e investimento em infraestrutura, as empresas de aplicativos "não fazem, pelo menos no Brasil, absolutamente nada".

Pressão das operadoras

Na consulta pública para mudar o modelo de concessões de telecomunicações, o mercado de telefonia fixa poderá ser a maior afetada. No fim de outubro, o presidente da Telecom Italia, Marco Patuano, disse que uma eventual fusão entre sua controlada TIM e a Oi depende da atualização do marco regulatório da telefonia fixa do Brasil.
O mercado brasileiro de telefonia fixa é dominado por duas concessionárias, Telefônica Brasil e Oi, mas a crescente migração de usuários para a telefonia móvel e banda larga tem elevado a importância no processo de consolidação das rivais Claro, do grupo América Móvil, e TIM.
A chance de consolidação ganhou força nas últimas semanas após a empresa de investimentos russa Letter One se oferecer para injetar até 4 bilhões de dólares na Oi se um acordo com a TIM acontecer.
Perguntado se a pressa do governo decorre de pressão das operadoras de telefonia interessadas no processo de consolidação, o ministro respondeu que "não necessariamente".
"Quando nos reunimos separadamente com representantes das operadoras (Oi e TIM), eles manifestaram essa intenção, mas não colocaram essa mudança na lei como condicionante. Precisamos atualizar a lei, isso é indiscutível. Independente de qualquer consolidação entre operadoras", disse Lima a jornalistas.
Os atuais contratos de concessão de telefonia fixa vencem em 2025, mas são renovados a cada cinco anos. Após a renovação em 2005, a primeira revisão ocorreu em 2011, referente ao período 2011-15. A nova revisão será para o período 2016-20.
Segundo fontes próximas do assunto disseram à Reuters em outubro, as operadoras propuseram à Anatel e ao Ministério das Comunicações transformar as concessões de telefonia fixa em regime de autorização, como acontece no serviço celular. A mudança faria com que as empresas não tenham mais obrigações de cobertura e universalização da oferta do serviço.
Sua mãe está no WhatsApp? Se sim, você certamente vai se identificar bastante com a página criada no Facebook --com mais de 17 mil curtidas-- em que filhos tornam públicas as gafes das genitoras. Elas nem sempre dominam a tecnologia e até podem cometer um errinho ou outro, mas sabem muito bem o que dizer aos filhos, independente do momento, e doa a quem doer!

linux entendendo o sistema

UMA INTRODUÇAO

O sistema operacional é o responsável por "dar vida" ao PC, fazer a placa de vídeo mandar imagens para o monitor, a placa de rede enviar e receber dados e assim por diante. Ele é o responsável por fazer as coisas funcionarem e rodar os programas da forma mais estável e rápida possível.
Existem vários sistemas operacionais, que servem às mais diversas aplicações, de servidores a celulares. O Linux é um sistema livre, o que significa que ele não é desenvolvido por uma única empresa ou organização, ele é a soma dos esforços de uma comunidade mundial, que inclui tanto empresas quanto desenvolvedores autônomos.
O código fonte é aberto, o que permite que qualquer interessado estude e modifique o sistema. Muitas destas melhorias acabam sendo incorporadas ao sistema principal, fazendo com que ele evolua muito rápido.
UM POUCO SOBRE A HISTORIA DO LINUX
Paralelamente à história da informática que conhecemos, com a IBM lançando seu IBM PC em 1981, o MS-DOS e as várias versões do Windows, existiram várias versões dos sistemas Unix, como o Solaris e o AIX que reinaram durante muito tempo nos servidores.
Mas, o Windows foi o primeiro sistema operacional amigável e acessível, que o transformou numa espécie de opção default para micros domésticos. A Apple tinha o Mac OS, outro sistema amigável e superior ao Windows em muitos aspectos, mas que só rodava nos computadores produzidos pela própria Apple, muito mais caros que os PCs.
Quem precisava de um sistema robusto e confiável para seus servidores optava por uma das várias versões do Unix, profissionais da área gráfica usavam Macs e o resto convivia com os problemas do Windows.
O Linux surgiu de uma forma completamente despretensiosa, como o projeto de um estudante Finlandês. Muitos sistemas são desenvolvidos como projetos de conclusão de curso ou apenas por hobby. O que permitiu que o Linux se transformasse no que é foi uma grande combinação de fatores e alguma dose de sorte.
Tudo começou em 1983, pouco depois que a IBM lançou seu primeiro PC e a Microsoft sua primeira versão do DOS. Richard Stallman criava a Free Software Fundation, que ao longo da década produziu a licença GNU e toda a base filosófica relacionada a ela e, mais importante, um conjunto de ferramentas, como o editor Emacs e o compilador GCC.
O Emacs é um editor de texto que combina uma grande quantidade de recursos e ferramentas úteis para programadores. O GCC é o compilador que permite transformar o código escrito nele em arquivos executáveis. A idéia era desenvolver um sistema operacional completo, mas para isso faltava a peça principal: o Kernel.
Imagine o Kernel como o cérebro e o coração de um sistema operacional. Ele sozinho não serve para nada, mas sem ele o resto do corpo também não vai muito longe. Em 1991, a Free Software Fundation ainda estava dando os primeiros passos no desenvolvimento do Hurd (que ainda hoje está muito longe se ser concluído), enquanto o Linux de Linus Torvalds era utilizável desde suas primeiras versões. O corpo encontrava o cérebro.
O fato do código fonte estar amplamente disponível e poder ser utilizado de forma muito liberal permitiu que muitos desenvolvedores passassem a trabalhar no sistema ainda em sua fase embrionária, adicionando novos recursos num ritmo muito rápido. Mas, durante os primeiros anos, o Linux ficou restrito a este círculo técnico, muito longe de ser usado em larga escala.
Isso começou a mudar com o aparecimento da Internet. O Apache foi um dos primeiros servidores web a ser lançado e tornou-se rapidamente o mais usado numa época em que existiam poucos concorrentes à altura. O Apache rodava em várias plataformas, mas o Linux tornou-se a opção mais comum, por ser rápido e estável.
Pouco tempo depois veio o servidor Samba, que permitia compartilhar arquivos numa rede Windows, de forma mais estável e mais barata que usando um servidor Windows. Novamente, o Linux tornou-se a opção preferida. Depois, vieram os bancos de dados e muitas outras aplicações, mas todas tinham algo em comum: sempre falávamos de servidores.
Por volta do final de 1994 foi lançada a primeira versão for Linux do Xfree. Ele é um "servidor gráfico", uma interface gráfica usada em vários sistemas Unix. Antes do Xfree, o Linux tinha apenas a velha interface de modo texto, o que explicava o fato de ele ser popular apenas entre programadores e administradores de sistemas. Em 2004, o Xfree passou a ser gradualmente substituído pelo X.org.
Uma coisa interessante sobre o X é que ele fornece a fase para o funcionamento da parte gráfica, incluindo o suporte à placa de vídeo e mouse, mas não inclui a interface em si. Graças a isso, não existe uma interface gráfica padrão como temos no Windows, por exemplo.
Existem no Linux várias interfaces diferentes, conhecidas como gerenciadores de janelas. No início existiam muitas interfaces diferentes, mas nenhuma chegava próxima do nível de funcionalidade e integração que existe no Windows. Isto mudou com o aparecimento do KDE (que é a interface usada por padrão em diversas distribuições, incluindo o Mandriva, SuSE e o Kurumin) e mais tarde também com o Gnome.
Ainda por volta de 1994 começaram a surgir as primeiras distribuições Linux, que eram um jeito mais "fácil" de instalar o sistema. Ao invés de ficar compilando tudo, começando pelo Kernel e passando por todos os aplicativos da Free Software Fundation, Xfree e o que mais você pretendesse rodar, você simplesmente passava alguns dias editando arquivos de configuração com a ajuda de alguns manuais mal escritos. Para você ter uma idéia do tamanho da encrenca, uma das distribuições consideradas mais "amigáveis" na época era o Slackware, ainda em suas primeiras versões.
Se você é algum saudosista desta época em que "homens eram homens e compilavam seus sistemas do zero", sinta-se livre para pesquisar no Google sobre o "Linux from Scratch", um passo a passo (com muitos passos...) que ensina como fazer isso. Pobres mortais como eu, possuem coisas mais urgentes e menos chatas a fazer... ;-).
Uma distribuição é um conjunto com o Kernel e vários programas, empacotado de forma que seja fácil de instalar e manter atualizado. Uma das primeiras versões com foco na facilidade de uso foi o Red Hat, que serviu de base para um grande número de distribuições, como o Mandrake, SuSE e Conectiva.
O Red Hat trouxe uma idéia nova, que foi rapidamente adotada em todas as outras distribuições: um sistema de gerenciamento de pacotes. Cada programa incluído era transformado num pacote compactado, que podia ser instalado através de um único comando. O sistema guardava as informações dos pacotes instalados permitindo que você pudesse removê-los depois. Não era tão amigável quanto clicar num executável e ter um instalador gráfico e, existiam problemas com dependências (um pacote precisa do outro, que precisa do outro, que precisa do outro...), mas já era muito melhor que sair compilando as coisas na unha.
Por volta de 1997 já existiam um conjunto de distribuições relativamente fáceis de usar, com sistemas de instalação relativamente simples, do tipo que um técnico médio consegue seguir sozinho com a ajuda do manual.
Nesta época algumas empresas passaram a portar seus sistemas e utilizar o Linux como uma forma de reduzir seus custos com licenciamento e manutenção (imunidade a vírus, menos travamentos, menos reinstalações do sistema; quem já usou o Windows 3.11 ou o 95 sabe do que estou falando...). O Linux dava seus primeiros passos no desktop, mas ainda existiam poucos aplicativos que rivalizassem em recursos e facilidade de uso com os do Windows.
Nos anos seguintes houve um crescimento espantoso. Aquele sistema feio, difícil de usar, famoso apenas por ser estável e bom para servidores ganhou o KDE e o Gnome, finalmente duas interfaces bonitas e fáceis de usar, ferramentas de configuração automática e um grande número de aplicativos, incluindo compatibilidade com alguns programas e jogos do Windows através do Wine, o que levou a um número cada vez maior de desenvolvedores e usuários.
Ao contrário de um sistema comercial, com todo o planejamento e estruturas envolvidas, o Linux é desenvolvido de forma descentralizada. Qualquer um pode pegar o código de algum programa, adaptá-lo, acrescentar novos recursos e transformá-lo em algo diferente do original, com aplicações que o autor original não seria capaz de sequer sonhar.
Isto cresce em escala geométrica, como uma bola de neve que vai crescendo e passando por cima de quem se atrever a oferecer resistência.
A licença GPL, pode ser resumida em 4 direitos básicos e uma obrigação:
1- Você tem o direito de usar o programa para qualquer fim. Não existe discriminação. Um exemplo é que ninguém pode impedir que um programa GPL seja usado numa clínica de aborto ou numa instalação militar, por exemplo.
2- Você tem o direito de tirar cópias do programa, distribuí-las ou até mesmo vendê-las a quem tiver interesse. Existe a possibilidade de ganhar algum dinheiro vendendo CDs gravados, por exemplo, mas como todo mundo pode fazer a mesma coisa, é preciso vender por um preço relativamente baixo, cobrando pelo trabalho de gravação e não pelo software em si, que está largamente disponível. A forma mais eficiente de ganhar dinheiro com software livre é vender suporte e serviços de personalização sobre os programas e distribuições que você domina. Para o cliente acaba sendo vantajoso, pois o custo de implantação será o gasto com a consultoria e treinamentos, enquanto ao implantar um software comercial qualquer ele gastaria também com as licenças de uso.
3- Direito de ter acesso ao código fonte do programa, fazer alterações e redistribuí-las. Para um programador este é o principal atrativo, pois você pode criar novos projetos usando como base o código fonte de programas já existentes ao invés de ter sempre que começar do zero, sem falar na grande oportunidade de aprendizado que examinar o código fonte dos programas disponíveis propicia.
4- Direito (e ao mesmo tempo a obrigação) de redistribuir as modificações feitas. Este é o ponto onde existem mais mal-entendidos. Se você desenvolve um software por hobby, ou por usá-lo internamente na sua empresa, e não possui interesse em explorá-lo comercialmente, você pode simplesmente divulgar o código fonte para todo mundo, o que é o caminho mais lógico se você pretende atrair outros interessados em ajudá-lo no desenvolvimento. Mas, caso você pretenda receber pelo seu trabalho de desenvolvimento, existem duas opções:
a) Você pode distribuir o software livremente para aumentar a base de usuários e ganhar vendendo suporte, treinamentos e personalizações ou:
b) Você só é obrigado a distribuir o código fonte a quem obtém o software, de forma que você pode trabalhar batendo de porta a porta, vendendo o software para alguns clientes específicos e fornecendo o código fonte apenas para eles. Não existe nada de errado com este modelo, mas você perde a possibilidade de ter contribuições de outros desenvolvedores, o que pode ser ruim a longo prazo.
5- Os softwares distribuídos sob a GPL não "contaminam" softwares comerciais ou de outras licenças no caso de distribuição conjunta. Por exemplo, uma revista pode distribuir alguns softwares GPL no meio de um monte de aplicativos fechados na mesma edição. Os softwares GPL continuam sendo GPL, com todas regras que vimos acima, enquanto os softwares comerciais continuam sendo fechados. A revista deve incluir o código fonte dos aplicativos GPL (ou pelo menos a informação de como obtê-los via internet), mas naturalmente não precisa fazer o mesmo com os outros aplicativos incluídos no CD.
Você pode também usar algum software GPL em conjunto com o seu aplicativo comercial, desenvolvendo um aplicativo qualquer que utiliza o Postgree SQL (um servidor de banco de dados), por exemplo. O Postgree SQL continua sendo GPL e o seu aplicativo continua sendo fechado; qualquer um pode usar e tirar cópias do Postgree SQL, mas você controla a distribuição do seu aplicativo. Uma coisa não interfere com a outra.

Um exemplo: desenvolvi o Kurumin usando como base dois projetos já existentes, o Knoppix e o Debian. O Knoppix entrou com sistema de detecção de hardware e configuração automática e o Debian com toda a base do sistema, como os pacotes e ferramentas de administração como o apt-get. Ao invés de ter que ficar compilando tudo, posso usar os pacotes do Debian que já estão prontos; e, ao invés de ficar desenvolvendo mais um ferramenta de detecção, posso usar o sistema do Knoppix que funciona extremamente bem.
Como a parte funcional do sistema já está pronta, posso trabalhar personalizando o sistema, desenvolvendo scripts de instalação, ferramentas de configuração, adicionando novos recursos e corrigindo problemas. Começo do ponto aonde os outros já chegaram, aproveitando todo o esforço anterior.
Quando alguém desenvolve um projeto derivado, uma outra distribuição Linux usando o Kurumin como base, como o Kalango ou o Dizinha, ganho novamente, pois posso utilizar as correções e novos recursos adicionados neles.
Muitas pessoas que utilizam o Kurumin acabam contribuindo com soluções para problemas e melhorias diversas. Para eles é interessante fazer isso, pois os problemas são resolvidos nas novas versões, evitando que eles precisem ficar corrigindo manualmente os novos problemas indefinidamente.
O LINUX HOJE
Hoje em dia já existem ferramentas suficientes para desenvolver distribuições muito fáceis de usar. Quase toda a configuração do sistema pode ser feita de forma automática e não é mais necessário sequer instalar o sistema, pois ele pode rodar a partir do CD-ROM, como no caso do Kurumin. Existem ainda um grande número de distribuições especializadas, destinadas a públicos específicos: artistas gráficos, multimídia, escolas, servidores e assim por diante.
A instalação de novos programas é mais simples na maioria dos casos, pois os programas são mais acessíveis. Você não precisa gastar um monte de dinheiro, ou ir até o camelô da esquina e depois ficar zanzando pelos sites de cracks (e pegar mais vírus...) para conseguir rodar sua cópia ilegal. Na maioria dos casos basta baixar o programa e instalar.
Gerenciadores como o apt-get são capazes de baixar os pacotes da internet e fazer toda a instalação automaticamente, de forma bem mais simples que no Windows, onde você precisa comprar o CD com o programa, instalar, registrar e muitas vezes ainda perder tempo removendo spywares ou propagandas.
Com exceção de aplicativos muito especializados, como o AutoCAD, Corel e Premier, existem boas alternativas para quase todas as áreas e existe suporte a programas nativos do Windows através do Wine (que devagar vai aumentando sua lista de compatibilidade) ou através do VMware, que aborda o problema de uma forma diferente, permitindo rodar uma cópia completa do Windows dentro de uma janela. Ainda existem deficiências, mas por outro lado também vários pontos em que o Linux já é mais forte.
Existe ainda suporte à quase todo tipo de hardware: mesmo softmodems, scanners e câmeras digitais não são um problema se você pesquisar um pouco antes de comprar.
Apesar de todos os progressos em termos de facilidade de uso, notícias sobre vírus, trojans e pragas em geral para Linux são raras, ao contrário do que vemos no mundo Windows. Você não precisa sacrificar o desempenho da sua máquina mantendo um antivírus ativo e atualizando-o religiosamente apenas para ser no final surpreendido pela última versão do vírus da moda que chegou por e-mail.
É comum ouvir notícias de servidores Linux que estão ligados há vários anos, de forma contínua, sem nunca serem reiniciados ou invadidos. Ao usar um micro com componentes de boa qualidade, é possível ter uma amostra desta estabilidade mesmo num desktop. Uma instalação bem feita pode durar meses ou até anos. Mesmo muitas pessoas leigas, que usam o micro apenas para navegar e ler e-mails estão migrando para o Kurumin ou outras distribuições fáceis de usar, a fim de fugir dos travamentos e vírus.
Como a filosofia Open Source privilegia a troca de informações e a cooperação, é fácil achar informações na web e, se você for educado, ajuda nos fóruns. Como em qualquer sociedade é possível encontrar todo tipo de pessoas, existem alguns grupos elitistas e gente mal-educada, mas em geral eles são as exceções, não a regra. Como usuário ou como desenvolvedor, você tem acesso a uma grande quantidade de informação e a chance de aprender mais.
O foco deste livro é explicar a estrutura do sistema, mostrar os programas e ferramentas de instalação disponíveis e abordar em detalhes a instalação e configuração. O objetivo é fornecer a base necessária para que você consiga trabalhar com várias distribuições.
Neste livro abordo três distribuições: o Kurumin, que apesar de ser um projeto pessoal acabou se tornando uma das mais usadas no Brasil; o Ubuntu, outra distribuição com foco na facilidade de uso que vem crescendo rapidamente; e o Slax, uma distribuição derivada do Slackware, que é uma forma mais fácil e agradável de aprender a trabalhar com ele.
A placa-mãe é o componente mais importante do micro, pois é ela a responsável pela comunicação entre todos os componentes. Pela enorme quantidade de chips, trilhas, capacitores e encaixes, a placa-mãe também é o componente que, de uma forma geral, mais dá defeitos. É comum que um slot PCI pare de funcionar (embora os outros continuem normais), que instalar um pente de memória no segundo soquete faça o micro passar a travar, embora o mesmo pente funcione perfeitamente no primeiro, e assim por diante.
A maior parte dos problemas de instabilidade e travamentos são causados por problemas diversos na placa-mãe, por isso ela é o componente que deve ser escolhido com mais cuidado.
A qualidade da placa-mãe é de longe mais importante que o desempenho do processador. Você mal vai perceber uma diferença de 20% no clock do processador, mas com certeza vai perceber se o seu micro começar a travar ou se a placa de vídeo onboard não tiver um bom suporte no Linux.
Ao montar um PC de baixo custo, economize primeiro no processador, depois na placa de vídeo, som e outros periféricos. Deixe a placa-mãe por último no corte de despesas.
Não se baseie apenas na marca da placa na hora de comprar, mas também no fornecedor. Como muitos componentes entram no país ilegalmente, "via Paraguai", é muito comum que lotes de placas remanufaturadas, ou defeituosas acabem chegando ao mercado. Muita gente compra estes lotes, vende por um preço um pouco abaixo do mercado e depois desaparece. Outras lojas simplesmente vão vendendo placas que sabem ser defeituosas até acharem algum cliente que não reclame. Muitas vezes os travamentos da placa são confundidos com "paus do Windows", de forma que sempre aparece algum desavisado que não percebe o problema.
Antigamente existia a polêmica entre as placas com ou sem componentes onboard. Hoje em dia isso não existe mais, pois todas as placas vem com som e rede onboard. Apenas alguns modelos não trazem vídeo onboard, atendendo ao público que vai usar uma placa 3D off-board e prefere uma placa mais barata ou com mais slots PCI do que com o vídeo onboard que, de qualquer forma, não vai usar.
Quanto aos conectores, temos na placa-mãe dois conectores IDE para conectar o HD e o CD-ROM, um slot AGP (o marrom) para a placa de vídeo, vários slots PCI (os brancos) para o modem, placa de som e outras placas, soquetes para conectar a memória, o soquete para o processador, o conector para a fonte de alimentação e o painel traseiro, que agrupa os encaixes dos componentes onboard, incluindo o vídeo, som, rede e portas USB.
O soquete (ou slot) para o processador é a principal característica da placa-mãe, pois indica com quais processadores ela é compatível. Você não pode instalar um Athlon 64 numa placa soquete A (que é compatível com os Athlons, Durons e Semprons), nem muito menos encaixar um Sempron numa placa soquete 478, destinada aos Pentium 4. O soquete é na verdade apenas um indício de diferenças mais "estruturais" na placa, incluindo o chipset usado, o layout das trilhas de dados, etc. É preciso desenvolver uma placa quase que inteiramente diferente para suportar um novo processador.
Existem ainda dois tipos de portas para a conexão do HD: as portas IDE tradicionais, de 40 pinos (PATA, de Parallel ATA) e os conectores SATA (Serial ATA), que são muito menores. Muitas placas recentes incluem um único conector PATA e quatro conectores SATA. Outras incluem as duas portas IDE tradicionais e dois conectores SATA e, algumas já passam a trazer apenas conectores SATA, deixando de lado os conectores antigos. Existem ainda algumas placas "legacy free", que eliminam também os conectores para o drive de disquete, portas seriais e porta paralela, incluindo apenas as portas USB. Isso permite simplificar o design das placas, reduzindo o custo de produção.
Tudo isso é montado dentro do gabinete, que contém outro componente importante: a fonte de alimentação. A função da fonte é transformar a corrente alternada da tomada em corrente contínua (AC) já nas tensões corretas, usadas pelos componentes. Ela serve também como uma última linha de defesa contra picos de tensão e instabilidade na corrente, depois do nobreak ou estabilizador.
Embora quase sempre relegada a último plano, a fonte é outro componente essencial num PC atual. Com a evolução das placas de vídeo e processadores, os PCs consomem cada vez mais energia. Na época dos 486, as fontes mais vendidas tinham 200 watts ou menos, enquanto as atuais têm a partir de 450 watts. Uma fonte subdimensionada não é capaz de fornecer energia suficiente nos momentos de pico, causando desde erros diversos, provocados por falhas no fornecimento (o micro trava ao tentar rodar um game pesado, ou trava sempre depois de algum tempo de uso, por exemplo), ou, em casos mais graves, até mesmo danos aos componentes. Uma fonte de má qualidade, obrigada a trabalhar além do suportado, pode literalmente explodir, danificando a placa-mãe, memórias, HDs e outros componentes sensíveis.
Evite comprar fontes muito baratas e, ao montar um micro mais parrudo, invista numa fonte de maior capacidade.
Não se esqueça também do fio terra, que é outro componente importante, mas freqüentemente esquecido. O fio terra funciona como uma rota de fuga para picos de tensão provenientes da rede elétrica. A eletricidade flui de uma forma similar à água: vai sempre pelo caminho mais fácil. Sem ter para onde ir, um raio vai torrar o estabilizador, a fonte de alimentação e, com um pouco mais de azar, a placa-mãe e o resto do micro. O fio terra evita isso, permitindo que a eletricidade escoe por um caminho mais fácil, deixando todo o equipamento intacto.
O fio terra é simplesmente uma barra de cobre com dois a três metros de comprimento, que é cravada no solo, no meio de um buraco de 20 cm de largura, preenchido com sal grosso e carvão. Naturalmente, instalar o terra é trabalho para o eletricista, até porque cavar o buraco e cravar a barra não é um trabalho nada fácil :-). Sem o terra, o estabilizador perde grande parte de sua função, tornando-se mais um componente decorativo, que vai ser torrado junto com o resto, do que uma proteção real.
Nas grandes cidades, é relativamente raro acontecer dos micros queimarem por causa de raios, pois os transformadores e disjuntores oferecem uma proteção razoável. Mas, pequenos picos de tensão são responsáveis por pequenos danos nos pentes de memória e outros componentes sensíveis, danos que se acumulam, comprometendo a estabilidade e abreviando a vida útil do equipamento.
A longo prazo, o investimento na instalação do terra e melhorias na instalação elétrica acabam se pagando com juros, principalmente se você tem mais de um micro.
HARDWARE VS SOFTWARE
Toda esta parte física, as coisas tangíveis, que você pode tocar é chamada de hardware. A parte mais importante vem depois, o Software, os programas que permitem que o computador faça coisas úteis. É aí que entra o sistema operacional e, depois dele, os programas que usamos no dia-a-dia.
Um bom sistema operacional é invisível. A função dele é detectar e utilizar o hardware da máquina de forma eficiente, fornecendo uma base estável sobre a qual os programas que utilizamos no cotidiano possam ser usados. Como diz Linus Torvalds, as pessoas não usam o sistema operacional, usam os programas instalados. Quando você se lembra que está usando um sistema operacional, é sinal de que alguma coisa não está funcionando como deveria.
O sistema operacional permite que o programador se concentre em adicionar funções úteis, sem ficar se preocupando com que tipo de placa de vídeo ou placa de som você tem. O programa diz que quer mostrar uma janela na tela e ponto; o modelo de placa de vídeo que está instalado e que comandos são necessários para mostrar a janela são problema do sistema operacional.
Para acessar a placa de vídeo, ou qualquer outro componente instalado, o sistema operacional precisa de um driver, que é um pequeno programa que trabalha como um intérprete, permitindo que o sistema converse com o dispositivo. Cada placa de vídeo ou som possui um conjunto próprio de recursos e comandos que permitem usá-los. O driver converte estes diferentes comandos em comandos padrão, que são entendidos pelo sistema operacional.
O driver é como se fosse a chave do carro, sem ela você não entra no carro nem dá a partida e ele não serve para nada. Comprar uma impressora ou scanner que não possua driver para o Linux, ou outro sistema operacional que você pretende utilizar, é como comprar um carro sem a chave. Pesquise antes para não levar gato por lebre.
ARQUITETURAS

Nos primórdios da informática, nas décadas de 50, 60 e 70, vários fabricantes diferentes disputavam o mercado. Cada um desenvolvia seus próprios computadores, que eram incompatíveis entre si. Tanto o hardware quanto os softwares para cada arquitetura não funcionavam nas outras. Isso causava uma ineficiência generalizada, pois cada fabricante tinha que desenvolver tudo, da placa-mãe ao sistema operacional.

No começo dos anos 80, os fabricantes começaram a se especializar. Surgiu então o PC que é uma arquitetura aberta, um conjunto de padrões que permite usar periféricos de vários fabricantes diferentes e roda vários tipos de sistemas operacionais.
O principal concorrente é a Apple, que produz os Macs. Ao contrário dos PCs, eles possuem uma arquitetura fechada. A Apple desenvolve tanto os computadores quando o sistema operacional.
Naturalmente muita coisa é terceirizada e várias empresas desenvolvem programas e acessórios, mas como a Apple precisa manter o controle de tudo e desenvolver muita coisa por conta própria, o custo dos Macs acaba sendo bem mais alto que o dos PCs. Isso faz com que (embora tenham seus atrativos) eles sejam muito menos populares. Atualmente os Macs possuem menos de 3% do mercado mundial, o que significa uma proporção de mais de 30 PCs para cada Mac.
No início da década de 80, a concorrência era mais acirrada e muitos achavam que o modelo da Apple poderia prevalecer, mas não foi o que aconteceu. Dentro da história da informática temos inúmeras histórias que mostram que os padrões abertos quase sempre prevalecem. Um ambiente onde existem várias empresas concorrendo entre si favorece o desenvolvimento de produtos melhores, o que cria uma demanda maior e, graças à economia de escala, permite preços mais baixos.
Como os micros PC possuem uma arquitetura aberta, ou seja, a possibilidade de vários fabricantes diferentes desenvolverem seus próprios componentes baseados em padrões já definidos, temos uma lista enorme de componentes compatíveis entre si. Podemos escolher entre várias marcas e modelos os componentes que melhor atendam nossas necessidades e montar nossa própria configuração, de acordo com o uso.
Qualquer novo fabricante, com uma placa-mãe mais barata ou um processador mais rápido, por exemplo, pode entrar no mercado, é apenas uma questão de criar a demanda necessária. A concorrência faz com que os fabricantes sejam obrigados a trabalhar com uma margem de lucro relativamente baixa, ganhando com base no volume de peças vendidas, o que é muito bom para nós que compramos.

UM POUCO SOBRE REDES


Montar uma rede já foi complicado e caro. Hoje em dia, as redes são algo onipresente, uma forma barata de trocar arquivos, compartilhar a conexão com a internet, compartilhar impressoras, CD-ROM e outros periféricos e assim por diante.
O uso mais corriqueiro é compartilhar a conexão com a internet. Você tem apenas uma linha ADSL ou apenas uma assinatura do serviço de acesso via cabo e pode acessar, ao mesmo tempo, a partir de todos os micros que tiver em sua casa ou empresa. Neste caso um dos micros atua como um ponto de encontro, enviando os pedidos de todos para a internet e devolvendo as respostas. Além de compartilhar a conexão, este servidor pode compartilhar arquivos, servir como firewall (protegendo a rede de acessos externos), rodar um proxy (que permite criar um cache de arquivos e páginas acessados, melhorando a velocidade da conexão), além de outros serviços.
Outra necessidade comum é compartilhar arquivos. Antigamente (naquela época em que os micros tinham 512 KB de memória e os homens eram homens e escreviam seus próprios sistemas operacionais) era usado o protocolo DPL/DPC (disquete pra lá, disquete pra cá), mas ele não era muito eficiente, principalmente quando o amigo que estava esperando os arquivos estava em outra cidade...
Os componentes básicos da rede são uma placa de rede para cada micro, os cabos e o hub ou switch que serve como um ponto de encontro, permitindo que todos os micros se enxerguem e conversem entre si.
As placas de rede já foram componentes caros, mas como elas são dispositivos relativamente simples e o funcionamento é baseado em padrões abertos, qualquer um pode abrir uma fábrica de placas de rede, o que faz com que exista uma concorrência acirrada que obriga os fabricantes a produzirem placas cada vez mais baratas e trabalhem com margens de lucro cada vez mais estreitas. As placas de rede mais baratas chegam a ser vendidas no atacado por menos de três dólares. O preço final é um pouco mais alto naturalmente, mas não é difícil achar placas por 20 reais ou até menos.
Temos três padrões de redes Ethernet: de 10 megabits, 100 megabits e 1 gigabit. As placas são intercompatíveis, mas, ao usar placas de velocidades diferentes, as duas vão conversar na velocidade da placa mais lenta.
As redes 10 megabits já são obsoletas, mas ainda é possível encontrar muitas instalações antigas por aí. Caso a rede já use cabos de categoria 5 (o número vem decalcado no cabo), é possível fazer um upgrade direto para 100 megabits, trocando apenas o hub e placas.
Lembre-se de que a velocidade das placas é calculada em bits e não em bytes. Uma rede de 100 megabits permite uma taxa de transmissão (teórica) de 12.5 MB/s. Como além dos dados são transmitidas outras informações (a estrutura dos pacotes, retransmissões, códigos de correção de erros, etc.), a velocidade na prática fica sempre um pouco abaixo disso. Normalmente é possível transferir arquivos a no máximo 10.5 MB/s, com a taxa máxima variando sutilmente de acordo com a placa e o sistema operacional usado.
A opção para quem precisa de mais velocidade são as redes Gigabit Ethernet, que transmitem a até 1000 megabits (125 megabytes) por segundo. As placas Gigabit atuais são compatíveis com os mesmos cabos de par trançado categoria 5, usados pelas placas de 100 megabits, por isso a diferença de custo fica por conta apenas das placas e do switch. Elas ainda são muito mais caras, mas pouco a pouco o preço vai caindo.
Os cabos de rede também são um artigo relativamente barato. Os cabos de categoria 5 que usamos em redes de 100 ou 1000 megabits geralmente custam em torno de 80 centavos o metro, com mais alguns centavos por conector.
Você pode comprar quantos metros de cabo quiser, junto com os conectores e fazer crimpar os cabos você mesmo, ou pode comprá-los já prontos. É no caso dos cabos já crimpados que o preço começa a variar. Algumas lojas chegam a crimpar os cabos na hora cobrando apenas o valor do material, enquanto outras vendem os cabos por preços exorbitantes.
Os cabos devem ter um mínimo de 30 centímetros e um máximo de 100 metros, a distância máxima que o sinal elétrico percorre antes que comece a haver uma degradação que comprometa a comunicação. Na verdade, estes valores não são exatos, principalmente com relação ao comprimento máximo do cabo.
Não é incomum ver gente usando cabos fora do padrão, com 120, 150 ou, em alguns casos até 200 metros. Dependendo da qualidade das placas de redes, cabos, conectores, crimpagem e do nível de interferências do ambiente, o sinal pode se propagar por distâncias bem acima dos 100 metros, mas neste caos sem garantia nenhuma de estabilidade. Até 100 metros você pode ter certeza de que a rede funcionará, acima disso começa a depender da sorte.
Existem dois tipos de cabos de rede: os cabos retos (straight), que são os cabos "normais", usados para ligar os vários micros ao hub ou switch, e os cabos cross-over, que utilizam um padrão diferente, que permite ligar diretamente dois micros, sem precisar de um hub.
Todas as placas são ligadas ao hub ou switch, que serve como uma central, de onde os sinais de um micro são retransmitidos para os demais. Todas as placas de rede são ligadas ao hub ou switch e é possível ligar vários hubs ou switchs entre si (até um máximo de 7) caso necessário, formando redes maiores.
A diferença entre um hub é um switch é que o hub apenas retransmite tudo o que recebe para todos os micros conectados a ele, é um tagarela. Isso faz com que apenas um micro consiga transmitir dados de cada vez e que todas as placas precisem operar na mesma velocidade (sempre nivelada por baixo, caso você coloque um micro com uma placa de 10 megabits na rede, a rede toda passará a trabalhar a 10 megabits).
Os switchs, por sua vez, são aparelhos mais inteligentes. Eles fecham canais exclusivos de comunicação entre o micro que está enviando dados e o que está recebendo, permitindo que vários pares de micros troquem dados entre si ao mesmo tempo. Isso melhora bastante a velocidade em redes congestionadas, com muitos micros.
Antigamente, existia uma grande diferença de preço entre os hubs burros e os switchs, mas os componentes caíram tanto de preço que a partir de um certo ponto a diferença se tornou insignificante e os fabricantes passaram a fabricar apenas switchs, que por sua vez dividem-se em duas categorias: os switchs "de verdade", aparelhos caros, capazes de gerenciar o tráfego de uma quantidade maior de micros e que possuem várias ferramentas de gerenciamento e os "hub-switchs", os modelos mais simples e baratos, que usamos no dia-a-dia.
O TCP/IP E A CONFIGURAÇAO DA REDE
Tudo o que vimos até agora, sobre placas e cabos representa a parte física da rede, os componentes necessários para fazer os uns e zeros enviados por um computador chegarem ao outro. O TCP/IP é o protocolo de rede, o conjunto de regras e padrões que permite que eles realmente falem a mesma língua.
Pense nas placas, hubs e cabos como o sistema telefônico e no TCP/IP como a língua falada que você usa para realmente se comunicar. Não adianta nada ligar para alguém na China que não saiba falar Português. Sua voz vai chegar até lá, mas ela não vai entender nada. Além da língua em si, existe um conjunto de padrões, como por exemplo dizer "alô" ao atender o telefone, dizer quem é, se despedir antes de desligar, etc.
Ligar os cabos e ver se os leds do hub e das placas estão acesos é o primeiro passo. O segundo é configurar os endereços da rede para que os micros possam conversar entre si, e o terceiro é finalmente compartilhar a internet, arquivos, impressoras e o que mais você quer que os outros micros da rede tenham acesso.
Graças ao TCP/IP, tanto o Linux quanto o Windows e outros sistemas operacionais em uso são intercompatíveis dentro da rede. Não existe problema para as máquinas com o Windows acessarem a internet através da conexão compartilhada no Linux, por exemplo.
Independente do sistema operacional usado, as informações básicas para que ele possa acessar a internet através da rede são:

- Endereço IP:
Os endereços IP identificam cada micro na rede. A regra básica é que cada micro deve ter um endereço IP diferente e todos devem usar endereços dentro da mesma faixa.
O endereço IP é dividido em duas partes. A primeira identifica a rede à qual o computador está conectado (necessário, pois numa rede TCP/IP podemos ter várias redes conectadas entre si, veja o caso da internet) e a segunda identifica o computador (chamado de host) dentro da rede. É como se o mesmo endereço contivesse o número do CEP (que indica a cidade e a rua) e o número da casa.
A parte inicial do endereço identifica a rede e os últimos identificam o computador dentro da rede. Quando temos um endereço "192.168.0.1", por exemplo, temos o micro "1" dentro da rede "192.168.0". Quando alguém diz "uso a faixa 192.168.0.x na minha rede", está querendo dizer justamente que apenas o último número muda de um micro para outro.
Na verdade, os endereços IP são números binários, de 32 bits. Para facilitar a configuração e memorização dos endereços, eles são quebrados em 4 números de 8 bits cada um. Os 8 bits permitem 256 combinações diferentes, por isso usamos 4 números de 0 a 255 para representá-los.
Todos os endereços IP válidos na internet possuem dono. Seja alguma empresa ou alguma entidade certificadora que os fornece junto com novos links. Por isso não podemos utilizar nenhum deles a esmo.
Quando você se conecta na internet você recebe um (e apenas um) endereço IP válido, emprestado pelo provedor de acesso, algo como por exemplo "200.220.231.34". É através deste número que outros computadores na Internet podem enviar informações e arquivos para o seu.
Quando quiser configurar uma rede local, você deve usar um dos endereços reservados, endereços que não existem na internet e que por isso podemos utilizar à vontade em nossas redes particulares. Algumas das faixas reservadas de endereços são: 10.x.x.x, 172.16.x.x até 172.31.x.x e 192.168.0.x até 192.168.255.x
Você pode usar qualquer uma dessas faixas de endereços na sua rede. Uma faixa de endereços das mais usadas é a 192.168.0.x, onde o "192.168.0." vai ser igual em todos os micros da rede e muda apenas o último número, que pode ser de 1 até 254 (o 0 e o 255 são reservados para o endereço da rede e o sinal de broadcast). Se você tiver 4 micros na rede, os endereços deles podem ser, por exemplo, 192.168.0.1, 192.168.0.2, 192.168.0.3 e 192.168.0.4.

- Máscara de sub-rede
A máscara é um componente importante do endereço IP. É ela que explica para o sistema operacional como é feita a divisão do endereço, ou seja, quais dos 4 octetos compõem o endereço da rede e quais contém o endereço do host, ou seja, o endereço de cada micro dentro da rede.
Ao contrário do endereço IP, que é formado por valores entre 0 e 255, a máscara de sub-rede é formada por apenas dois valores: 0 e 255, como em 255.255.0.0 ou 255.0.0.0, onde um valor 255 indica a parte endereço IP referente à rede, e um valor 0 indica a parte endereço IP referente ao host.
Se você está usando a faixa 192.168.0.x, por exemplo, que é um endereço de classe C, então a máscara de sub-rede vai ser 255.255.255.0 para todos os micros. Você poderia usar uma máscara diferente: 255.255.0.0 ou mesmo 255.0.0.0, desde que a máscara seja a mesma em todos os micros.
Se você tiver dois micros, 192.168.0.1 e 192.168.0.2, mas um configurado com a máscara "255.255.255.0" e o outro com "255.255.0.0", você terá na verdade duas redes diferentes. Um dos micros será o "1" conectado na rede "192.168.0" e o outro será o "0.2", conectado na rede "192.168".

- Default Gateway (gateway padrão)
Lembra que disse que quando você se conecta à internet através de um provedor de acesso qualquer, você recebe apenas um endereço IP válido? Quando você compartilha a conexão entre vários micros, apenas o servidor que está compartilhando a conexão possui um endereço IP válido, só ele "existe" na internet. Todos os demais acessam através dele.
O default gateway ou gateway padrão é justamente o micro da rede que tem a conexão, que os outros consultarão quando precisarem acessar qualquer coisa na internet.
Por exemplo, se você montar uma rede doméstica com 4 PCs, usando os endereços IP 192.168.0.1, 192.168.0.2, 192.168.0.3 e 192.168.0.4, e o PC 192.168.0.1 estiver compartilhando o acesso à internet, as outras três estações deverão ser configuradas para utilizar o endereço 192.168.0.1 como gateway padrão.

- Servidor DNS
Memorizar os 4 números de um endereço IP é muito mais simples do que memorizar o endereço binário. Mas, mesmo assim, fora os endereços usados na sua rede interna, é complicado sair decorando um monte de endereços diferentes.
O DNS (domain name system) permite usar nomes amigáveis ao invés de endereços IP para acessar servidores, um recurso básico que existe praticamente desde os primórdios da internet. Quando você se conecta à internet e acessa o endereço http://www.hardware.com.br/, é um servidor DNS que converte o "nome fantasia" no endereço IP real do servidor, permitindo que seu micro possa acessar o site.
Para tanto, o servidor DNS mantém uma tabela com todos os nomes fantasia, relacionados com os respectivos endereços IP. A maior dificuldade em manter um servidor DNS é justamente manter esta tabela atualizada, pois o serviço tem que ser feito manualmente. Dentro da internet, temos várias instituições que cuidam desta tarefa. No Brasil, por exemplo, temos a FAPESP. Para registrar um domínio é preciso fornecer à FAPESP o endereço IP real do servidor onde a página ficará hospedada. A FAPESP cobra uma taxa de manutenção anual de R$ 30 por este serviço.
Servidores DNS também são muito usados em intranets, para tornar os endereços mais amigáveis e fáceis de guardar.
Faz parte da configuração da rede informar os endereços DNS do provedor (ou qualquer outro servidor que você tenha acesso), que é para quem seu micro irá perguntar sempre que você tentar acessar qualquer coisa usando um nome de domínio e não um endereço IP. O jeito mais fácil de conseguir os endereço do provedor é simplesmente ligar para o suporte e perguntar.
O ideal é informar dois endereços, assim se o primeiro estiver fora do ar, você continua acessando através do segundo. Também funciona com um endereço só, mas você perde a redundância. Exemplos de endereços de servidores DNS são: 200.204.0.10 e 200.204.0.138.
No Kurumin você encontra a opção de configurar a rede dentro do Painel de Controle, em "Conectar na internet ou configurar a rede > Configurar conexão via rede local". O assistente vai perguntando as configurações da rede que vimos.
Um exemplo de configuração de rede completa para um dos micros da rede, que vai acessar a internet através do micro que está compartilhando a conexão seria:
IP: 192.168.0.2
Máscara: 255.255.255.0
Gateway: 192.168.0.1 (o endereço do micro compartilhando a conexão)
DNS: 200.204.0.10 200.204.0.138
O micro que está compartilhando a conexão por sua vez vai ter duas placas de rede, uma para a internet e outra para a rede local, por isso vai ter uma configuração separada para cada uma. A configuração da internet é feita da forma normal, de acordo com o tipo de conexão que você usa, e a configuração da rede interna segue o padrão que vimos até aqui.
É possível usar também um servidor DHCP para fornecer as configurações da rede para os micros, de forma que você não precise ficar configurando os endereços manualmente em cada um. O configurador do Kurumin pergunta sobre isso logo na primeira opção: "Configurar a rede via DHCP"?
Respondendo "Sim", o micro simplesmente "pede socorro" na rede e é ajudado pelo servidor DHCP, que fornece para ele toda a configuração da rede, de forma automática. Você gasta um pouco mais de tempo configurando o servidor DHCP, mas em compensação economiza na configuração dos micros.
REDES WIRELESS
Apesar de inicialmente muito mais caras, as redes wireless estão gradualmente caindo de preço e se popularizando rapidamente. Além da questão da praticidade, em muitos casos simplesmente não é viável usar cabos. Imagine que você precise ligar dois escritórios situados em dois prédios distantes, ou que a sua mãe/esposa/marido não deixa você nem pensar em espalhar cabos pela casa.
O que você precisa prestar atenção na hora de comprar é se o modelo escolhido é bem suportado no Linux. Caso a placa tenha um driver disponível, a configuração será simples, quase como a de uma placa de rede normal, mas sem o driver você fica trancado do lado de fora do carro. Lembre-se, o driver é a chave e você nunca deve comprar um carro sem a chave :-).
Numa rede wireless, o hub é substituído pelo ponto de acesso (access-point em inglês). Ele tem basicamente a mesma função: retransmitir os pacotes de dados, de forma que todos os micros da rede os recebam. Em geral os pontos de acesso possuem uma saída para serem conectados num hub tradicional, permitindo que você "junte" os micros da rede com fios com os que estão acessando através da rede wireless, formando uma única rede.
Ao contrário dos hubs, os pontos de acesso são dispositivos inteligentes, que podem ser configurados através de uma interface de administração via web. Você se conecta num endereço específico usando o navegador (que muda de aparelho para aparelho, mas pode ser encontrado facilmente no manual), loga-se usando uma senha padrão e altera as configurações (e senhas!) de acordo com as necessidades da sua rede.
Ao contrário de uma rede cabeada, com um switch, em qualquer rede wireless a banda da rede é compartilhada entre os micros que estiverem transmitindo dados simultaneamente. Isso acontece pois não existem cabos independentes ligando o ponto de acesso a cada micro, mas um único meio de transmissão (o ar), o que faz com que a rede opere como se todos os micros estivessem ligados ao mesmo cabo. Enquanto um transmite, os outros esperam. Conforme aumenta o número de micros e aumenta o tráfego da rede, mais cai o desempenho.
Outra questão é que a potência do sinal decai conforme aumenta a distância, enquanto a qualidade decai pela combinação do aumento da distância e dos obstáculos pelo caminho. É por isso que num campo aberto o alcance será muito maior do que dentro de um prédio, por exemplo.
Conforme a potência e qualidade do sinal se degrada, o ponto de acesso pode diminuir a velocidade de transmissão a fim de melhorar a confiabilidade da transmissão. A velocidade pode cair para 5.5 megabits, 2 megabits ou chegar a apenas 1 megabit por segundo antes que o sinal se perca completamente.
Existem três padrões diferentes de rede wireless em uso. O primeiro (e mais comum) é o 802.11b, onde a rede opera a uma taxa teórica de 11 megabits.
O seguinte é o 802.11a, que ao contrário do que o nome dá a entender, é mais recente que o 802.11b. As redes 802.11a são mais rápidas (54 megabits) e são mais resistentes a interferências, pois operam na faixa de freqüência dos 5 GHz, ao invés dos 2.4 GHz usados no 802.11b. A desvantagem é que, pelo mesmo motivo (a freqüência mais alta), o alcance das redes 802.11a é menor, cerca de metade que numa rede 802.11b. As placas 802.11a são relativamente raras e, como a maioria é capaz de operar nos dois padrões, muitas delas acabam operando a 11 megabits, juntando-se a redes 802.11b já existentes.
Finalmente, temos o 802.11g, o padrão atual. Ele junta o melhor dos dois mundos, operando a 54 megabits, como no 802.11a e trabalhando na mesma faixa de freqüência do 802.11b (2.4 GHz), o que mantém o alcance inicial. Para que a rede funcione a 54 megabits, é necessário que tanto o ponto de acesso, quanto todas as placas sejam 802.11g, caso contrário a rede inteira passa a operar a 11 megabits, a fim de manter compatibilidade com as placas antigas. Muitos pontos de acesso permitem desativar este recurso, fazendo com que as placas de 11 megabits simplesmente fiquem fora da rede, sem prejudicar o desempenho das demais.
Existem ainda as placas dual band, que são capazes de transmitir simultaneamente usando dois canais diferentes, dobrando a taxa de transmissão. Uma placa de "108 megabits" é na verdade uma 802.11g dual-band.
As redes wireless também são redes Ethernet e também usam o TCP/IP. Mas, além da configuração dos endereços IP, máscara, gateway, etc., feita da mesma forma que numa rede cabeada, temos um conjunto de parâmetros adicional.
A configuração da rede wireless é feita em duas etapas. Primeiro você precisa configurar o ESSID, canal e (caso usada encriptação) a chave WEP ou WPA que dá acesso à rede.
O ESSID é uma espécie de nome de rede. Dois pontos de acesso, instalados na mesma área, mas configurados com dois ESSIDs diferentes formam duas redes separadas, permitindo que a sua rede não interfira com a do vizinho, por exemplo. Mesmo que existam várias redes na mesma sala, indicar o ESSID permite que você se conecte à rede correta.
Em seguida temos o canal que, novamente permite que vários pontos de acesso dentro da mesma área trabalhem sem interferir entre si. Temos um total de 16 canais (numerados de 1 a 16), mas a legislação de cada país permite o uso de apenas alguns deles. Nos EUA, por exemplo, é permitido usar apenas do 1 ao 11 e na França apenas do 10 ao 13. Esta configuração de país é definida na configuração do ponto de acesso.
O ESSID sozinho provê uma segurança muito fraca, pois qualquer um que soubesse o nome da rede poderia se conectar a ele ou mesmo começar a escutar todas as conexões. Embora o alcance normal de uma rede wireless, usando as antenas padrão das placas e pontos de acesso normalmente não passe de 30 ou 50 metros (em ambientes fechados) usando antenas maiores, de alto ganho e conseguindo uma rota sem obstáculos, é possível captar o sinal de muito longe, chegando a 2 ou até mesmo 5 KM, de acordo com a potência do seu ponto de acesso.
Como é praticamente impossível impedir que outras pessoas captem o sinal da sua rede, a melhor solução é encriptar as informações, de forma que ela não tenha utilidade fora o círculo autorizado a acessar a rede.
Existem atualmente três padrões de encriptação, o WEP de 64 bits, WEP de 128 bits e o WPA, o padrão mais recente e considerado mais seguro.
Embora nenhum dos três seja livre de falhas, elas são uma camada essencial de proteção, que evita que sua rede seja um alvo fácil. É como as portas de uma casa. Nenhuma porta é impossível de arrombar, mas você não gostaria de morar numa casa sem portas.
Ao usar WEP, você define numa chave de 10 (WEP de 64 bits) ou 26 (WEP de 128 bits) caracteres em hexa, onde podem ser usados números de 0 a 9 e as letras A, B, C, D, E e F. Também é possível usar caracteres ASCII (incluindo acentuação e todo tipo de caracteres especiais); neste caso as chaves terão respectivamente 5 e 13 caracteres.
A regra básica é que os micros precisam possuir a chave correta para se associarem ao ponto de acesso e acessarem a rede. Em geral os pontos de acesso permitem que você especifique várias chaves diferentes, de forma que cada micro pode usar uma diferente.
ACESSO REMOTO
Muitos dispositivos, como por exemplo modems ADSL, pequenos servidores de impressão, roteadores, etc. possuem várias opções de configuração; muitas vezes rodam o Linux ou outro sistema operacional completo, mas não possuem nem teclado nem monitor.
Nestes casos toda a configuração é feita remotamente, através de algum utilitário de configuração. O mais comum é o uso de alguma interface http, que você acessa de qualquer micro da rede local usando o navegador, ou então o uso do ssh ou telnet.
Eu, por exemplo, uso um modem ADSL Parks 600, que pode ser configurado como roteador ou bridge, através de uma interface de administração simples, que acesso via telnet, a partir de qualquer micro da rede.
O telnet é um protocolo primitivo que permite rodar comandos remotamente através de uma interface de modo texto. Existem clientes telnet para vários sistemas operacionais. Tanto no Linux quanto no Windows, você acessa uma máquina remotamente via telnet usando o comando "telnet" seguido do endereço IP destino, como em:
$ telnet 192.168.0.1
O grande problema é que o telnet não oferece nenhum tipo de segurança. Todas as informações, incluindo as senhas são transmitidas em texto puro, de forma legível pela rede e são fáceis de interceptar. É como se você fizesse suas transações bancárias gritando pela janela.
O ssh já é mais evoluído. Ele utiliza um sistema de criptografia bastante seguro para proteger os dados. Alguém pode interceptar as informações, afinal a internet é uma rede pública, mas os dados capturados não terão utilidade nenhuma. O ssh é a opção mais usada para administrar servidores remotamente.
Hoje em dia poucas empresas hospedam seus websites "in house" ou seja, em servidores instalados dentro da própria empresa. Quase sempre os servidores ficam hospedados em data centers, complexos que oferecem toda a estrutura necessária para que os servidores fiquem no ar de forma confiável, incluindo links redundantes (se o link principal cai, existe um segundo de reserva), nobreaks de grande porte, geradores, refrigeração (a temperatura ambiente mais baixa ajuda os componentes a trabalhar de forma mais estável) e assim por diante.
Isto significa que, apesar do servidor ser "seu", você não tem nenhum tipo de acesso físico a ele. Não pode usar o teclado ou mouse por exemplo, tudo precisa ser feito a distância.
No Linux, toda a configuração do sistema, instalação de novos programas, etc. pode ser feita a partir do modo texto, o que permite configurar o servidor e mantê-lo atualizado remotamente, via ssh. Outro ponto interessante é que apesar de ser nativo do Unix, existem clientes ssh também para Windows e outras plataformas, permitindo que o responsável administre o servidor a partir de uma estação Windows, por exemplo.
Outra possibilidade interessante para o ssh é suporte a distância. Você pode se conectar no micro de um amigo para corrigir algum problema, por exemplo.
Para acessar uma máquina remotamente via ssh, você deve informar o login que você usará para se conectar, seguido do IP da máquina, que pode estar tanto na rede local quanto na internet. Se o seu amigo criou o login "suporte" para que você acesse o micro dele remotamente e o IP é 200.221.34.32, o comando seria:
$ ssh suporte@200.221.34.32
O ssh pede a senha (tudo feito através da conexão segura) e depois você já vê o prompt da outra máquina:
Embora o uso mais comum seja rodar comandos de modo texto, o ssh também permite rodar aplicativos gráficos. Se você estiver se conectando a partir do Linux, geralmente não precisará fazer nada além de chamar o programa pelo nome, como em:
$ konqueror
O programa roda no servidor, mas a imagem é exibida no seu monitor:
Este recurso de rodar aplicativos gráficos remotamente é mais útil dentro de uma rede local, pois consome muita banda, deixando as respostas lentas se você acessa via modem, por exemplo.
Outro programa interessante para acessar outros micros remotamente é o VNC. Ele permite ver uma extensão do desktop da outra máquina, incluindo o KDE ou outra interface gráfica. O VNC é dividido em dois módulos, um cliente e um servidor. O servidor VNC é instalado na máquina que será acessada remotamente, enquanto as que vão acessar precisam apenas do cliente, um programa pequeno que já vem pré-instalado na maioria das distribuições. Os dois estão disponíveis tanto para Linux quanto para Windows, de forma que você pode acessar um micro com o Windows a partir do Kurumin ou vice-versa.
Finalmente, temos as interfaces de administração via web. Como disse, elas são usadas por muitos modems ADSL (são mais fáceis de usar que a interface de modo texto do meu Parks) e também por programas de configuração destinados a servidores Linux, como o Swat e o Webmin.
O Swat permite configurar o Samba, usado para compartilhar arquivos com máquinas Windows, enquanto o Webmin é uma ferramenta completa, que permite configurar vários servidores diferentes. Caso instalados no servidor, ambos podem ser acessados a partir de outro micro da rede local, ou até mesmo via internet, usando o navegador:
O KERNEL E AS DISTRIBUIÇOES
Nas reportagens sobre o Linux você lerá muito sobre Linus Torvalds, o criador do Kernel do Linux. Ele (o Kernel) é a peça fundamental do sistema, responsável por prover a infra-estrutura básica para os programas funcionarem. O Kernel é algo comum em todas as diferentes distribuições; muda a versão, mas o Kernel do Linus está sempre ali.
O Kernel é o responsável por dar suporte aos mais diferentes periféricos: placas de rede, som, e o que mais você tiver espetado no micro. Uma nova versão sempre traz suporte a muita coisa nova, o que faz diferença principalmente para quem pretende trocar de PC em breve ou está de olho em algum handheld ou mp3player exótico. É por isso que o lançamento de uma atualização importante, como o Kernel 2.6, é sempre tão comemorado.
Mas, apesar de toda a sua importância, o grande objetivo dos desenvolvedores é que o Kernel seja invisível. Ele deve simplesmente fazer seu trabalho sem que você precise se preocupar com ele. Você só se dá conta que o Kernel existe quando algo não funciona, de forma que quanto menos você notá-lo melhor, sinal de que as coisas estão funcionando bem... :-).
Uma distribuição Linux é como uma receita, ao invés de ficar compilando o Kernel e os programas como faziam os pioneiros, você simplesmente instala um conjunto que uma equipe desenvolveu e disponibilizou. O bom dos softwares é que uma vez criados eles podem ser distribuídos quase sem custo. Ao contrário de um objeto material, que se quebra ao ser dividido, quanto mais pessoas copiarem e usarem sua distribuição melhor: seu trabalho terá mais reconhecimento e apoio.
Alguns exemplos de distribuições são o Debian, Mandriva, Fedora, SuSE, Slackware e Gentoo.
Qualquer pessoa ou empresa com tempo e conhecimentos suficientes pode desenvolver uma distribuição. O mais comum é usar uma distribuição já existente como ponto de partida e ir incluindo novos recursos a partir daí. No mundo open-source não é preciso reinventar a roda, os trabalhos anteriores são respeitados e reutilizados, aumentando radicalmente a velocidade de desenvolvimento de novos projetos.
A distribuição mais antiga, ainda ativa é o Slackware, que em julho de 2006 completou 13 anos. O Slackware é uma das distribuições mais espartanas, que tem como objetivo preservar a tradição dos sistemas Unix, provendo um sistema estável, organizado, mas com poucas ferramentas automatizadas, que te obriga a estudar e ir mais a fundo na estrutura do sistema para conseguir usar. Muita gente usa o Slackware como ferramenta de aprendizado, encarando os problemas e deficiências como um estímulo para aprender.
Pouco depois, em novembro de 1994, foi lançado o Red Hat, que foi desenvolvido com o objetivo de facilitar a configuração e automatização do sistema, incluindo várias ferramentas de configuração. Apesar de sua alma comercial, todas as ferramentas desenvolvidas pela equipe do Red Hat tinham seu código aberto, o que possibilitou o surgimento de muitas outras distribuições derivadas dele, incluindo o Mandrake (França) e o Conectiva (Brasil). Devido à sua origem comum, estas distribuições preservam muitas semelhanças até hoje, sobretudo na estrutura do sistema e localização dos arquivos de configuração.
A partir de 2003, a Red Hat mudou seu foco, concentrando seus esforços no público empresarial, desenvolvendo o Red Hat Enterprise e vendendo pacotes com o sistema, suporte e atualizações.
O Red Hat Desktop foi descontinuado em 2004, pouco depois do lançamento o Red Hat 9. A partir daí, passou a ser desenvolvido o Fedora combinando os esforços de parte da equipe da Red Hat e vários voluntários que, com a maior abertura, passaram a contribuir com melhorias, documentações e suporte comunitário nos fóruns. O Fedora herdou a maior parte dos usuários do Red Hat Desktop e é atualmente uma das distribuições mais usadas.
O Mandrake começou de uma forma modesta, como uma versão modificada do Red Hat, lançada em julho de 1998, cuja principal modificação foi a inclusão do KDE (ainda na versão 1.0). O Mandrake conquistou rapidamente um número relativamente grande de usuários e passou a ser desenvolvido de forma independente, com foco na facilidade de uso. Em 2005 aconteceu a fusão entre o Mandrake e o Conectiva, que deu origem ao atual Mandriva, que passou a ser desenvolvido combinando os esforços dos desenvolvedores das duas distribuições.
A história do SuSE é um pouco mais complicada. As primeiras versões foram baseadas no SLS, uma das primeiras distribuições Linux que se têm notícia. Em 1995 os scripts e ferramentas foram migrados para o Jurix, que por sua vez era baseado no Slackware. A partir a versão 5.0, lançada em 1998, o SuSE passou a utilizar pacotes RPM, o formato do Red Hat e passou a incorporar características e ferramentas derivadas dele. Todas estas ferramentas foram integradas no Yast, um painel de controle central que facilita bastante a administração do sistema.
Devido a todas estas mudanças, o SuSE é difícil de catalogar, mas atualmente o sistema possui muito mais semelhanças com o Fedora e o Mandriva do que com o Slackware, por isso é mais acertado colocá-lo dentro da família Red Hat.
Em 2003, a SuSE foi adquirida pela Novell, dando origem ao Novell Desktop (uma solução comercial) e ao OpenSuSE, um projeto comunitário, que usa uma estrutura organizacional inspirada no exemplo do Fedora.
Finalmente, temos o Debian, cuja primeira versão oficial (chamada Buzz) foi lançada em 1996. O Debian deu origem a uma grande linhagem de distribuições, que incluem de produtos comerciais, como o Linspire e o Xandros a projetos comunitários, como o Ubuntu, Knoppix, Mephis e o próprio Kurumin.
As principais características do Debian são a grande quantidade de pacotes disponíveis (atualmente, quase 25 mil, se incluídas as fontes não oficiais) e o apt-get, um gerenciador de pacotes que permite baixar, instalar, atualizar e remover os pacotes de forma automática.
O Debian utiliza um sistema de desenvolvimento contínuo, onde são desenvolvidas simultaneamente 3 versões, chamadas de Stable (estável), Testing (teste) e Unstable (instável). A versão estável é o release oficial, que tem suporte e atualizações de segurança freqüentes. A versão estável atual é o Sarge (3.1), lançado em junho de 2005; antes dele veio o Woody (3.0), lançado em julho de 2002 e o Potato (2.2), lançado em agosto de 2000. O lançamento da próxima versão estável (batizada de Etch), está planejada para o final de 2006.
Apesar do longo intervalo entre os lançamentos das versões estáveis, os pacotes ficam congelados, recebendo apenas correções de segurança. Isso faz com que os pacotes do Stable fiquem rapidamente defasados em relação a outras distribuições. Para solucionar este problema, existe a opção de usar o Testing, composto de pacotes recentes porém menos testados e, como última opção, existe o Unstable, que é a porta de entrada para as últimas versões e por isso sujeito a mais problemas. Em algumas épocas, o uso do Unstable é impraticável, pois muitas alterações são feitas simultaneamente, fazendo com que muitos pacotes fiquem quebrados e apareçam problemas diversos.
Tipicamente, os pacotes começam no Unstable, onde recebem uma primeira rodada de testes. Depois de algumas semanas, são movidos para o Testing. Periodicamente, os pacotes no Testing são congelados, dando origem a uma nova versão estável. Além destes, existe o Experimental, usado como um laboratório para a inclusão de novos pacotes.
O Debian em si é bastante espartano em termos de ferramentas de configuração e por isso reservado a usuários mais avançados. Porém, muitas distribuições derivadas dele, como Ubuntu, o Mepis e o Kurumin, são desenvolvidas com foco na facilidade de uso e incluem muitas ferramentas e assistentes de configuração.
Você pode ver uma tabela mais completa com as origens de cada distribuição neste link do Distrowatch:
http://distrowatch.com/dwres.php?resource=independence
Veja que dentre as distribuições cadastradas no site, a grande maioria é baseada no Debian (129) ou no Knoppix (50). Naturalmente, as distribuições baseadas no Knoppix também são indiretamente derivadas do Debian e, de fato, muitas distribuições são incluídas dentro das duas categorias.
Em seguida temos as distribuições derivadas do Fedora (63), do Slackware (28) e do Mandriva (14). Até o Kurumin já entrou na lista, com 5 filhos.


OS LIVE-CDS


Tradicionalmente, qualquer sistema operacional precisa ser instalado no HD antes de ser usado. Você dá boot usando o CD ou DVD de instalação e é aberto um sistema compacto, que roda o instalador e se encarrega de instalar e configurar o sistema principal. Depois de algum tempo respondendo perguntas e vendo a barra de progresso da cópia dos arquivos, você reinicia o micro e pode finalmente começar a usar o sistema. Isso é válido tanto para o Windows quanto para a maior parte das distribuições Linux.
Os live-CDs são distribuições Linux que rodam diretamente a partir do CD-ROM, sem necessidade de instalar. Um dos pioneiros nesta área é o Knoppix (derivado do Debian), que até hoje é um dos live-CDs de maior sucesso. O Kurumin é um descendente direto dele, desenvolvido com base no Knoppix 3.1 (a versão mais recente no início de 2003) e desenvolvido de forma mais ou menos autônoma a partir daí, utilizando como base os pacotes do Debian, combinados com atualizações provenientes do Knoppix e várias outras distribuições, além de um conjunto de scripts e ferramentas de configuração próprias, centralizadas na forma do Clica-aki.
Para quem já se acostumou com a idéia, pode parecer natural rodar o sistema a partir do CD e até mesmo instalar novos programas, sem precisar modificar as informações salvas no HD, mas o aparecimento do Knoppix foi um verdadeiro marco dentro do mundo Linux.
A base de tudo é um módulo de Kernel chamado cloop, um hack que permite que o sistema rode a partir de um sistema de arquivos compactado, gravado no CD-ROM. Os dados são descompactados "on-the-fly", conforme são necessários. É algo que funciona de forma similar às partições compactadas pelo smartdrive no Windows 95/98 (ainda lembrado pelos saudosistas :), mas com um desempenho melhor e otimizado para CD-ROMs.
Graças à compressão, uma distribuição como o Kurumin pode incluir cerca de 1.2 GB de programas, em uma imagem com pouco mais de 400 MB. Além de reduzir o tamanho do sistema, comprimir os arquivos melhora também a taxa de transferência do CD-ROM, diminuindo a perda de desempenho causado pela baixa taxa de leitura.
A idéia é que um CD-ROM de 40X é capaz de ler a em média 4 MB/s, pois como o CD gira sempre na mesma velocidade, as informações gravadas nas trilhas da parte externa do CD (mais longas), são lidas a mais ou menos o dobro da velocidade das do centro (que são mais curtas). Um CD-ROM de 40x lê a 6 MB/s nas trilhas externas mas a apenas 3 MB/s nas internas. Como o CD-ROM é gravado a partir do centro, na maior parte do tempo ele lê os dados a 3, 4 ou 5 MB/s.
Mas, ao ler 4 MB/s de dados compactados a uma razão de 3x, ele estará lendo na prática a quase 12 MB/s, quase a mesma taxa de transferência de um HD de meia década atrás. Naturalmente ainda existem outros problemas, como o tempo de busca, que é muito mais alto num CD-ROM, mas o problema principal é bastante amenizado.
Se não fosse o sistema de compressão, os live-CDs descendentes do Knoppix seriam três vezes maiores e três vezes mais lentos ao rodar do CD, o que os tornariam sistemas muito menos atrativos.
Em contrapartida, o trabalho do processador passa a ser maior, pois, além de processar os dados referentes aos programas, ele tem que ao mesmo tempo descompactar os dados lidos pelo CD-ROM. Por isso, mais do que em outras distribuições, o desempenho (ao rodar do CD) aumenta de acordo com o poder de processamento da máquina. Numa máquina lenta, um Pentium II 300, por exemplo, o desempenho é cerca de 50% menor do que seria ao rodar uma distribuição instalada no HD, enquanto num Athlon XP ou Pentium 4 a diferença já é muito menor.
A primeira etapa do boot é a tela de boas-vindas e uma linha onde você pode fornecer parâmetros para o boot. Logo depois é carregado o Kernel, que por sua vez inicializa o hardware, cria um ramdisk usando uma parte (pequena) da memória RAM onde são armazenados arquivos de configuração e outros dados que precisam ser alterados durante o uso. Depois disso entra em ação o hwsetup, o programa de detecção que se encarrega de detectar a placa de vídeo, som, rede, modem e outros periféricos suportados, desenvolvido por Klaus Knopper com base no Kudzu do Red Hat.
Este trabalho de detecção é justamente o grande trunfo. Em poucos segundos o sistema é capaz de detectar, configurar e ativar todos os periféricos suportados na máquina, baseado nos códigos de identificação dos dispositivos, sem nenhuma intervenção do usuário.
Claro, sempre existem casos de problemas. Algumas placas-mãe travam durante a detecção do ACPI, alguns notebooks travam durante a etapa inicial, onde o sistema procura por placas SCSI e assim por diante. Mas na grande maioria dos casos estes problemas podem ser resolvidos desativando as partes da detecção que causam problemas, usando opções de boot. Veremos mais detalhes sobre isso no capítulo 3.
Durante o boot ele tenta sempre configurar automaticamente a rede, obtendo o IP e outros dados a partir de um servidor DHCP disponível na rede. Se a máquina acessar a internet através de uma conexão compartilhada dentro da rede local ou através de um modem ADSL configurado como roteador, ele já será capaz de acessar a web logo após o boot, caso contrário você pode configurar a rede manualmente.
Uma questão importante ao usar qualquer live-CD é a questão da memória RAM. Como o sistema por padrão não utiliza as partições do HD, tudo é feito usando a memória RAM, incluindo a instalação de novos programas. O ramdisk que é criado durante o boot vai crescendo conforme são feitas modificações. Em micros com pouca RAM você verá uma mensagem de "disco cheio" (quando na verdade o que acabou foi o espaço no ramdisk), ou até mesmo efeitos diversos por falta de memória RAM disponível.
A instalação de novos programas é possibilitada pelo UnionFS, mais um hack que monitora tentativas de alterações nos arquivos do CD (originalmente impossíveis, já que o CD é somente-leitura) e engana os programas, fazendo-as no ramdisk, permitindo que você altere arquivos e instale novos programas, mesmo ao rodar o sistema a partir do CD. Este recurso está disponível a partir do Knoppix 3.8 e do Kurumin 5.0.
A configuração mínima para rodar o Kurumin é um Pentium II com 128 MB de RAM. Para o Knoppix ou outras distribuições, os requisitos variam de 128 a 256 MB. Para usar o apt-get e instalar novos programas (UnionFS), você precisa ter 512 MB de RAM.
Para poder abrir vários programas simultaneamente e para melhorar o desempenho geral do sistema, é recomendável ter disponível uma partição swap, que pode ser criada usando o gparted, cfdisk, ou outro programa de particionamento. Muitas distribuições criam uma partição swap automaticamente ao serem instaladas.
A memória swap (ou memória virtual) é um recurso usado por todos os sistemas operacionais atuais quando não existe memória RAM suficiente. Ele passa a armazenar os dados que não "cabem" na memória num arquivo ou partição swap criada no HD. É o uso da memória swap que permite que o sistema continue funcionando, mesmo quando não existe memória RAM suficiente.
Como não é possível fazer memória swap no CD-ROM, o sistema é capaz de detectar e montar automaticamente partições de memória swap de outras distribuições Linux. Caso você tenha apenas o Windows instalado, ele tentará em último caso criar um arquivo de swap dentro da partição do Windows, mas isto só é possível se o HD estiver formatado em FAT32 (o sistema de arquivos usado pelo Windows 98). Por enquanto ainda não é possível fazer isso em partições NTFS do Windows XP.
Ou seja, para rodar o Kurumin em micros com pouca memória RAM, você deve preferencialmente usar um programa de particionamento qualquer para criar uma partição Linux swap ou pelo menos certificar-se de que o HD está formatado em FAT32 e não em NTFS, caso contrário ele não terá para onde correr quando a memória RAM acabar ;-).
Além do Knoppix e do Kurumin, existem muitos outros live-CDs, tanto baseados no Debian quanto baseados em outras distribuições, como o Slax (baseado no Slackware) e o PcLinuxOS (baseado no Mandriva).
COMO BAIXAR GRAVAR E DAR BOOT
A forma mais popular de disponibilizar novas versões das distribuições é através de arquivos ISO, cópias binárias do conteúdo dos CDs ou DVD de instalação, que você pode gravar usando o Nero, K3B ou outro programa de gravação, obtendo um CD idêntico ao original.
Gravar um arquivo ISO é diferente de gravar um arquivo qualquer no CD. Um arquivo ISO é uma imagem binária que deve ser copiada bit a bit no CD-ROM, e não simplesmente adicionado dentro de uma nova seção. Todos os bons programas de gravação suportam a gravação de arquivos ISO, veja como gravar o arquivo usando alguns programas populares.
Ao usar o Easy CD Creator, abra o Easy CD Creator e clique em "File > Menu > Record CD from CD Image". Aponte o arquivo que será gravado. Marque a opção "ISO Image Files (*.iso)" na janela de navegação e clique em "Start Recording" para gravar o CD.
No Nero Burning Rom, clique em File > Burn Image, aponte o arquivo que será gravado e clique em "Write" para gravar o CD.
Ao usar o K3B (no Linux), clique em Ferramentas > Gravar Imagem ISO (ou Queimar imagem de CD), aponte o arquivo, escolha a velocidade de gravação e clique em "Gravar".
Depois de gravado o CD, o próximo passo é configurar o setup da placa-mãe para dar boot através do CD-ROM. A maioria dos micros vem configurados para dar boot preferencialmente através do CD-ROM. Neste caso basta deixar o CD na bandeja e você já cai na tela de boas vindas do sistema. Se não for o seu caso, pressione a tecla DEL durante o teste de memória para entrar no Setup.
Procure pela seção "Boot" e coloque o CD-ROM como dispositivo primário. Tudo pronto, agora é só salvar a configuração acessando o menu exit, escolhendo a opção "Save & Exit setup".
Ao reiniciar o micro sem o CD no drive, ele volta a carregar o Windows ou outro sistema que estiver instalado no HD. Esta alteração apenas faz com que ele passe a procurar primeiro no CD-ROM.
Um hábito saudável é verificar a integridade do arquivo .ISO antes de gravar o CD. Sempre é possível que o arquivo esteja incompleto, ou venha corrompido, seja por problemas com a conexão ou no gerenciador de download usado. Você pode detectar este tipo de problema (e evitar gastar mídias à toa), verificando o MD5SUM do arquivo, um teste que soma todos os bits do arquivo e devolve uma "assinatura", um código de 32 dígitos que permite detectar qualquer mudança no arquivo.
Os códigos de assinatura dos arquivos estão quase sempre disponíveis na página de download, como em:
11479ced7eea505506b5a3314d33ee70 kurumin-5.0.iso
Você precisa apenas rodar o MD5SUM no arquivo baixado e ver se o resultado é igual ao número da página. No Linux (qualquer distribuição), acesse a pasta onde o arquivo foi baixado e digite:
$ md5sum kurumin-5.0.iso
Se o número retornado for igual, você pode gravar a imagem sem medo, o arquivo está ok. Caso o número seja diferente, então o arquivo chegou corrompido ou incompleto. Uma dica nesta caso é que é possível corrigir arquivos corrompidos usando o bittorrent (se o arquivo estiver disponível para download através dele). Para isso, baixe o arquivo .torrent para a mesma pasta do arquivo corrompido e inicie o download. O bittorrent usa um algoritmo próprio para verificar cada pedaço do arquivo, descartando os pedaços corrompidos. Isso permite que ele baixe novamente apenas os pedaços corrompidos, sem precisar baixar novamente todo o arquivo.
No Windows baixe o programa disponível no http://www.md5summer.org/download.html. Ele é gráfico, até mais fácil de usar que a versão Linux.
Uma última dica é com relação aos famosos "Cloop Errors", erros de leitura que aparecem ao tentar rodar qualquer live-CD (que usa o módulo cloop para compactar os dados) a partir de uma mídia ruim. O cloop possui um sistema próprio para verificar as integridade dos dados no CD, detectando e avisando sobre os erros de leitura.
Nestes casos você verá vários "CLOOP READ erros" durante o boot, que indicam justamente que o sistema não está conseguindo ler os dados corretamente. Veja um exemplo:
CLOOP READ ERROR:AT POS 5233960 IN FILE/CDROM/KNOPPIX/KNOPPIX
CLOOP:ERROR-3 UNCOMPRESSING BLOCK 46065536/0/23207/05233960-
I/O ERROR DEV OB:00, SECTOR 17212 LINUXRC CANNOT CREAT/VAN/RUN/VTMP.DIRECTORY NOEXISTENT
Os cloop erros podem ser causados por três fatores:
a) O arquivo baixado está incompleto ou corrompido.
b) O CD ou CD-RW está riscado/danificado e o sistema não está conseguindo ler os dados corretamente (o mais comum). Os CD-RW dão esse tipo de problema mais freqüentemente, pois o índice de refração luminosa da mídia é mais baixa e a superfície de gravação mais frágil, facilitando o aparecimento de problemas de leitura.
c) O próprio leitor CD-ROM ou o cabo IDE podem estar com problemas e por isso os dados não estão sendo lidos corretamente, embora a mídia esteja em bom estado.
Os CLOOP ERRORS são sempre causados direta ou indiretamente por um destes três fatores; problemas com o CD ou com o hardware do seu micro e não por problemas do software. O sistema pode apresentar outros tipos de problemas na sua máquina, como travar durante a detecção de algum componente, mas este erro específico é justamente um aviso de problemas com a leitura dos dados.
Em muitos casos, o sistema roda normalmente a partir do CD, mas apresenta problemas estranhos ao ser instalado (o modo gráfico não abre, alguns aplicativos não funcionam, mensagens de erro diversas reclamando da falta de aplicativos ou bibliotecas, etc.), causados por problemas de leitura durante a instalação.
Prefira usar mídias CDR normais e depois doar suas cópias antigas para amigos que ainda não conheçam o sistema, assim você estará evitando dor de cabeça e ainda fazendo uma boa ação :).
LINGUAGENS DE PROGRAMAÇAO
Os computadores são funcionários quase perfeitos. Fazem tudo o que mandamos, não reclamam, não se importam de trabalhar até tarde da noite, não cobram hora extra nem tiram férias. Mas, em compensação, também não pensam. Para que façam qualquer coisa é preciso explicar tudo com os mínimos detalhes e na língua deles.
Considerando que tudo o que os computadores conseguem entender são seqüências intermináveis de números binários, fornecer estas "instruções" pode ser muito penoso para um ser humano. Você consegue se imaginar lendo um manual de 5.000 páginas e decorando um a um centenas de códigos binários que representam as instruções do processador?
Se os programadores precisassem programar diretamente em binários, decorando seqüências como 10111011101101101110110011001010 para cada instrução do processador e para cada endereço de memória a ser acessado, provavelmente não teríamos mais programadores; já estariam todos loucos.
Para facilitar as coisas, começaram a ser desenvolvidas as linguagens de programação, que diferem na sintaxe e recursos, mas têm um ponto em comum, que é a existência de um compilador. Seja programando em C, ou seja em Kylix, você usará um editor para escrever seu programa, respeitando as regras da linguagem escolhida e em seguida rodará o compilador, que interpretará os comandos que formam o seu programa e os transformará em um arquivo binário, que contém as instruções binárias que são entendidas pelo processador.
No Windows não temos muito contato com código fonte, pois os programas são quase sempre distribuídos apenas em formato binário, que você não tem como alterar. Mas, no caso do Linux, temos a possibilidade de baixar o código fonte de praticamente todos os programas que usamos no dia-a-dia. Muita gente aprende a programar fuçando no código fonte de algum programa que conhece bem, começando com pequenas traduções e mudanças, e acaba entendendo bem a sintaxe da linguagem e vários dos truques usados. Depois de cada rodada de alterações, é possível compilar todo o código, abrir o programa e verificar de que forma elas alteraram o programa final.
A vantagem de usar linguagens de programação é que o desenvolvedor passa a trabalhar com instruções como "if", "else", etc. além de todas as facilidades oferecidas pela linguagem ao invés de gigantescos endereços binários. Sem dúvida muito mais simples.
Existem diversas linguagens de programação. Meu objetivo aqui é dar algumas noções básicas sobre as peculiaridades e utilidade de algumas delas
Para começar, existe uma linguagem "básica" para quem quer aprender a programar, ensinada nos cursos de lógica da programação, o pseudocódigo. Ele não é uma linguagem "de verdade", mas sim uma maneira mais simples para aprender os fundamentos usados em todas as linguagens de programação.
Podemos começar com um exemplo simples. Vamos fazer um programa capaz de tomar uma decisão fácil. Ele pergunta a nota do aluno e diz se ele passou ou não. Para um ser humano isso seria um problema muito elementar, mas para o computador as coisas não são assim tão simples. Lembre-se de que ele é burro e precisa ser orientado passo a passo. Nosso programinha em pseudocódigo poderia ficar assim:
escreva: "Qual é a nota do aluno?"
leia nota
se nota maior ou igual a sete
então:
escreva "Ele passou"
senão:
escreva: "Ele foi reprovado"
fim do se
fim do programa
Este programinha perguntaria a nota e, com base no número que for digitado, avisaria se o aluno passou ou não.
Ele poderia ser escrito em qualquer linguagem, mas a lógica seria a mesma. De acordo com os recursos oferecidos pela linguagem escolhida, ele poderia ter uma interface simples em modo texto, uma interface gráfica mais trabalhada, aparecer no meio de uma pagina web e assim por diante. O mesmo programinha escrito em shell script, a linguagem mais elementar que temos no Linux, onde utilizamos comandos de terminal, poderia ficar assim:
echo "Qual é a nota do aluno"
read nota
if [ "$nota" -ge "7" ]
then
echo "Ele passou"
else
echo "Ele foi reprovado"
fi
As linguagens de programação são conjuntos de padrões e comandos que você pode usar para dar ordens para nossos amigos burros.
Assim como nas línguas faladas, existem diferenças de sintaxe, gramática e existem linguagens mais simples ou mais complicadas de aprender e linguagens mais adequadas para cada tipo de tarefa a realizar. Veja alguns exemplos de linguagens de programação:

- Assembly
: O Assembly foi provavelmente a primeira linguagem de programação da história, surgida na década de 50, época em que os computadores ainda usavam válvulas. A idéia do Assembly é usar um comando em substituição a cada instrução de máquina.
No Assembly, cada uma destas instruções equivale a uma instrução do processador. Ao invés de usar instruções como 10101011, você pode usar outras bem mais fáceis de entender e de memorizar, como add, div, mul, and, or, not, etc. Você também pode criar variáveis, que são pequenos espaços na memória RAM reservados para guardar algum tipo de informação, que o programa precisará mais tarde. Você pode usar aquelas instruções que citei para lidar com elas. Por exemplo, a instrução "add" faz com que o processador some duas variáveis; "add x, y" por exemplo, soma os valores de x e y.
Apesar de ser exaustivamente trabalhoso, você pode perfeitamente desenvolver pequenos programas em Assembly. Para isso só vai precisar de um compilador e bastante paciência para aprender. Um bom ponto de partida é baixar o MenuetOS, um sistema operacional aberto, inteiramente escrito em Assembly, que inclui todas as ferramentas e compiladores necessários para começar a programar. Na página você encontra também alguns tutoriais e exemplos:
http://www.menuetos.net/
O compilador transforma o código escrito em Assembly em linguagem de máquina, que finalmente poderá ser entendida pelo processador.
Existem também os decompiladores, que fazem o trabalho inverso, de transformar um programa já compilado em código Assembly. Este recurso é chamado de engenharia reversa. É assim que conseguem crackear programas, quebrar códigos de proteção (como o do DVD), etc. Claro que para isso, é preciso alguém que conheça muito de Assembly e que tenha disposição para ficar estudando o código até encontrar o que procura.
Por causa desta característica de permitir trabalhar diretamente com as instruções do processador, o Assembly é uma linguagem de baixo nível. Existem também linguagens de alto nível, como C++ ou Pascal, onde é possível usar várias funções já prontas ou mesmo ferramentas visuais, como o Kdeveloper ou o Kylix, que são ainda mais fáceis.
Em se tratando de programação, o fato de uma linguagem ser "de baixo nível", não significa que ela é ruim, mas apenas que ela manipula diretamente as instruções e endereços de memória e, por isso, é mais trabalhosa e voltada para o desenvolvimento de aplicativos otimizados.

- Fortran
: O Fortran foi uma das primeiras linguagens de alto nível da história. Enquanto o Assembly é chamado de linguagem de baixo nível, por nele utilizarmos diretamente as instruções e endereços do processador e memória, numa linguagem de alto nível temos várias funções prontas, o que facilita muito a programação, mas em compensação torna em muitos casos o programa maior e mais pesado, já que o compilador jamais conseguirá gerar um código tão otimizado quanto um programador experiente conseguiria.
Fortran é a contração de "Formula Translator". A primeira versão do Fortran foi criada no final da década de 50, mas a linguagem começou a ser usada em larga escala a partir da metade da década de 60, quando surgiram várias versões diferentes. Atualmente o Fortran é ainda usado em diversos aplicativos relacionados a engenharia. Ele é também ensinado em várias universidades, como uma forma mais prática de ensinar lógica da programação.

- Pascal
: O Pascal é outra linguagem de alto nível, criada durante a década de 60. O Pascal é uma linguagem bastante estruturada, com regras bastante rígidas, o que a torna difícil de usar. Hoje em dia o Pascal original é pouco usado, mas seus descendentes diretos como o Free Pascal evoluíram muito. O próprio Kylix (junto com o Delphi) é uma evolução do Pascal.

- Cobol
: Cobol significa "Common Business Oriented Language". Esta linguagem foi desenvolvida no final da década de 50, com o objetivo de ser uma plataforma de desenvolvimento para aplicações bancárias e financeiras em geral. Comparado com o Pascal e o Assembly, comuns na época, o Cobol é uma linguagem relativamente amigável, o que garantiu uma grande aceitação. Até hoje esta linguagem é usada em muitos sistemas bancários, o que explica a grande procura por programadores experientes nesta linguagem na época do bug do ano 2000.

- C
: O C foi desenvolvido durante a década de 70, mas ainda é largamente utilizado. A grande vantagem do C é permitir escrever tanto programas extremamente otimizados para a máquina, como seria possível apenas em Assembly, e ao mesmo tempo vir com várias funções prontas, como uma linguagem de alto nível, que podem ser utilizadas quando não for necessário gerar um código tão otimizado.
A maior parte dos programas Linux e quase todo o Kernel foram escritos em C, o que explica o porquê do sistema ser tão rápido em algumas tarefas.

- C++
: O C++ mantém os recursos do C original, mas traz muitos recursos novos, como recursos orientados a objetos, sendo também bem mais fácil de utilizar. O C++ é bastante usado atualmente para desenvolver muitos programas para várias plataformas. Ele é, por exemplo, a linguagem oficial do KDE e da maioria dos programas para ele.

- Python
: O Python é uma linguagem de programação com uma sintaxe muito simples e intuitiva e ao mesmo tempo bastante poderosa, que pode ser usada por toda classe de usuários. É uma boa opção de linguagem para quem está começando a programar. No Kurumin, você pode abrir o interpretador do Python em Iniciar > Sistema > Desenvolvimento.
A maior parte das distribuições instalam o Python por default. Basta abrir um terminal e chamar o comando "python". Existe também uma versão for Windows que pode ser baixada no: http://www.python.org/download/. Ao abrir um programa, você verá um prompt como este:
Este é o interpretador do Python, um prompt onde você pode digitar um comando de cada vez e já ir vendo os resultados. Bom para ir testando os comandos enquanto você não quiser realmente desenvolver nenhum programa completo.
Vamos começar com uma coisa simples. Que tal ouvir um bom dia? Para isso podemos usar o "print" que é o comando para escrever coisas na tela. Este comando é simples de usar, basta escrever a frase entre aspas: print "Bom Dia!".
E você terá um:
Podemos personalizar um pouco isto, fazendo com que ele primeiro pergunte o seu nome e depois dê bom dia. Para isso, podemos usar o comando "raw_input", que lê texto digitado no teclado. Este texto precisa ser guardado em algum lugar, para armazená-lo usamos uma variável, que é um pequeno espaço de memória reservado e que pode ser usado mais tarde.
Experimente usar a linha abaixo:
nome = raw_input("Olá, qual é o seu nome? ")
Isso faz com que ele pergunte o seu nome e fique esperando você digitar alguma coisa e dar Enter. Em seguida ele armazena o texto digitado na variável "nome" e volta para o prompt. O texto entre aspas pode ser substituído por outra coisa se quiser.
Como disse, a variável armazena dados que podem ser usados mais tarde. Como agora já temos o seu nome armazenado na variável "nome", podemos completar nosso bom dia, fazendo com que ele escreva junto o seu nome (ou o que for que você tenha digitado no passo anterior :-):
print "Bom dia", nome
Ele escreve a frase "Bom Dia" que está entre aspas e em seguida completa com o texto armazenado na variável "nome". Não se esqueça da vírgula, ela indica que além de escrever o texto armazenado na variável, o interpretador deve adicionar a palavra "nome" em seguida.
Experimente agora abrir o kedit (ou outro editor de textos qualquer) e salvar nosso pequeno programa num arquivo de texto. Ele pode se chamar, por exemplo, "programa.py" (.py de python). Eu enfeitei um pouco mais o meu. Os "\n" no meio do texto são quebras de linha:
Este arquivo pode ser executado usando o interpretador do Python. Para isso, abra um terminal e chame o comando:
$ python programa.py
O programa vai fazer o mesmo que no prompt do Python, a diferença é que agora ele executa os comandos escritos no arquivo de texto ao invés de ir perguntando.
Podemos agora fazer algo usando uma instrução de tomada de decisão. Que tal perguntar a idade e com base nela decidir qual será a próxima frase do diálogo? Se o interlocutor responder que menos de 18 anos, ele pode receber um "Beleza, tem aula hoje?" e se tiver 18 ou mais recebe um "Ei, você não vai trabalhar hoje?".
Para isso precisamos começar perguntando a idade. De volta ao nosso editor de textos acrescentamos ao que já tínhamos feito:
idade = input("Quantos anos você tem? ")
Veja que mudamos o "raw_input" para apenas "input". A diferença entre os dois é que o raw_input pode ser qualquer tipo de dados (letras, números, binários), enquanto o "input" serve para armazenar números.
Agora chegamos à parte mais importante, que é fazer o programa descobrir se o número digitado é maior ou menor que 18 e depois decidir qual frase deve escrever. Para isso, vamos usar a instrução "if" (se) que tem sua companheira inseparável, a "elif" (então se). Funciona assim:
if idade < 18:
print "Beleza, tem aula hoje?"
elif idade >= 18:
print "Ei, você não vai trabalhar hoje?"
Parece complicado à primeira vista, mas não é. O primeiro if verifica se o número é menor (<) que 18. Caso seja, ele escreve o "Beleza, tem aula hoje?" e o programa acaba.
Caso o número seja maior que 18, então o primeiro if não faz nada e ele passa para o elif que vai verificar se o número é maior ou igual (>=) a 18. Caso seja, ele imprime a frase "Ei, você não vai trabalhar hoje?". Veja que eu aproveitei pra colocar mais quebras de linha, que servem para deixar a saída de texto do programa mais legível.
Como vimos, o Python pode trabalhar com expressões aritméticas, usando números e os operadores:
+ (mais)
- (menos)
* (multiplicação)
/ (divisão)
== (igual a)
!= (diferente de)
> (maior que)
> = (maior ou igual a)
< (menor que)
< = (menor ou igual a)
** (exponenciação, elevado à)
Podemos usá-los para resolver aquele problema clássico de tirar a média das notas do aluno e dizer se ele passou de ano. Digamos que sejam 4 provas e a média para passar seja 7. Precisaríamos perguntar as notas das quatro provas, tirar a média e depois usar o if e o elif para descobrir se a média é maior ou menor que 7.
O programa poderia ficar assim:
aluno = raw_input("\n Qual o nome do aluno? ")
prova1 = input("\n Nota da primeira prova: ")
prova2 = input("\n Nota da segunda prova: ")
prova3 = input("\n Nota da terceira prova: ")
prova4 = input("\n Nota da quarta prova: ")
media = (prova1 + prova2 + prova3 + prova4) / 4
if media < 7:
print "\n Média", media,". Que vergonha", aluno,". Levou bomba!"
elif media >=7:
print "\n Média", media,".", aluno, "passou. Parabéns!"
Imagine agora que você não queria saber apenas a média de um aluno, mas da sala inteira. Você precisaria que o programa ficasse perguntando as notas de todos os alunos, um por vez e depois desse a média geral.
Para isso precisamos usar a instrução "while" (enquanto), que repete uma seqüência de instruções até que uma condição seja atingida. Podemos começar o programa perguntando o número de alunos na sala e criar uma variável "contagem" com o valor zero. Cada vez que são dadas as notas de um aluno, a variável "contagem" aumenta em 1. Quando ela chegar ao número de alunos da sala, sabemos que todos foram contados. O programa ficaria assim:
alunos = input("\n Quantos alunos esta sala tem?")
contagem = 0
total = 0
while contagem < alunos:
contagem = contagem + 1
print "\n Notas do aluno ", contagem
prova1 = input(" Nota da primeira prova: ")
prova2 = input(" Nota da segunda prova: ")
prova3 = input(" Nota da terceira prova: ")
prova4 = input(" Nota da quarta prova: ")
total = total + prova1 + prova2 + prova3 + prova4
media = total / alunos / 4
print "\n\n A média geral da sala é", media, "\n\n"
Este já ficou um pouco mais complexo que o anterior. Temos três novas variáveis. A variável "alunos" armazena o número de alunos da sala. A variável "contagem" começa com zero mais vai aumentando em 1 a cada vez que o programa roda. O while vai perguntando as notas e vai somando tudo na variável total. Quando finalmente o número de alunos é atingido, vamos para a parte final do programa, onde a média é calculada e escrita na tela.
Ao ser executado, o programa primeiro pergunta o número de alunos da sala e depois vai perguntando as notas de cada prova até chegar ao resultado.
O Python reconhece a parte do texto que pertence ao while pela indentação do texto. Quando acaba a indentação, acaba o while. Para indentar uma linha, basta pressionar espaço quatro vezes. Alguns editores, como o Kwrite e o Kate, possuem botões para indentar blocos de texto, o que facilita seu trabalho neste caso.

- Java
: O Java é uma linguagem de programação multiplataforma, com uma sintaxe até certo ponto parecida com o C++, porém com bibliotecas diferentes. Os programas em Java podem ser executados em qualquer sistema operacional, desde que o interpretador esteja instalado.
A JVM é um programa que converte o código Java em comandos que o sistema operacional possa executar. Existem máquinas virtuais para vários sistemas operacionais: o problema é que, devido ao processamento executado pela máquina virtual, o programa torna-se mais pesado do que seria caso escrito diretamente para a plataforma.
Um exemplo de programa desenvolvido desta forma é o Mercury (um cliente MSN com versões para Linux e Windows, um dos primeiros a oferecer suporte a webcam e por isso bastante famoso). Embora o código fonte do programa seja relativamente simples e bem escrito, ele é bem mais pesado que outros programas similares, por causa da máquina virtual.
Explicando de forma mais elaborada, linguagens de programação "tradicionais", como o C e o C++, utilizam um compilador diferente para cada plataforma ou sistema operacional em que o programa irá rodar. O código fonte em si pode ser escrito de forma a ser facilmente portável, ou seja, rodar em diferentes versões do Unix ou em várias famílias de processadores diferentes sem muitas alterações, mas ainda assim será necessário recompilar o código fonte, gerando um binário diferente para cada caso.
Embora o trabalho inicial seja maior, a vantagem desta abordagem é que o desempenho é o melhor possível, já que sempre teremos um programa binário otimizado para a plataforma.
O Java utiliza um conceito diferente. Ao invés de gerar um binário diferente para cada plataforma, é gerado um binário que pode ser executado em qualquer plataforma, dentro de uma máquina virtual. Este binário "universal" é chamado de bytecode.
A idéia é criar aplicativos que possam ser escritos uma vez e a partir daí serem executados em qualquer plataforma, reduzindo os custos de desenvolvimento. Apenas o software da máquina virtual é que precisa ser reescrito para cada plataforma, mas isso é problema dos desenvolvedores da linguagem, não do programador.
Existe ainda a opção de abrir mão da flexibilidade do bytecode em troca de um maior desempenho, passando a compilar os programas com otimizações para uma determinada plataforma. Isso é muito útil quando o programa será executado apenas dentro de computadores de uma certa plataforma, como PCs rodando Linux, por exemplo.
No caso do Java, a máquina virtual que executa os programas é chamada de Java Virtual Machine. Muitas páginas web utilizam applets Java, por isso a maioria das pessoas acaba instalando o suporte a Java. Hoje em dia, além do Java da Sun, temos versões alternativas, como o Blackdown e o Kofee, que possuem conjuntos de recursos variados, mas são a princípio compatíveis com o código gerado para o Java da Sun.
Embora tenha ganhado relevância com o Java, este conceito não é exatamente novo. Linguagens mais antigas como o LISP e o Prolog já utilizam bytecode e máquinas virtuais.

- Shell Script
: Qualquer distribuição Linux inclui um número absurdo de comandos e pequenos utilitários de modo texto, que são o terror dos iniciantes, mas a alegria dos usuários mais avançados. O motivo de utilitários como o "tar", "dump", "dd", "rsync" e muitos outros terem sobrevivido durante tantas décadas sem muitas modificações, não é apenas resultado do saudosismo de alguns, mas resultado do fato de que, ao contrário da maioria dos utilitários gráficos, eles podem ser combinados com outros comandos e entre si, formando scripts poderosos de backup, automatização de tarefas diversas e muitas outras coisas.
O shell script é uma espécie de linguagem universal no Linux, pois combina comandos de terminal com estruturas lógicas, similares às encontradas em outras linguagens para criar programas de poucas linhas, capazes de executar tarefas complexas. Via shell script é possível desenvolver em minutos ferramentas que demandariam horas de trabalho em outras linguagens.
Muitos dos utilitários de configuração usados nas distribuições (embora muitas vezes não pareçam) são na verdade shell scripts elaborados, que aparentam ser muito mais complexos do que realmente são.
Um exemplo de uso de shell scripts são os ícones mágicos, painéis e outras ferramentas que desenvolvi para uso no Kurumin. Uma outra vantagem é que estes programas não precisam ser compilados. Você simplesmente escreve os comandos num arquivo de texto e executa diretamente. Quando precisa fazer alguma alteração você altera o arquivo e pronto, o problema está resolvido.
Um exemplo de shell script, que serve só para mostrar uma janelinha dando olá na tela seria simplesmente: kdialog --msgbox "Olá, tudo bem?"
Não escrevi errado, ele só tem uma linha mesmo. Na verdade, quando você escreve um shell script, você simplesmente usa funções de outros programas que estão instalados, por isso ele é tão simples se comparado às linguagens de programação "de verdade" que vimos acima.
Você pode encontrar os scripts usados no Kurumin dentro da pasta "/usr/local/bin/". Para estudá-los, você pode abrí-los em qualquer editor de texto e começar fazendo pequenas modificações, para ir aprendendo como eles funcionam.
Os painéis gráficos são desenvolvidos com a ajuda do Kommander, que permite criar scripts gráficos, usando as funções do KDE. Os arquivos vão na pasta "/etc/Painel/" e podem ser abertos usando o "kmdr-editor", no "Iniciar > Sistema > Desenvolvimento".
Um shell script nada mais é do que um arquivo de texto comum, contendo os comandos que serão executados, em ordem. Basicamente, se você sabe como fazer alguma tarefa via linha de comando, você não tem problemas em fazer o mesmo via shell script. Este é um exemplo de script simples, que serve para fazer backup dos arquivos de uma pasta num segundo HD, usando o rsync:
#!/bin/sh
rsync -av /mnt/hda6/ARQUIVOS/ /mnt/hdb6/ARQUIVOS
Todo shell script deve começar com a linha "#!/bin/sh" (ou "#!/bin/bash", que tem exatamente a mesma função), que indica quem irá executar os comandos a seguir, neste caso o próprio bash, o interpretador de comandos do Linux. Na verdade, estas linhas não são realmente necessárias, pois o bash é o padrão de qualquer forma, mas não custa nada fazer as coisas de forma elegante ;-).
O rsync é eficiente para este tipo de tarefa, pois ele sincroniza o conteúdo das duas pastas transferindo apenas as modificações e não os arquivos completos, como aconteceria se você fizesse uma cópia simples. Para que este arquivo de texto vire um script, é necessário que ele tenha permissão para ser executado, o que é feito usando o comando "chmod +x", como em "chmod +x script".
Este é um exemplo de script bem mais complexo, que faz parte do ícone mágico para instalar o VMware Player no Kurumin. Ele faz download do arquivo, verifica se foi baixado corretamente e, se necessário, remove o arquivo e começa de novo, até ter certeza de que ele está ok. Depois, são executados os passos necessários para instalar o programa via linha de comando. No final, ele verifica se o programa foi mesmo instalado e exibe a mensagem apropriada. Este exemplo é mais complexo que os anteriores, pois minha idéia é dar um exemplo de script que é usado na prática:
#!/bin/sh
cd /packages
md5sum=`md5sum vmware-player-distrib.tar.bz2`
while [ "$md5sum" != \
"9e41fed4b2d15d3f44522e5861b4bf5a vmware-player-distrib.tar.bz2" ]
do
cd /packages
rm -f vmware-player-distrib.tar.bz2
wget -c http://downloads-guiadohardware.net/vmware-player-distrib.tar.bz2
md5sum=`md5sum vmware-player-distrib.tar.bz2`
done
tar -jxvf vmware-player-distrib.tar.bz2
cd vmware-player-distrib/
sudo ./vmware-install.pl
rm -rf vmware-player-distrib/
if [ -e /usr/bin/vmplayer ]; then
kdialog --msgbox "O VMware Player foi instalado com sucesso. Você pode criar novas máquinas virtuais e alterar suas configurações usando o Kurumin-EMU, encontrado no Iniciar > Escritório e Utilitários."
else
kdialog --msgbox "Aparentemente houve algum problema durante a instalação. Verifique se está conectado à Internet. Se o servidor do arquivo estiver fora do ar, espere alguns minutos e tente novamente."
fi
À primeira vista, o script não parece tão simples assim, mas sem dúvida é bem mais simples que programas escritos em outras linguagens. Dentro do código, podemos notar algumas funções lógicas, como o while (enquanto), o "if" (então) e o "else" (senão).
O script começa acessando a pasta onde será feito o download e verificando se o arquivo já não foi baixado. Isso evita que ele baixe de novo se ele já foi instalado anteriormente. Em seguida temos um while, que faz com que ele execute um trecho de código repetidamente, até que uma determinada condição seja satisfeita. No caso, a condição é que o md5sum do arquivo precisa estar correto. Se necessário, ele deleta o arquivo e começa de novo.
Depois de baixar o arquivo e verificar o md5sum, ele parte para a instalação, descompactando o arquivo, acessando a pasta que é criada e executando o programa de instalação. No final ele verifica (if [ -e ) se o executável "/usr/bin/vmware" existe, um indício de que o programa foi realmente instalado. Se algo de errado aconteceu e o executável não existe, ele exibe uma mensagem avisando do problema.
Hoje em dia, muitos programas gráficos podem ser controlados via linha de comando. Graças a isso, um script pode fazer coisas como abrir e fechar programas, criar novas janelas, minimizá-las ou maximizá-las, alterar seu conteúdo e assim por diante. Via script também é possível acessar bancos de dados, modificar arquivos de configuração de outros programas ou alterar a configuração do sistema e assim por diante. Você pode ler mais sobre o desenvolvimento de shell scripts no meu livro Linux, Ferramentas Técnicas.


ENTENDENDO O SISTEMA


Apesar das distribuições estarem cada vez mais fáceis de instalar e existir a opção de rodar o sistema direto a partir do CD-ROM, o "modus operandi" do sistema é bem diferente que o do Windows, o que faz com que muitas vezes mesmo tarefas simples, como instalar novos programas ou configurar a rede, pareçam complicadas. Existe ainda a famosa linha de comando, um recurso extremamente poderoso, que não encontra similar no Windows (o prompt do DOS não passa de uma sombra ridícula e subnutrida que nem entra na conta ;).
Este capítulo é um resumo geral da organização do sistema, uso da linha de comando, instalação de novos programas e outras dúvidas comuns. Ele é escrito de forma bem genérica, para que as informações sejam aplicáveis a várias distribuições.
AS INTERFACES E PROGRAMAS
No Windows, a interface gráfica se confunde com o restante do sistema. Existe uma interface "tamanho único" e você simplesmente não tem escolha a não ser se habituar com ela.
No Linux, o conceito de interface gráfica é um pouco diferente. O X.org, ou apenas X para os íntimos, é o responsável pela infra-estrutura básica. Ele é o responsável por se comunicar com a placa de vídeo, montar as imagens que serão mostradas no monitor e fornecer os recursos de que os programas precisam. Mas, assim como o Kernel, ele é "invisível". Quem você vê não é o X.org, mas sim um gerenciador de janelas, que é o programa que monta as janelas e menus que você vê na tela.
A vantagem é que você pode escolher qual gerenciador de janelas usar. O KDE, usado por padrão no Kurumin e muitas outras distribuições, tem um visual mais ou menos parecido com o do Windows. Se você quiser alguma coisa mais parecida com o MacOS, pode experimentar o Gnome (usado por padrão em muitas distribuições, como o Ubuntu); se quiser algo mais geek, pode tentar o Fluxbox, e assim por diante.
Eu pessoalmente recomendo o KDE como melhor opção para quem está começando. Ele tem muitas opções de personalização, permitindo que você deixe-o com praticamente a cara que quiser. Você pode baixar temas, ícones, sons, papéis de parede, etc. no http://kde-look.org. Como o nome sugere, ele é um site dedicado a tudo relacionado a "embelezamento" do KDE.
Claro que o Kernel, o X e o KDE são importantes, eles são a base, mas o que interessa mesmo são os programas. Aqui cai bem uma frase interessante do Linus: "Uma coisa interessante sobre os sistemas operacionais é que ninguém realmente usa um sistema operacional, as pessoas usam os programas instalados nele". De que adiantaria um Kernel rápido e estável e uma interface bonita se você não pudesse navegar na internet, assistir filmes nem ouvir música?.
Por serem dois sistemas operacionais muito diferentes, não existe a princípio qualquer compatibilidade entre os programas escritos para o Linux e o Windows. Disse "a princípio", pois hoje em dia existem alternativas para quem precisa rodar programas do Windows no Linux, o que acho muito positivo já que aumenta nossa liberdade de escolha. Não seria muito agradável se você encontrasse vários recursos interessantes no Linux, mas ficasse preso ao Windows por causa de algum programa que você não pode viver sem.
Existem basicamente duas opções: o Wine permite executar diretamente programas Windows no Linux. Ele funciona muito bem em alguns casos e não tão bem em outros. O Cedega é uma versão do Wine otimizada para jogos, que permite rodar um grande número de games, como o Counte Strike e Warcraft III, e o CrossOver Office é uma versão otimizada para rodar o Office e outros aplicativos de produtividade.
Temos ainda o VMware, que permite rodar o Windows inteiro dentro de uma janela e conseqüentemente todos os programas que quiser. A grande diferença entre o Wine e o VMware, é que o Wine executa os programas Windows diretamente, com compatibilidade limitada, enquanto o VMware permite que você execute diretamente uma instância completa do Windows dentro de uma janela, e rode os programas dentro dela.
Mas, voltando ao ponto principal, aqui vai uma pequena amostra de alguns dos programas incluídos nas distribuições atuais, que dão conta das tarefas mais comuns. Mais adiante teremos um capítulo inteiro dedicado a mostrar e analisar os programas disponíveis.
O Konqueror é o navegador incluído no KDE. Ele é bastante rápido e serve também como um excelente gerenciador de arquivos. O Konqueror é bastante versátil, pois pode ser usado para acessar compartilhamentos de rede, ripar CDs, acessar as configurações do KDE e muitas outras funções. Concorrendo com ele temos o Firefox, que se tornou uma espécie de navegador padrão, roubando até mesmo o espaço do IE no Windows. O Firefox deu origem a outros navegadores, como o Epiphany e o Galeon, encontrados em algumas distribuições.
Entre os programas de mensagem instantânea, temos o Gaim, Kopete e Sim, que combinam acesso a vários protocolos, como o Trillian for Windows. Entre os programas especializados, que acessam apenas o MSN, temos o Mercury (que inclui inclusive suporte a webcam) e o Amsn, além do Skype, que possui versão Linux.
Para assistir filmes e DVDs, você pode contar com o Kaffeine, Xine (e suas variantes, como o gXine e o Toten) e o Mplayer. O suporte a formatos de vídeo diversos já foi um problema no Linux, mas hoje em dia a situação é muito mais confortável que no Windows, com suporte inclusive a vídeos via streaming através do navegador.
A maior parte dos codecs disponíveis já vem incluídos no sistema, e o suporte aos formatos de vídeo mais "complicados", como o QuickTime e o WMF, é adicionado instalando um pacote adicional, o "w32codecs". Para assistir DVDs protegidos, você precisa do pacote "libdvdcss2". Existe ainda uma versão Linux do RealPlayer, que completa o time.
Existem algumas exceções a esta regra, como o Fedora, OpenSuSE e o Ubuntu, que vem por padrão com um conjunto capado de codecs, com o objetivo de eliminar qualquer possibilidade de problemas relacionados a licenças ou patentes. Nestes casos, você tem suporte apenas aos formatos mais básicos (muitas vezes sequer a arquivos MP3) e precisa adicionar os demais manualmente.
Para ouvir música temos o clássico XMMS, que oferece um conjunto de funções similar ao WinAmp, o próprio Kaffeine e um conjunto de players de "nova geração", como o Amarok, que seguem a tendência de organizar as músicas na forma de coleções, inaugurada pelo iTunes da Apple.
Para edição de texto, planilhas e apresentações, a opção mais desenvolvida é o OpenOffice. Como ele é atualizado muito freqüentemente, recebe correções e melhorias num ritmo muito acelerado. Ele já está à frente do MS Office em várias áreas, oferece por exemplo um recurso de salvar qualquer documento como um arquivo PDF, um formato ideal para mandar por e-mail ou publicar na web por exemplo. Em outubro de 2005, foi lançado o OpenOffice 2.0, que trouxe melhorias expressivas na interface e na compatibilidade com os arquivos do Office e o OpenOffice Base, um aplicativo de banco de dados que concorre com o Access.
Apesar do OpenOffice ser de longe o mais conhecido e aberto, temos outras opções, como o Koffice, a suíte office do KDE, composta de 11 aplicativos, incluindo o Kword, Koffice, Kpresenter, Kivio (fluxogramas), Krita (editor de imagens), Kchart, Kformula e outros. Eles oferecem a vantagem de serem mais leves que o OpenOffice e possuírem menos funções, o que os torna mais fáceis de usar para muitos. Mais uma opção é a dupla Abiword (texto) e Gnumeric (planilhas), que são bem completos mas ainda assim bastante leves em comparação com o OpenOffice.
Para edição de imagem temos o Gimp, um concorrente direto do Photoshop. Para desenho vetorial temos o Inkscape, Sodipodi, Karbon14 e o próprio OpenOffice Draw.
O Mozilla Thunderbird é um cliente de e-mails com muitos recursos, incluindo um filtro anti-span adaptável, que "aprende" durante o uso, relacionando novas mensagens de span com outras anteriormente recebidas, enquanto o Evolution é mais parecido com o Outlook, incluindo compatibilidade com servidores Exchange. Temos ainda o Kmail, que se diferencia dos dois por ser um cliente mais simples e leve, integrado ao KDE.
Existem muitos jogos que rodam nativamente no Linux, como o Unreal (2003 e 2004), toda a série Quake (incluindo o 4), vários jogos próprios para a plataforma e muitos que rodam através do Cedega.
Uma grande diferença entre o Windows e as principais distribuições nesta área é que o Windows em si traz poucos aplicativos e você precisa baixar ou comprar os programas adicionais e ir instalando-os posteriormente. No caso das distribuições, o sistema já vem com um grande conjunto de programas, fazendo com que em muitos casos o principal trabalho seja remover os que não usa.
ONDE ESTOU?? ENTENDENDO OS OS DIRETORIOS
O primeiro choque para quem está chegando agora é a estrutura de diretórios do Linux, que não lembra em nada o que temos no Windows. No Windows temos os arquivos do sistema concentrados nas pastas Windows e Arquivos de programas, e você pode criar e organizar suas pastas da forma que quiser.
No Linux é basicamente o contrário. O diretório raiz está tomado pelas pastas do sistema e espera-se que você armazene seus arquivos pessoais dentro da sua pasta no diretório /home.
Mas, as diferenças não param por aí. Para onde vão os programas que são instalados se não existe uma pasta central como a "Arquivos de programas"? E para onde vão os arquivos de configuração se o Linux não possui nada semelhante ao registro do Windows?
A primeira coisa com que você precisa se habituar é que no Linux os discos e partições não aparecem necessariamente como unidades diferentes, como o C:, D:, E: do Windows. Tudo faz parte de um único diretório, chamado diretório raiz ou simplesmente "/".
Dentro deste diretório temos não apenas todos arquivos e as partições de disco, mas também o CD-ROM, drive de disquete e outros dispositivos, formando a estrutura que você vê no gerenciador de arquivos.
O diretório "/bin" armazena os executáveis de alguns comandos básicos do sistema, como o su, tar, cat, rm, pwd, etc. Geralmente isto soma de 5 a 7 MB, pouca coisa.
O grosso dos programas ficam instalados dentro do diretório /usr (de "Unix System Resources", ou recursos de sistema Unix). Este é de longe o diretório com mais arquivos em qualquer distribuição Linux, pois é aqui que ficam os executáveis e bibliotecas de todos os principais programas. A pasta "/usr/bin" (bin de binário), por exemplo, armazena cerca de 2.000 programas e atalhos para programas numa instalação típica. Se você tiver que chutar em que pasta está o executável de um programa qualquer, o melhor chute seria justamente a pasta /usr/bin :-).
Outro diretório "populado" é o "/usr/lib", onde ficam armazenadas bibliotecas usadas pelos programas. A função destas bibliotecas lembra um pouco a dos arquivos .dll no Windows. As bibliotecas com extensão ".a" são bibliotecas estáticas, que fazem parte de um programa específico, enquanto as terminadas em ".so.versão" (xxx.so.1, yyy.so.3, etc.) são bibliotecas compartilhadas, usadas por vários programas.
Subindo de novo, a pasta "/boot" armazena (como era de se esperar) o Kernel e alguns arquivos usados pelo Lilo (o gerenciador de boot do sistema), que são carregados na fase inicial do boot. Estes arquivos são pequenos, geralmente ocupam menos de 5 MB. Versões antigas do Red Hat e de outras distribuições criam por default uma partição separada para o diretório "/boot" de cerca de 30 MB, posicionada no início do disco para evitar o limite de 1024 cilindros dos BIOS de micros antigos. Isto não é necessário hoje em dia, pois nas versões atuais do Lilo este limite não existe mais. Apesar disso, alguns usuários preferem manter o "/boot" numa partição separada por questão de hábito.
Se tiver curiosidade, o arquivo "config-2.6.11-kanotix-7" (o número de versão muda de acordo com a distribuição) é justamente o arquivo compactado com o Kernel do sistema, que é carregado durante o boot.
Quando se fala em particionamento, as possibilidades são muitas, existem até listas de discussão dedicadas exclusivamente ao assunto. Afinal, talvez usar o sistema de arquivos xxx na partição yyy possa melhorar em 0,03% o desempenho do sistema... Tem gente que realmente se prende aos detalhes. :-).
Logo abaixo temos o diretório "/dev", que é de longe o exemplo mais exótico de estrutura de diretório no Linux. Todos os arquivos contidos aqui, como, por exemplo, "/dev/hda", "/dev/dsp", "/dev/modem", etc., não são arquivos armazenados no HD, mas sim ponteiros para dispositivos de hardware. Por exemplo, todos os arquivos gravados no "arquivo" "/dev/dsp" serão reproduzidos pela placa de som, enquanto o "arquivo" "/dev/mouse" contém as informações enviadas pelo mouse.
Esta organização visa facilitar a vida dos programadores, que podem acessar o hardware do micro simplesmente fazendo seus programas lerem e gravarem em arquivos. Não é preciso nenhum comando esdrúxulo para tocar um arquivo em .wav, basta "copiá-lo" para o arquivo "/dev/dsp", o resto do trabalho é feito pelo próprio sistema. O mesmo se aplica ao enviar um arquivo pela rede, ler as teclas do teclado ou os clicks do mouse e assim por diante. O Kernel se encarrega da parte complicada.
O diretório "/etc" concentra os arquivos de configuração do sistema, substituindo de certa forma o registro do Windows. A vantagem é que enquanto o registro é uma espécie de caixa preta, os scripts do diretório "/etc" são desenvolvidos justamente para facilitar a edição manual. É verdade que na maioria dos casos isto não é necessário, graças aos vários utilitários de configuração disponíveis, mas a possibilidade continua aí.
Os arquivos recebem o nome dos programas seguidos geralmente da extensão .conf. Por exemplo, o arquivo de configuração do servidor DHCP (que pode ser configurado para atribuir endereços IP aos outros micros da rede) é o "/etc/dhcpd.conf", enquanto o do servidor FTP é o "/etc/proftpd.conf". Claro, ao contrário do registro, os arquivos do "/etc" não se corrompem sozinhos e é fácil fazer cópias de segurança caso necessário.
O diretório "/mnt" (de "mount") recebe este nome justamente por servir de ponto de montagem para o CD-ROM (/mnt/cdrom), drive de disquetes (/mnt/floppy), drives Zip e outros dispositivos de armazenamento. O uso do diretório /mnt é apenas uma convenção. Você pode alterar o ponto de montagem do CD-ROM para /CD, ou qualquer outro lugar se quiser. Isso é configurável através do arquivo "/etc/fstab", onde vai a lista de todos os dispositivos usados pelo sistema e as pastas em que cada um é montado.
Nada impede que você crie mais pastas no diretório raiz para armazenar seus arquivos. Apesar de ser recomendável em termos de organização e segurança, você não é obrigado a concentrar seus arquivos dentro do seu diretório de usuário. Nada impede que você abra o gerenciador de arquivos como root (kdesu konqueror), crie uma pasta /MP3, abra o menu de permissões para que seu login de usuário tenha permissão para acessá-la e a utilize para guardar suas músicas, por exemplo.
USANDO O TERMINAL
No início, todos os sistemas operacionais usavam apenas interfaces de modo texto. Antes do Windows, existiu o DOS e, antes do KDE, Gnome e todas as outras interfaces que temos atualmente, o Linux tinha também apenas uma interface de modo texto.
A diferença é que no Linux a interface de modo texto evoluiu junto com o restante do sistema e se integrou de uma forma bastante consistente com os aplicativos gráficos. Quanto mais você aprende, mais tempo você acaba passando no terminal; não por masoquismo, mas porque ele é realmente mais prático para fazer muitas coisas.
Você pode chamar qualquer aplicativo gráfico a partir do terminal; na maioria dos casos o comando é o próprio nome do programa, como "konqueror" ou "firefox". Durante o livro você vai notar que, em muitos exemplos, ensino os passos para executar tarefas através da linha de comando, pois os atalhos para abrir os programas, itens nos menus, etc., podem mudar de lugar, mas os comandos de texto são algo mais ou menos universal, mudam pouco mesmo entre diferentes distribuições. Esta mesma abordagem é adotada de forma geral dentro dos livros sobre Linux.
Por exemplo, para descompactar um arquivo com a extensão .tar.gz, pelo terminal, você usaria o comando:
$ tar -zxvf arquivo.tar.gz
Aqui o "tar" é o comando e o "-zxvf" são parâmetros passados para ele. O tar permite tanto compactar quanto descompactar arquivos e pode trabalhar com muitos formatos de arquivos diferentes, por isso é necessário especificar que ele deve descompactar o arquivo (-x) e que o arquivo está comprimido no formato gzip (z). O "v" é na verdade opcional, ele ativa o modo verbose, onde ele lista na tela os arquivos extraídos e para onde foram.
Se você tivesse em mãos um arquivo .tar.bz2 (que usa o bzip2, um formato de compactação diferente do gzip), mudaria a primeira letra dos parâmetros, que passaria a ser "j", indicando o formato, como em:
$ tar -jxvf arquivo.tar.bz2
Você poderia também descompactar o arquivo clicando com o botão direito sobre ele numa janela do Konqueror e usando a opção "Extrair > Extrair aqui". Para quem escreve, é normalmente mais fácil e direto incluir o comando de texto, mas você pode escolher a maneira mais prática na hora de fazer.
Existe um número muito grande de pequenos aplicativos de modo texto, cada um deles suportando muitos parâmetros diferentes, por isso é quase impossível conhecer todos. Aprender a usar o modo texto é parecido com aprender uma segunda língua, é um processo gradual e constante, onde você sempre está aprendendo comandos, parâmetros e truques novos. É uma área em que ninguém pode dizer que sabe tudo.
Existem duas formas de usar o terminal. Você pode acessar um terminal "puro" pressionando as teclas "Ctrl+Alt+F1", mudar entre os terminais virtuais pressionando "Alt+F2", "Alt+F3", etc. e depois voltar ao modo gráfico pressionando "Alt+F7", "Alt+F5" ou mesmo "Alt+F3", dependendo do número de terminais de texto usados na distribuição em uso.
Estes terminais são às vezes necessários para manutenção do sistema, em casos em que o modo gráfico deixa de abrir, mas no dia-a-dia não é prático usá-los, pois sempre existe uma pequena demora ao mudar para o texto e voltar para o ambiente gráfico, e, principalmente, estes terminais não permitem usar aplicativos gráficos.
Na maior parte do tempo, usamos a segunda forma, que é usar um "emulador de terminal", um terminal gráfico que permite rodar tanto os aplicativos de texto, quanto os gráficos.
No KDE, procure o atalho para abrir o Konsole. Ele possui várias opções de configuração (fontes, cores, múltiplas janelas, etc.). Se você preferir uma alternativa mais simples, procure pelo Xterm.
O Xterm é o mais simples, que abre quase instantaneamente. O Konsole por sua vez é bem mais pesado, mas oferece mais recursos, como abrir vários terminais dentro da mesma janela, fundo transparente, etc. Dê uma olhada rápida em cada um e veja qual lhe agrada mais. Além destes dois, existem vários outros, como o Gnome Terminal, Rxvt e Eterm, incluídos ou não de acordo com a distribuição.
Na maioria dos casos, ao chamar um programa gráfico através do terminal, você pode passar parâmetros para ele, fazendo com que ele abra diretamente algum arquivo ou pasta. Por exemplo, para abrir o arquivo "/etc/fstab" no Kedit, use:
$ kedit /etc/fstab
Para abrir o arquivo "imagem.png" no Gimp, use:
$ gimp imagem.png
No começo, faz realmente pouco sentido ficar tentando se lembrar do comando para chamar um determinado aplicativo ao invés de simplesmente clicar de uma vez no ícone do menu. Mas, depois de algum tempo, você vai perceber que muitas tarefas são realmente mais práticas de fazer via terminal.
É mais rápido digitar "kedit /etc/fstab" do que abrir o kedit pelo menu, clicar no "Arquivo > Abrir" e ir até o arquivo usando o menu. É uma questão de costume e gosto. O importante é que você veja o terminal como mais uma opção, que pode ser utilizada quando conveniente, e não como algo intimidador.
COMPLETANDO COM A TECLA TAB
Um dos recursos que torna o terminal um ambiente dinâmico é a possibilidade de completar comandos e nomes de arquivos usando a tecla Tab do teclado. Por exemplo, imagine o comando:
$ md5sum kurumin-6.0alpha1.iso
Um pouco desconfortável de digitar não é mesmo? Nem tanto. Com a ajuda da tecla tab, você pode digitá-lo com apenas 8 toques: md5<tab> kur<tab>. Prontinho, fica faltando só dar o enter :-).
Se por acaso houver outro comando começado com "md5" ou outro arquivo na mesma pasta começado com "kur", então o Tab completará até o ponto em que as opções forem iguais e exibirá uma lista com as possibilidades para que você termine de completar o comando. Por exemplo, se tivesse os arquivos kurumin-5.1.iso e kurumin-6.0alpha1.iso na mesma pasta, ele completaria até o "md5sum kurumin-", onde os nomes diferem e deixaria que completasse o comando.
Pressionando <tab> duas vezes, ele exibe uma lista das opções disponíveis. Por exemplo, digitando: apt-get remove<tab><tab>, ele pergunta:
Display all 826 possibilities? (y or n)
Continuando, ele exibe uma lista de todos os pacotes (atualmente instalados), que poderiam ser removidos usando o comando. O autocompletar é bem inteligente, entendendo a sintaxe dos comandos usados e exibindo apenas as possibilidades que se aplicam a eles.
COMONDOS DO PROMPT
Apesar da interface gráfica ser muito mais fácil de usar, é bom você ter pelo menos uma boa noção de como as coisas funcionam pelo prompt de comando, isso vai lhe dar um domínio muito maior sobre o sistema.
Em vários pontos deste livro, sem falar de outros tipos de documentação sobre Linux, você verá receitas com longas listas de comandos que devem ser dados para configurar ou alterar algo. Na grande maioria dos casos, existe algum utilitário gráfico que permite fazer o mesmo, mas os autores geralmente preferem dar a receita de como fazer via linha de comando, pois nem todo mundo terá os utilitários à mão e muitas vezes existem diferenças entre as opções disponíveis nas diferentes distribuições. Dar simplesmente uma lista de comandos torna a dica utilizável para um número maior de pessoas.
Outro ponto é que muitas vezes é realmente mais fácil simplesmente dar um comando para abrir um arquivo e descomentar algumas linhas do que abrir um utilitário que demora 10 segundos para carregar, navegar por um monte de menus diferentes e marcar algumas opções escondidas. Uma coisa interessante no Linux é que você não precisa realmente digitar os comandos, basta selecionar a linha e usar o botão do meio do mouse para colá-la na janela do prompt.
O modo de comando é uma forma de "conversar" com o sistema, com mais opções do que seria possível através de um utilitário gráfico e obtendo respostas mais rápidas. É claro que o modo de comando pode assustar no início, mas um pouco de insistência vai facilitar bastante sua vida daqui em diante. Não seja apressado, o legal é justamente ir aprendendo comandos novos conforme os problemas forem aparecendo.
Aqui estão alguns comandos básicos:
cd: Serve para navegar entre os diretórios. Ao abrir o terminal, você começa dentro do seu diretório home (como "/home/kurumin"). Para acessar um diretório específico, especifique-o como parâmetro, como em "cd /etc". Para subir um diretório use "cd .." e, para voltar ao home, digite simplesmente "cd", sem parâmetro algum. Sempre que quiser confirmar em qual diretório está, use o comando "pwd".
Se você estiver dentro da pasta "/home/kurumin/arquivos/", por exemplo, e quiser ir para a pasta "/usr/local", não é preciso usar o "cd .." até voltar ao diretório raiz, para só depois abrir a pasta, basta dar o comando "cd /usr/local", de qualquer lugar, para ir diretamente à pasta desejada. Se, por outro lado, você quiser acessar a pasta "trabalho", dentro da pasta atual, digite apenas "cd trabalho".
ls: Serve para listar os arquivos e diretórios dentro da pasta atual. Na maioria das distribuições, a listagem aparece colorida, permitindo diferenciar as pastas e os diferentes tipos de arquivos. As pastas aparecem em azul, os links em azul claro, os arquivos compactados em vermelho, as imagens em rosa, os executáveis em verde e os arquivos de texto e outros formatos em preto.
Para incluir os arquivos ocultos (que no Linux começam com "."), use "ls -a". Para ver mais detalhes sobre cada arquivo, incluindo o tamanho, permissões de acesso e dono, use "ls -lh". Para incluir os ocultos, adicione o "a", como em "ls -lha".
A ordem dos parâmetros não altera o resultado do comando. Tanto faz digitar "tar -zxvf arquivo.tar.gz", quando "tar -xzfv arquivo.tar.gz". Acostume-se a sempre usar a tecla Tab para completar os comandos (principalmente os nomes de arquivos), assim, além de digitar mais rápido, você diminui a possibilidade de erros.
man: Como disse, ninguém pode dizer que sabe tudo sobre todos os comandos do terminal. Para facilitar as coisas, cada comando possui um manual, onde são citados todos os parâmetros e vários exemplos. Todos estes manuais são acessados através de um comando único, o "man". Para ver as (muitas) opções do "ls", por exemplo, use "man ls". Use as setas para rolar a tela e, para sair do manual, pressione a tecla "q".
O man acaba sendo um componente essencial para quem usa muito a linha de comando, pois mesmo comandos simples, como o ls, cat, grep, tail, usados no dia-a-dia possuem mais parâmetros do que é possível memorizar (pelo menos para uma pessoa normal ;), de forma que o man acaba servindo como um guia de consulta rápida.
Mas, devido à quantidade de parâmetros disponíveis, os manuais de muitos programas são muito longos e complicados. Por isso, muitos suportam o parâmetro "--help", que exibe uma ajuda resumida, contendo apenas os parâmetros mais usados. Experimente, por exemplo, o "ls --help".
Se você quiser apenas uma descrição rápida do que um determinado comando faz, experimente o comando "whatis" (o que é), como em: "whatis ls".
Mais uma variante do man é o comando "info", que contém manuais alternativos para muitos comandos. Enquanto os manuais do man são técnicos, desenvolvidos para serem manuais de referência, os do info normalmente utilizam uma linguagem mais simples, abordando apenas as opções mais comuns. Nem todos os comandos possuem uma página info, mas o número vem crescendo. Para usá-lo, basta digitar "info comando", como em "info lsmod".
cp: Este é o comando usado para copiar arquivos de uma pasta a outra. Inclua o nome do arquivo e a pasta para onde ele vai, como em "cp arquivo.tar.gz /mnt/sda1". Se você quiser copiar um arquivo que está em outra pasta para o diretório atual, inclua a localização completa do arquivo e em seguida o "./" (que representa o diretório atual), como em "cp /mnt/cdrom/video.avi ./".
O cp é por padrão um comando bastante chato e difícil de entender. Se você quer copiar uma pasta do CD para o diretório atual, o mais lógico seria digitar "cp /mnt/cdrom/musicas ./", não é?. Mas, se você fizer isso, ele responde: "cp: omitindo diretório '/mnt/cdrom/musicas' ".
Para copiar toda a pasta, você precisaria incluir o comando "-r", que explica que ele deve copiar recursivamente, incluindo todos os arquivos e subdiretórios.
Um parâmetro bastante útil é o "-a", que faz com que o cp sempre copie recursivamente, mantenha as permissões do arquivo original e preserve os links simbólicos que encontrar pelo caminho. Em resumo, faz o cp se comportar de uma forma mais simples e lógica. Para copiar a pasta do exemplo original, experimente usar "cp -a /mnt/cdrom/musicas ./".
Você pode ainda usar o "*" e a "?" como curingas quando quiser copiar vários arquivos. Para copiar todos os arquivos da pasta atual para a pasta "/mnt/hda6", por exemplo, use "cp * /mnt/hda6".
A "?" por sua vez é mais contida, substituindo um único caractere. Por exemplo, "cp arquivo?.txt /mnt/hda6", copia o "arquivo1.txt", "arquivo2.txt" e o "arquivo3.txt", mas não o "arquivo21.txt".
Lembre-se da diferença entre usar a barra ou não no início do arquivo. Uma barra especifica que você está dando o caminho completo a partir do diretório raiz, como em "/mnt/cdrom/musicas", por exemplo. Ao dar o nome de uma pasta ou arquivo, sem a barra, o sistema entende que ele está dentro do diretório atual. Por exemplo, se você está no diretório /home e quer acessar a pasta "/home/kurumin/arquivos", você precisaria digitar apenas "cd kurumin/arquivos".
Outra dica é que existem no shell algumas variáveis de ambiente que podem ser usadas para abreviar comandos. Por exemplo, o caractere "~" representa seu diretório home (como "/home/kurumin"). Você pode usá-lo para abreviar comandos: para copiar a pasta "/mnt/cdrom/musicas" para o home, você pode usar "cp -a /mnt/cdrom/musicas ~", ao invés de digitar "cp -a /mnt/cdrom/musicas /home/kurumin", por exemplo.
mv: O mv serve tanto para mover arquivos de um lugar para o outro quanto para copiar arquivos. Para mover o arquivo foto.png para a pasta "/mnt/hda6/", o comando seria "mv foto.png /mnt/hda6". Você pode usar o mv também para mover e renomear pastas. A diferença entre o mv e o cp é que, ao mover, o arquivo original deixa de existir.
rm: O rm serve para remover tanto arquivos quanto diretórios, de acordo com os parâmetros usados. Para remover um arquivo simples, basta usá-lo diretamente, como em "rm arquivo". Para que ele remova sem pedir a confirmação, adicione o parâmetro "-f", como em "rm -f arquivo". Para remover uma pasta e todos os arquivos e diretórios dentro dela, adicione o parâmetro "-r", como em "rm -rf arquivos/".
Tome cuidado ao usar o "-rf", pois ele não pede confirmação, deleta os arquivos diretamente, sem escalas. Respire fundo e verifique se realmente está deletando a pasta certa antes de pressionar Enter.
É possível também usar caracteres curingas na hora de remover arquivos. Para remover todos que possuírem a extensão ".jpg", use "rm -f *.jpg". Para remover todos os arquivos que começarem com "img", use "rm -f img*". Lembre-se de que você pode usar também o "?" quando quiser usar o curinga para apenas um caractere específico. Se você quiser remover os arquivos "doc1.txt", "doc2.txt" e "doc3.txt", mas sem remover o "doc10.txt" e o "doc11.txt", você poderia usar o comando "rm -f doc?.txt".
mkdir: Este serve para criar novos diretórios, como em "mkdir /mnt/hda6/arquivos". É possível também criar pastas recursivamente, criando se necessário todas as pastas necessárias até chegar a que você pediu, adicionando o parâmetro "-p" como em "mkdir -p /mnt/hda6/arquivos/novos/2006". Mesmo que a pasta "novos" não exista, ela será criada.
rmdir: Esta é uma variação do mkdir, que permite remover diretórios. A diferença entre ele e o "rm -rf" é que o rmdir só remove diretórios vazios. Acostume-se a usá-lo no lugar do "rm -rf" ao deletar uma pasta que acha que está vazia, assim você evita acidentes.
locate: Este é um dos comandos mais úteis na minha opinião; ele permite encontrar arquivos de forma instantânea. Assim como mecanismos de busca, como o Google, o locate não sai procurando em todo o HD até achar o arquivo que pediu. Ele procura apenas dentro de uma base de dados, que contém os nomes de todos os arquivos. Esta base é gerada ao rodar o comando "updatedb", sua cara metade.
A vantagem de usar a base de dados é que as buscas são instantâneas, a desvantagem é que você precisa rodar o updatedb (como root) de vez em quando, a fim de incluir as últimas modificações. Para procurar um arquivo, simplesmente use "locate arquivo".
Se você está procurando por um programa, experimente o comando "which", uma variante do locate que mostra apenas executáveis.
find: O find também permite localizar arquivos, mas funciona da forma tradicional, realmente vasculhando os diretórios em busca dos arquivos, ao invés de usar uma base de dados, como o locate. Embora seja lento ao procurar em diretórios com muitos arquivos e subdiretórios, o find é eficiente se você souber previamente onde procurar. Por exemplo, o diretório "/etc" concentra as configurações do sistema. Se você estiver procurando pelo arquivo "smb.conf" (onde é armazenada a configuração do Samba), você poderia ir direto à fonte, usando o comando "find /etc -name smb.conf".
Note que além do diretório onde ele vai procurar (/etc no exemplo), você deve usar o parâmetro "-name" antes de indicar o nome do arquivo que está procurando. Omitindo o diretório, ele simplesmente procura dentro do diretório atual. Você pode também fazer buscas por todos os arquivos com uma determinada extensão, como em "find /mnt/hda6 -name *.mp3".
Uma forma mais amigável de procurar arquivos é usar o kfind, o "Procurar arquivos" do KDE, que serve como uma interface para o find. Através dele você pode procurar pelo nome ou tipo de arquivo (você pode fazer uma busca incluindo apenas arquivos de imagem, por exemplo), procurar dentro de pastas específicas ou localizar arquivos pertencentes a um determinado usuário ou grupo do sistema, ou até mesmo procurar por arquivos modificados recentemente.

su: No Linux, existe uma separação clara entre o root e os demais usuários do sistema. O root é o único que pode alterar a configuração do sistema e usar a maior parte das ferramentas de configuração. Os usuários normais, por sua vez, podem usar os programas instalados e modificar arquivos dentro do seu diretório home. Esta organização permite que várias pessoas usem o mesmo micro (o que é vital no caso dos servidores), sem que um possa alterar as configurações do outro, nem muito menos mudar as configurações do sistema.
Por um lado, isso torna o sistema muito mais robusto, mas por outro faz com que algumas tarefas sejam mais complexas, pois você precisará primeiro se logar como root, para depois executar o comando. O su permite que você "vire" root a qualquer momento, passando a abrir os programas, modificar arquivos e usar todas as ferramentas sem limitações.
Digite "su" e forneça a senha de root. O "$" do terminal vira um "#", alertando que a partir daí você tem plenos poderes. Se ao tentar abrir arquivos gráficos você receber uma mensagem dizendo que não é possível se conectar ao X, experimente usar o comando "sux" no lugar do su. Ele configura as permissões corretamente.
Algumas distribuições, como o Kurumin e o Ubuntu incluem uma variação dele, o "sudo", que permite executar comandos específicos como root. Para abrir o Konqueror (o gerenciador de arquivos), como root, de forma a conseguir alterar arquivos fora do seu home, digite "sudo konqueror". Dependendo da configuração, ele abre sem pedir senha, ou confirma sua senha de usuário, uma proteção contra a possibilidade de outra pessoa estar usando seu micro.
cat: Serve para ver o conteúdo de um arquivo. Por exemplo, "cat carta" mostra o conteúdo do arquivo "carta". Este comando serve bem para ver o conteúdo de arquivos de texto pequenos, sem precisar abrir um editor mais sofisticado. Ele também pode ser combinado com outros comandos para realizar tarefas mais complexas. Por exemplo, se você tem um arquivo "boot.img" com a imagem de um disquete de boot, não bastaria simplesmente copiar o arquivo para o disquete com o comando cp; você precisaria fazer uma cópia bit a bit. Existem várias formas de fazer isso, mas uma solução simples seria usar o comando "cat boot.img > /dev/fd0".
Neste caso, ele lista o conteúdo do arquivo, mas ao invés de mostrar na tela ele o escreve no disquete (/dev/fd0). No shell existem alguns caracteres especiais, como o ">", ">>" e o "|", que permitem enviar informações e o texto de resposta de comandos de um lugar para o outro. Você verá muitos usos úteis para estes recursos especiais ao estudar sobre shell script.
clear: Limpa a tela, uma forma de colocar a ordem na casa antes de executar novos comandos. Ao invés de digitar, você pode pressionar "Ctrl+L", que é o atalho de teclado para ele.
head: Este é um dos primos do cat, ele permite ver apenas as primeiras linhas do arquivo, ao invés de exibir a coisa inteira. Basta especificar o número de linhas que devem ser exibidas, como por exemplo "head -20 texto.txt".
Outro parente distante é o tail (cauda), que mostra as últimas linhas do arquivo. O uso é o mesmo, basta indicar o número de linhas que devem ser mostradas e o nome do arquivo, como "tail -12 meu_longo_texto.txt".
Este comando é muito usado por administradores de sistemas para acompanhar os arquivos de log de seus servidores. Como as novas entradas destes arquivos vão sendo inseridas no final do arquivo, o tail permite verificar rapidamente apenas as novas inclusões, sem precisar perder tempo abrindo o arquivo inteiro.
du: O du permite ver uma lista com o espaço ocupado por cada pasta dentro do diretório atual. É uma forma rápida de encontrar grandes arquivos ou pastas que estão consumindo muito espaço. Em geral usamos "du -h", onde o -h faz com que ele exiba o tamanho dos arquivos de forma "humana", escrevendo "2,8G" ao invés de "2876322", por exemplo.
O Konqueror inclui um modo de visualização que funciona de maneira similar, mostrando os arquivos e pastas na forma de blocos coloridos, classificados de acordo com o tamanho. Para ativar este modo, clique no último botão da barra de funções:
| (pipe): Junto com as setas de redirecionamento (> e >>), o pipe ( | ) é muito usado em scripts e comandos diversos. Ele permite fazer com que a saída de um comando seja enviada para outro ao invés de ser mostrada na tela. Parece uma coisa muito exótica, mas acaba sendo incrivelmente útil, pois permite "combinar" diversos comandos que originalmente não teriam nenhuma relação entre si, de forma que eles façam alguma coisa específica.
Por exemplo, imagine que você quer imprimir o manual de algum dos comandos, ou mandar por e-mail para alguém que não tem Linux instalado. Uma forma de fazer isso seria usar o comando "man comando | col -b > arquivo.txt", que copia toda a saída do comando man para o arquivo.txt, mantendo a formatação e as quebras de linha. Aqui usamos o pipe para enviar a saída do man, que originalmente seria mostrada na tela, para ser reformatada pelo comando "col -b" e, a partir daí, para o arquivo. O pipe é um componente de muitos comandos que veremos ao longo do livro.
grep: O grep permite filtrar a saída de um determinado comando, de forma que ao invés de um monte de linhas, você veja apenas a informação que está procurando. Ele é freqüentemente usado em conjunto com o pipe, sobretudo em scripts.
Um exemplo simples: sua placa de rede não está funcionando e você quer saber se o módulo de kernel "sis900", que dá suporte a ela, está carregado. Você pode ver os módulos que estão carregados usando o comando "lsmod", mas a lista é um pouco longa. Você poderia completar o lsmod com "| grep sis900", que vai filtrar usando o grep, mostrando na tela apenas as linhas contendo "sis900". O comando ficaria então "lsmod | grep sis900".
Se não aparecer nada na tela, você sabe de antemão que o módulo não está ativo, Neste caso, você poderia tentar carregá-lo manualmente usando o comando "modprobe sis900", como root.
split: Esse comando serve para quebrar arquivos em vários pedaços. Muito útil quando você precisa gravar arquivos grandes em vários disquetes ou CDs, por exemplo. Imagine que você queira quebrar um arquivo de 3 GB chamado "tenshi.avi" em vários arquivos de 650 MB cada um, de forma a conseguir gravá-lo em vários CDs. Poderia usar o comando "split -b 650m tenshi.avi".
O "650m" é o tamanho de cada pedaço, no caso 650 MB. Você precisa apenas trocar o tamanho dos pedaços e o nome do arquivo. Esse comando vai gerar vários arquivos: xaa, xab, xac, xad, etc. que podem ser transportados. Para juntá-los depois, usamos o comando cat que vimos acima. Basta reunir todos na mesma pasta novamente e rodar o comando "cat x* > tenshi.avi".
Isso junta todos os arquivos (na ordem) restaurando o arquivo original. Isso funciona porque os fragmentos de arquivo gerados pelo split sempre começam com "x".
Outro truque é que você pode usar o cat também para juntar diversos arquivos, formando um só. Isto funciona para músicas e vídeos, por exemplo. Para juntar vários vídeos curtos, num único maior, use "cat video1.avi video2.avi video3.avi > videozao.avi".
&: Este é um parâmetro que permite rodar aplicativos mantendo o terminal livre. No Linux, todos os aplicativos, mesmo os gráficos, podem ser chamados a partir de uma janela de terminal. O problema é que, ao chamar algum aplicativo, o terminal ficará bloqueado até que o aplicativo seja finalizado, obrigando-lhe a abrir um para cada programa.
Acrescentar o & no final do comando, como em "konqueror /etc &" resolve este problema, mantendo o terminal livre. Se você esquecer de acrescentar ao "&" ao abrir um programa, ainda pode "destravar" o terminal pressionando "Ctrl+Z" (que paralisa o programa e te devolve o controle do terminal) e depois "bg", que reinicia o programa em background.
Note que alguns aplicativos exibem mensagens diversas e avisos depois de serem abertos, o que "suja" o terminal, mas sem comprometer o que você está fazendo. Se isto te incomodar, você pode adicionar um "&>/dev/null" ao comando, o que descarta todas as mensagens, como em "konqueror /etc & &>/dev/null".
startx: Serve para abrir a interface gráfica a partir do prompt, caso você tenha escolhido inicializar o sistema em modo texto.
Histórico: O terminal mantém um histórico dos últimos 500 comandos digitados. Para repetir um comando recente, simplesmente pressione as setas para cima ou para baixo até encontrá-lo. Para fazer uma busca use o comando "history | grep comando" , como em "history | grep cp" para mostrar todas as entradas onde foi usado o comando "cp".
Ponto e vírgula: Você também pode executar uma fila de comandos de uma vez. Basta separá-los por ponto e vírgula, como em "ls; pwd" ou "cd /mnt/arquivos; ls"
Lembre-se de que no Linux o terminal distingue entre letras maiúsculas e minúsculas. "ls" é diferente de "LS". Quando criar novos arquivos e pastas, prefira usar nomes em minúsculas, assim você evita confusão.
Desligando: Assim como no Windows, você precisa desligar o sistema corretamente para evitar perda de arquivos e corrompimentos diversos na estrutura da partição. Além das opções nos menus do KDE ou Gnome, você pode desligar via terminal, usando os comandos abaixo. Não se esqueça que todos eles precisam ser executados como root. Use primeiro o comando su ou o sudo:
reboot: Reinicia o micro.
halt: Desliga o micro.
shutdown -h now: Também serve para desligar o sistema, mas permite que você especifique um horário. É muito útil se você deixar o micro ligado à noite fazendo alguma coisa ou baixando um arquivo, mas quiser que ele desligue sozinho depois de um certo tempo. Substitua now (agora) por um tempo em minutos que o sistema esperará antes de desligar, usando o parâmetro "+" como em shutdown -h +60. Você pode ainda especificar um horário, no formato hh:mm como em shutdown -h +06:00 (para desligar às 6:00 da manhã).
Ctrl+Alt+Del: Este é um atalho de teclado que, dado no terminal de texto, serve para reiniciar o micro. Não tem tanta utilidade quanto no Windows, mas é mais rápido que fazer o login e rodar o comando "reboot" ;).
EDITANDO OS ARQUIVOS DE CONFIGURAÇAO
Complementando os comandos de terminal, existem os arquivos de configuração. Ao contrário do Windows, onde as configurações são salvas numa caixa preta, o registro, difícil de entender e ainda mais de editar, no Linux as configurações são salvas sempre dentro de arquivos de texto, na maior parte das vezes legíveis, que você pode editar manualmente quando necessário.
Na verdade, a maioria dos programas de configuração nada mais são do que assistentes que facilitam a configuração destes arquivos. O programa lhe mostra as opções de uma forma amigável, mas na hora de salvá-las eles simplesmente reescrevem os arquivos correspondentes. Eu tenho uma certa experiência no desenvolvimento destes utilitários, pois ao longo dos anos desenvolvi muitos deles para incluir no Kurumin, mas, para não alongar muito, vou me limitar a dar uma visão geral sobre os principais arquivos de configuração do sistema.
Não é realmente necessário que você estude cada um destes arquivos (a menos que você esteja estudando para alguma prova de certificação), mas é importante ter pelo menos uma idéia geral sobre a função de cada um, pois ao pesquisar sobre instalação de drivers e programas, pesquisar soluções para problemas diversos, ou mesmo receber ajuda de alguém através dos fóruns, você vai ver muitas referências a arquivos de configuração diversos. Eles são o denominador comum entre as diversas distribuições, por isso a única forma de escrever algum artigo ou howto explicando sobre como instalar um driver de um modem ou placa wireless, por exemplo, em diversas distribuições diferentes, é explicar o caminho das pedras através dos arquivos de configuração, que é justamente a abordagem que a maioria dos autores acaba adotando.
Ou seja, gostando ou não, muitas vezes você precisará editar algum arquivo de configuração, ou talvez prefira fazer isso algumas vezes para ganhar tempo ou para ter acesso a opções que não estejam disponíveis nos utilitários de configuração.
Para editar os arquivos, você precisará apenas de um editor de textos. Existem vários exemplos: você pode por exemplo usar o kedit ou o kwrite no KDE, o gedit no Gnome, ou o mcedit, joe, nano ou mesmo o antigo e pouco amigável vi, caso esteja em modo texto.
Lembre-se de que em qualquer um deles você pode abrir o editor diretamente no arquivo que quiser editar, como em "mcedit /etc/fstab".
Tanto o kedit quanto o gedit são editores relativamente simples, que lembram até certo ponto o notepad do Windows. O kwite já é um editor mais avançado, voltado para quem escreve scripts ou mesmo programa em linguagens diversas. Ele é capaz de realçar a sintaxe de várias linguagens, diferenciando os comandos, condicionais, comentários, etc., através de cores. Isso ajuda muito a entender o código e permite identificar erros muito mais rápido.
Nos editores de modo texto as coisas são um pouco mais complicadas, já que eles são controlados através de atalhos de teclado, mas você acaba precisando deles para resolver problemas em situações onde o modo gráfico não está mais abrindo, ou ao usar outras máquinas remotamente, via SSH.
O mais simples é o mcedit. Ele faz parte do pacote "mc", que é encontrado em todas as distribuições. Se ele não estiver instalado, você resolve o problema instalando o pacote. Nele, as funções são acessadas usando as teclas F1 a F10, com uma legenda mostrada na parte inferior da tela. Para salvar você pressiona F2 e para sair, F10.
O joe é um meio termo. Ele é muito parecido com o antigo Wordstar do DOS e usa as mesmas teclas de atalho que ele. Para salvar o arquivo e sair, você pressiona Ctrl+K e depois X. Para salvar e sair no nano, pressione Ctrl+X, depois S e Enter.
Finalmente, temos o vi, que por algum motivo conquistou um grupo de usuários fiéis ao longo de seus quase 30 anos de vida e, graças eles, continua vivo até hoje, muito embora seja um dos editores menos amigáveis.
O vi tem três modos de operação: comando, edição e o modo ex. Ao abrir o programa, você estará em modo de comando; para começar a editar o texto, pressione a tecla "i". A partir daí, ele funciona como um editor de textos normal, onde o Enter insere uma nova linha, as setas movem o cursor, etc.
Quando terminar de editar o arquivo, pressione Esc para voltar ao modo de comando e em seguida "ZZ" (dois Z maiúsculos) para salvar o arquivo e sair. Para sair sem salvar pressione Esc e digite ":q!" (exatamente como aqui, dois pontos, quê, exclamação, seguido de Enter). Uma segunda opção para salvar e sair é pressionar Esc seguido de ":wq". Para apenas salvar, sem sair, pressione Esc seguido de ":w" e para sair sem salvar use o Esc seguido de ":q!".
Resumindo, o Esc faz com que o vi volte ao modo de comando, o ":" nos coloca no modo ex, onde podemos salvar e fechar, entre outras funções. O "q" fecha o programa, o "w" salva o arquivo e o "!" é uma confirmação.
Embora não seja exatamente pequeno (se comparado a editores mais simples, como o joe ou o nano), muito menos fácil de usar, o vi é praticamente o único editor que pode ser encontrado em qualquer distribuição. Em muitos casos é usado o elvis, uma versão simplificada, mas que funciona mais ou menos da mesma forma. O pequeno grupo de usuários forma um bando bem organizado, que urra, balança os galhos das árvores e atira cocos nas cabeças dos desenvolvedores, sempre que uma distribuição se atreve a removê-lo :-P.
Ao sair do editor, volta para o terminal. Você pode verificar se o arquivo realmente foi salvo corretamente usando o cat, como em "cat /etc/fstab". No caso de arquivos longos, acrescente "| more", que permite ler uma página de cada vez, como em "cat /var/log/syslog | more".
Alguns arquivos particularmente importantes são:
/etc/fstab: Aqui vai uma lista das partições que são acessadas pelo sistema, onde cada uma é montada e quais delas são montadas automaticamente na hora do boot. Além das partições, o fstab pode ser usado também para incluir CD-ROMs e até mesmo compartilhamentos de rede.
/etc/modules: Neste arquivo vão módulos que são carregados durante o boot. Em geral, usamos este arquivo para ativar o carregamento de módulos para placas wireless, modems e placas de som que não foram instalados manualmente, ou que não foram detectados automaticamente durante a instalação. Você vai ver muitas referências a este arquivo em tutoriais falando sobre a instalação de drivers diversos.
/etc/lilo.conf: O lilo é o gerenciador de boot, responsável por carregar o sistema. O lilo pode ser configurado para carregar diversos sistemas operacionais diferentes, onde você escolhe qual usar na hora do boot. Você pode fazer dual-boot entre Linux e Windows, ou até mesmo instalar diversas distribuições diferentes no mesmo HD. Sempre que fizer alterações no arquivo, rode o comando "lilo" (como root) para salvar as alterações.
/boot/grub/menu.lst: Muitas distribuições adotam o grub como gerenciador de boot ao invés de usar o lilo. No caso do grub, as alterações no arquivo são aplicadas automaticamente.
/etc/X11/xorg.conf: Este é o arquivo onde vai a configuração do vídeo, que inclui o driver usado, resolução, taxa de atualização e configuração de cores do monitor, além da configuração do mouse. Hoje em dia, praticamente todas as distribuições (com exceção do Slackware) são capazes de configurar o vídeo corretamente durante a instalação, mas você pode manter uma cópia do arquivo à mão para poder restaurar a configuração do vídeo em caso de problemas. Você pode também usar o arquivo gerado em outras distribuições.
O xorg.conf é usado pelo X.org, que é a versão atual do servidor gráfico. Distribuições antigas usam o Xfree, que armazena as configurações num arquivo diferente, o "/etc/X11/XF86Config-4".
/etc/passwd, /etc/shadow e /etc/group: Estes arquivos armazenam a base de dados dos usuários, senhas e grupos do sistema. Naturalmente, você não precisa se preocupar em alterá-los, pois eles são modificados automaticamente pelo adduser, users-admin e outras ferramentas, mas é interessante saber que eles existem. Você pode ver o conteúdo dos três apenas como root.
O "/etc/passwd" guarda os logins e outras informações sobre ou usuários. Você notará que além do root e dos usuários que adicionou, existem vários usuários de sistema, como o cupsys, proxy, sys, etc. Estes usuários são usados internamente pelos programas, você não pode fazer login através dele. Esta prática de ter usuários separados para cada programa aumenta bastante a segurança do sistema. Apesar do nome, o "/etc/passwd" não armazena as senhas, elas vão no arquivo "/etc/shadow" num formato encriptado.


CRIANDO LINKS


O comando ln permite criar links. Existem dois tipos de links suportados pelo Linux, os hard links e os links simbólicos. Os links simbólicos têm uma função parecida com os atalhos do Windows: eles apontam para um arquivo, mas se o arquivo é movido para outro diretório, o link fica quebrado. Os hard links por sua vez são semelhantes aos atalhos do OS/2 da IBM, eles são mais intimamente ligados ao arquivo e são alterados junto com ele. Se o arquivo muda de lugar, o link é automaticamente atualizado. Isto é possível porque nos sistemas de arquivos usados pelo Linux cada arquivo possui um código de identificação (chamado de inode), que nunca muda. O sistema sabe que o arquivo renomeado é o mesmo do atalho simplesmente procurando-o pelo inode ao invés do nome.
O comando ln dado sem argumentos cria um hard link, como em:
$ ln /home/morimoto/arquivo.txt arquivo
Onde será criado um link chamado "arquivo" no diretório corrente, que apontará para o arquivo.txt dentro do diretório /home/morimoto.
Para criar um link simbólico, acrescente o argumento "-s", como em:
$ ln -s /home/morimoto/arquivo.txt arquivo
Você pode criar tanto links apontando para arquivos, quanto links apontando para diretórios. Por exemplo, se você acha muito trabalhoso acessar o CD-ROM através do diretório /mnt/cdrom, você pode simplesmente criar um link para ele dentro do seu diretório de usuário, ou onde você quiser. Ao clicar sobre o link no gerenciador de arquivos, você acessará o CD-ROM.
Para criar um link chamado "CD" dentro do seu diretório de usuário apontando para o CD-ROM, o comando seria:
$ ln -s /mnt/cdrom ~/CD
O interpretador de comandos se encarregará de substituir automaticamente o "~" pela localização correta da sua pasta de usuário, não importa qual seja.
Você pode ainda criar links que funcionarão em qualquer parte do sistema. Por exemplo, imagine que você armazene seus arquivos de trabalho na pasta /home/seu_nome/trabalho/arquivos. Ao invés de digitar o caminho completo, você poderia criar um link simbólico "arquivos" que poderia ser acessado a partir de qualquer pasta do sistema. Para isto, basta acessar o diretório "/usr/bin" e criar o link por lá, usando os comandos:
$ cd /usr/bin
$ ln -s /home/seu_nome/trabalho/arquivos arquivos
Você verá muitos links espalhados pela estrutura de diretórios do Linux, um recurso muito usado quando os arquivos de sistemas mudam de lugar numa nova versão. Mantendo um link na localização antiga, todos os programas antigos continuam funcionando sem problemas.


FECHANDO PROGRAMAS TRAVADOS


Apesar do Kernel do Linux ser extremamente estável, quase impossível de travar, os programas nem sempre são. Para complicar, o rápido desenvolvimento do sistema e a necessidade por novos aplicativos acabam fazendo com que muitas vezes as distribuições tragam programas ainda em estágio beta, ou mesmo alpha, que ainda não estão completamente estáveis. Isto acaba muitas vezes resultando em travamentos. A vantagem do Linux neste ponto é que você quase nunca precisará reiniciar todo o sistema, basta matar o aplicativo problemático, ou, no pior dos casos, reiniciar o ambiente gráfico.
A forma mais prática de finalizar aplicativos é usar o xkill. Ao clicar sobre o ícone do programa, ou chamá-lo pelo terminal (digitando xkill), o cursor do mouse vira um ícone de caveira e basta clicar sobre o programa travado para matá-lo sem dó. Você pode também chamar o xkill usando o atalho "Ctrl+Alt+ESC.
Se a coisa for séria e o mouse parar de responder, você pode reiniciar o X, o que reabre toda a parte gráfica, pressionando "Ctrl+Alt+Backspace". Embora você possa perder arquivos não salvos, esta é uma solução muito menos radical (e mais rápida) do que reiniciar o micro no botão.
Embora mais trabalhoso, você pode também finalizar os programas através do terminal, usando os comandos kill e killall. O killall pode ser usado sempre que você souber o comando que inicializa o programa a ser fechado. Por exemplo, para fechar o xmms, o mesmo do screenshot acima, bastaria escrever "killall xmms"; para finalizar o konqueror o comando seria "killall konqueror", e assim por diante.
O problema com o killall é que em muitos casos o comando para fechar o programa não é o mesmo que seu nome. Para fechar o Firefox, por exemplo, você teria que digitar "killall firefox-bin" e não apenas "killall firefox", que seria o mais lógico.
Para os casos onde você não souber o nome do programa, existe o comando "ps" que mostra todos os processos abertos. Existem várias opções para este comando. A que costumo usar mais freqüentemente é "ps -x | more", que mostra todos os processos iniciados por você, sempre dando uma pausa quando esta encher a tela:
Na coluna direita da lista você verá os nomes dos aplicativos. Veja que em muitos casos o mesmo programa aparece várias vezes, seja porque você abriu várias instâncias do programa, seja por ele realmente ser dividido em vários processos diferentes, mas o killall se encarrega de acabar com todos os vestígios.
Na coluna da esquerda está o PID de cada processo, um número de identificação que pode ser usado em conjunto com o comando kill para matar um processo específico, como em "kill 4060".
Além do ps -x, você pode tentar o "ps -aux", que inclui todos os processos ativos. A lista é sempre longa, pois inclui todos os serviços e componentes do sistema que são carregados automaticamente durante o boot. Outro programa de texto com a mesma função é o pstree. Ele mostra os processos na forma de uma árvore, permitindo que você veja como eles se relacionam.
Se você estiver no KDE, pode gerenciar os processos de uma forma muito mais amigável usando o Ksysguard. Basta procurar por ele no iniciar ou pressionar "Ctrl+Esc" para abri-lo:
MONTANDO E DESMONTANDO
Embora cada vez mais as distribuições detectem as partições, CD-ROMs, pendrives e outros dispositivos automaticamente, criando ícones no desktop ou algo similar, por baixo dos panos é sempre necessário montar os dispositivos antes de acessá-los. Isto é feito automaticamente quando você clica no ícone do CD-ROM no desktop, por exemplo, mas, dependendo da distribuição que resolver usar, você acabará precisando fazer isso manualmente em muitos casos. Vamos então entender como esse processo funciona.
Cada dispositivo ou partição é acessado pelo sistema através de um device, um arquivo especial criado dentro do diretório "/dev". Para entender a ordem usada para nomear estes dispositivos é preciso usar algumas noções de hardware.
Na placa-mãe você encontra duas portas IDE (primária e secundária), que são usadas para instalar o HD e CD-ROM. Cada uma das duas permite conectar dois dispositivos, de forma que podemos instalar um total de 4 HDs ou CD-ROMs na mesma placa. Os drives IDE "tradicionais", que usam os cabos de 40 ou 80 vias são chamados de "PATA", de "parallel ATA".
Cada par de drives é instalado na mesma porta. Para diferenciar os dois é usado um jumper, que permite configurar cada drive como master (mestre) ou slave. O mais comum é usarmos apenas um HD e mais um CD-ROM ou DVD, cada um instalado em sua própria porta e ambos configurados como master. Ao adicionar um segundo HD, você poderia escolher entre instalar na primeira ou segunda porta IDE, mas de qualquer forma precisaria configurá-lo como slave, mudando a posição do jumper. Independentemente de ser um HD, CD-ROM ou qualquer outro tipo de dispositivo, os drives são detectados pelo sistema da seguinte forma:
IDE primária, master: /dev/hda
IDE primária, slave: /dev/hdb
IDE secundária, master: /dev/hdc
IDE secundária, slave: /dev/hdd
Os HDs Serial ATA (SATA) são vistos pelo sistema da mesma forma que HDs SCSI. Isso também se aplica a pendrives e outros dispositivos USB. Aqui entra uma história interessante: como o código é aberto, é muito comum que novos módulos sejam baseados ou utilizem código de outros módulos já existentes. O suporte a drives SCSI no Kernel é tão bom que ele passou a ser usado (com pequenas adaptações) para dar suporte a outros tipos de dispositivos. Na época do Kernel 2.4, até os gravadores de CD eram vistos pelo sistema como drives SCSI.
O primeiro dispositivo SCSI é detectado como "/dev/sda", o segundo como "/dev/sdb" e assim por diante. Se você tiver um HD SATA ou pendrive, o drive é visto como "/dev/sda" e não como "/dev/hda", como seria se fosse um drive IDE.
Se você tiver um HD SATA e um pendrive, instalados na mesma máquina, então o HD será visto como "/dev/sda" (pois é inicializado primeiro, logo no início do boot) e o pendrive como "/dev/sdb". Se você plugar um segundo pendrive, ele será visto como "/dev/sdc", e assim por diante. Ao contrário dos dispositivos IDE, os devices são definidos seqüencialmente, conforme o sistema vai detectando os dispositivos. Quem chega primeiro leva.
Se você tiver um HD IDE e um pendrive, então o HD será visto como "/dev/hda" e o pendrive como "/dev/sda". Uma observação é que você quase sempre encontrará uma opção dentro do Setup que permite colocar as portas SATA em modo de compatibilidade (Legacy Mode ou Compatibility Mode, dependendo da placa). Ao ativar esta opção, seu HD SATA passará a ser visto pelo sistema como " /dev/hda', como se fosse um HD IDE normal. Esta opção é útil ao instalar distribuições antigas, que ainda não oferecem um bom suporte a HDs SATA.
Em seguida vem a questão das partições. Ao invés de ser um espaço único e indivisível, um HD é como uma grande sala comercial, que pode ser dividida em vários escritórios e ambientes diferentes. Ao instalar o sistema operacional, você tem a chance de particionar o HD, onde é feita esta divisão. É sempre recomendável usar pelo menos duas partições separadas, uma para o sistema e outra para seus arquivos. Isto permite reinstalar o sistema sempre que necessário, sem perder seus arquivos e configurações.
No Linux existe ainda a necessidade de criar uma partição separada para a memória swap. Esta partição utiliza uma organização própria, otimizada para a tarefa. Embora um pouco mais complicada, esta abordagem faz com que o acesso seja mais rápido que no Windows, onde o swap é feito dentro de um arquivo, criado na partição de instalação de sistema.
Existem diversos programas de particionamento, os mais usados no Linux são o cfdisk, gparted e o qtparted. Muitas distribuições incluem particionadores próprios, o Mandriva por exemplo inclui o diskdrake. Veremos mais detalhes sobre o particionamento e instalação do sistema no próximo capítulo.
Acima temos um screenshot do Gparted. Como pode ver, cada partição recebe um número e é vista pelo sistema como um dispositivo diferente. A primeira partição do "/dev/hda" é vista como "/dev/hda1" e assim por diante. O mesmo acontece com os pendrives, que do ponto de vista do sistema operacional são uma espécie de HD em miniatura.
O sistema nunca acessa os dados dentro da partição diretamente. Ao invés disso, ele permite que você "monte" a partição numa determinada pasta e acesse os arquivos dentro da partição através dela, o que é feito usando o comando "mount".
A sintaxe básica inclui o dispositivo e a pasta onde ele será acessado, como em:
# mount /dev/hda2 /mnt/hda2
O mais comum é que as partições "extras" sejam montadas dentro da pasta "/mnt", que é própria para a tarefa, mas isso não é uma regra; você pode montar as partições em qualquer pasta vazia. Não se esqueça de criar a pasta desejada, se necessário, usando o comando "mkdir".
No caso do CD-ROM, citamos apenas o dispositivo, sem incluir a partição (já que um CD-ROM não pode ser particionado, como um HD). Você pode tanto usar o dispositivo correto, como "/dev/hdc" ou "/dev/hdd", quanto usar o "/dev/cdrom", um link que é criado durante a instalação:
# mount /dev/cdrom /mnt/cdrom
Se quiser trocar o CD que está na bandeja, você deve primeiro "desmontar" o CD-ROM, com o comando "umount /mnt/cdrom". O mesmo se aplica a pendrives e HDs externos: é sempre necessário desmontar antes de desplugá-los. No caso dos pendrives e HDs, desmontar é fundamental, pois as alterações não são necessariamente salvas imediatamente por causa do cache de disco. Removendo sem desmontar, existe uma probabilidade muito grande das últimas alterações serem perdidas. É muito comum as pessoas gravarem arquivos no pendrive, desplugarem logo depois (sem desmontar) e, ao tentar usar de novo, verem que os arquivos simplesmente não foram gravados.
Se por acaso você tiver um drive de disquetes (em que século você vive? :), o comando para montá-lo manualmente é "mount /dev/fd0 /mnt/floppy" e, para desmontar, "umount /mnt/floppy". Assim como no caso dos pendrives, é importante desmontar antes de remover o disquete do drive.
Os pontos de montagem, ou seja, as pastas onde as partições serão montadas podem ser configurados através do arquivo "/etc/fstab". Quase sempre, este arquivo é configurado durante a instalação, incluindo referências a todas as partições e CD-ROMs disponíveis, de forma que você pode montar as partições digitando apenas "mount /mnt/hda6" (por exemplo), sem precisar usar o comando completo.
Naturalmente, além da forma manual, existem maneiras mais práticas de acessar o CD-ROM e partições. Em primeiro lugar, ao usar o KDE, você pode sempre usar o ícone no desktop, clicando sobre ele para montar e usando a opção "desmontar" (que aparece ao clicar com o botão direito sobre o ícone) para liberar o CD na hora de remover. Na maioria das distribuições, ao plugar um pendrive é criado automaticamente um ícone no desktop para acessar os arquivos. Geralmente o ícone inclui uma opção para desmontar, acessível ao clicar sobre ele com o botão direito.
Ainda no KDE, você pode acessar as demais partições do HD abrindo o Konqueror e acessando a url "media:/" (ou "devices:/", nas versões antigas). Assim como no caso do CD-ROM, você acessa os arquivos clicando sobre o ícone. No caso das partições do HD, não é necessário desmontar depois de usar, pois elas são desmontadas ao desligar o micro.
Muitas distribuições incluem o automount, que faz com que o acesso ao CD-ROM e disquete seja transparente, como no Windows. Você coloca o CD-ROM na bandeja. Ao acessar a pasta "/mnt/cdrom" o sistema se encarrega de montá-lo automaticamente. Quando você pressiona o botão para ejetar o CD, o sinal é interceptado pelo sistema que se encarrega de desmontá-lo e em seguida ejetar o CD.


O CLIPBOARD E O TERCEIRO BOTAO


O botão central do mouse, que não tem muita serventia no Windows, permite copiar e colar entre aplicativos ou até mesmo entre aplicativos gráficos e terminais abertos dentro da interface gráfica. Isso substitui o Ctrl+C, Ctrl+V, com a vantagem do comando ser dado com um único clique do mouse. Basta selecionar o trecho de texto, a imagem, ou o que quiser copiar numa janela e clicar com o botão central na janela onde quiser colar a seleção. Se você não tiver um mouse de três botões, pressione simultaneamente os dois botões.
Porém, este modo "padrão" tem algumas deficiências. Ele não funciona muito bem para copiar grandes quantidades de texto, e o texto a ser copiado precisa ficar selecionado durante a operação. Basicamente, você consegue copiar o que puder ser visualizado na tela. Não funciona para copiar 120 páginas de texto do Abiword para o OpenOffice, por exemplo.
Pensando nisso, os desenvolvedores do KDE e do Gnome se preocuparam em incluir sistemas de copiar e colar com um funcionamento semelhante ao do Windows. Você pode selecionar várias páginas de texto do Kword e colar no Kmail, por exemplo, usando o bom e velho Ctrl+C, Ctrl+V.
O KDE inclui até um Applet, o Klipper (que no Kurumin e em outras distribuições baseadas no Debian pode ser instalado com o comando "apt-get install klipper"), que multiplica a área de transferência. Você tem vários slots que armazenam todas as últimas operações e pode colar qualquer uma das anteriores, selecionando a desejada através do ícone ao lado do relógio, de forma bem prática.

TRABALHANDO COM PERMISSOES


Apesar de toda a evolução em relação aos antigos sistemas Unix, usados nas décadas de 70 e 80, o Linux mantém suas raízes multiusuário. Isso significa que o sistema pode ser usado por várias pessoas simultaneamente (imagine o caso de um servidor de rede), sem que uma atrapalhe o trabalho da outra, nem possa ver e alterar arquivos que não deveria.
Para isso, é usado um sistema de permissões simples, porém eficiente, que consiste num conjunto de três permissões de acesso (ler, gravar e executar) e três grupos (dono, grupo e outros), que combinadas permitem fazer muita coisa. Este sistema de permissões é bem similar ao usado do Windows 2000 e no Windows XP, a principal diferença é que no Windows você usa o sistema como administrador (equivalente ao root) por padrão e muitos programas não funcionam corretamente quando você tenta usar uma conta sem privilégios especiais. No Linux é o contrário, você usa o sistema com um login de usuário e os programas são projetados para funcionar desta forma. Apenas os utilitários de configuração e alguns programas para tarefas específicas precisam ser executados como root. Isso faz com que o sistema seja fundamentalmente mais seguro.
Um argumento comum é que não existem muitos vírus, worms e trojans para Linux porque o sistema é menos popular. Porém, nos servidores, o Linux já é mais usado que o Windows e mesmo assim os casos de problemas de segurança continuam sendo mais raros. Segundo a Netcraft, quase 70% dos sites da internet rodam sobre o Apache, a grande maioria deles sobre o Linux, enquanto apenas 20% rodam sobre o IIS da Microsoft. Mas, mesmo assim, é muito mais comum termos notícias de problemas de segurança no IIS do que no Apache:
Voltando às permissões, clicando sobre as propriedades de qualquer arquivo no Konqueror você verá uma janela com três menus de seleção, que permitem ajustar individualmente as permissões para o dono do arquivo, para usuários que façam parte do mesmo grupo e para os outros, que inclui todo mundo que tenha acesso ao sistema.
Cada um dos campos aceita três possibilidades: "negado", "pode ler" e "pode ler e escrever". Por default, o dono é o único que pode ler e escrever, os demais (grupo e outros) podem apenas ler o arquivo, mas sem modificar.
No caso dos arquivos, existe uma quarta permissão que é o campo "É executável". Esta é uma daquelas diferenças fundamentais entre o Linux e o Windows: o sistema não decide quais arquivos são programas pela extensão, mas sim pelas permissões. Isso aumenta bastante a segurança do sistema, mas por outro lado causa um pouco de dor de cabeça em algumas situações. Sempre que você baixar um instalador qualquer via web (o driver da nVidia, por exemplo), vai precisar primeiro marcar o "É executável" nas propriedades do arquivo antes de conseguir instalá-lo.
O "dono" do arquivo é por default o usuário que criou o arquivo. Apenas este usuário pode alterar as permissões de acesso ao arquivo e pasta. Em seguida vem a configuração do grupo, que permite que vários usuários tenham acesso a um arquivo ou pasta, sem ter que apelar para o campo "outros" que daria acesso a qualquer um.
Imagine que estamos configurando um servidor em uma empresa importante, e neste servidor temos uma pasta chamada "projeto_apolo" com vários arquivos confidenciais que deverá ser acessada apenas pelos programadores que estão trabalhando no projeto.
Desativaríamos de imediato o campo "todos", mantendo marcados apenas os campos "usuário" e "grupo". O próximo passo seria justamente criar um novo grupo de usuários ("apolo", por exemplo) e incluir neste grupo todos os usuários que fazem parte do projeto. A partir daí, todos os programadores passariam a ter acesso à pasta, já que fazem parte do grupo.
Você pode criar novos grupos e adicionar usuários a eles através do "users-admin" ou do "kuser", usando o que estiver disponível na distribuição. Basta chamá-los pelo terminal ou procurar pelo atalho no menu.
No Fedora, o users-admin se chama "system-config-users", e, no Mandriva, "userdrake". O Kuser é usado em um número menor de distribuições, mas é também bastante usado.
Para criar um novo grupo, clique em "Grupo > Adicionar grupo". Na janela que será aberta, especifique o nome do grupo e os usuários que farão parte dele. Um mesmo usuário pode fazer parte de vários grupos simultaneamente. Muita gente cria um grupo diferente para cada pasta importante, de forma a poder definir individualmente quem terá acesso a ela.
Você notará que nesta tela aparecem vários usuários que não são mostrados na tela principal, como o "bin", "daemon" e "mail". Estes são usuários ocultos do sistema, contas sem privilégios e que não possuem senhas definidas (é simplesmente impossível fazer login com qualquer uma delas), que são usadas para isolar os programas, fazendo com que cada um tenha acesso apenas a seus próprios arquivos. Isso limita muito os danos que um programa ou servidor com bugs ou falhas de segurança pode causar quando alguma coisa dá errado.
De fato, a configuração default da maior parte das distribuições Linux atuais é dar acesso de leitura para a maioria das pastas (com exceção, naturalmente, dos arquivos de senha e outros arquivos críticos) para todos os usuários, mas ao mesmo tempo dar acesso de gravação apenas para o diretório home de cada um.
Ou seja, por default você, logado como usuário normal, poderá navegar por quase todos os diretórios do sistema, mas só poderá criar e alterar arquivos dentro da sua pasta de usuário. Nos outros lugares receberá sempre um aviso de acesso negado. Isso impede que os usuários possam fazer besteira no sistema, como por exemplo, tentar deletar a pasta de módulos do Kernel ;-).
Claro, como todas as regras, as permissões de acesso têm sua exceção: o root. Ele é o único que não possui restrições: pode alterar, executar ou deletar o que bem entender. Pode alterar o dono das pastas ou alterar as permissões de acesso. O root é o deus do sistema.
Você precisará usar o root sempre que for alterar as permissões de acesso a uma pasta do sistema ou criada por outro usuário, mas não use-o regularmente, a menos que esteja apenas brincando com o sistema e possa reinstalá-lo a qualquer momento, pois além de poder destruir facilmente arquivos do sistema, usar o root abre as portas para várias brechas de segurança ao usar programas de IRC, abrir anexos em e-mails ou mesmo navegar na web.
A maioria dos problemas de segurança a que os usuários do Windows estão submetidos decorre justamente do fato de utilizarem contas com privilégios equivalentes ao do root no Linux. Se você pode fazer o que quiser no sistema, os programas executados por você (incluindo trojans, scripts incluídos de páginas web executados pelo navegador, etc.) também poderão não ter restrições.
Se você se pergunta como alguns vírus do Windows, como o Ninda e o Sircan podem se espalhar tão rapidamente, saiba que o problema é justamente este: a combinação de um sistema com um fraco controle de segurança, combinado com o uso de contas administrativas por usuários sem noções de segurança.
Voltando ao tema da criação de usuários, se você não gostou dos utilitários gráficos, pode adicionar novos usuários também usando os comandos "adduser" e "passwd" (como root). Por exemplo:
# adduser manuel
(cria o usuário manuel, já definindo a senha)
# passwd manuel
(altera a senha posteriormente)
Para remover um usuário anteriormente criado, utilize o comando "userdel", como em "userdel manuel". Por questões de segurança o comando remove apenas o login, preservando o diretório home do usuário. Caso você tenha certeza que não vá mais precisar de nada, deve deletar o diretório manualmente depois.
Você também pode bloquear temporariamente um usuário, um amigo que vem jogar Warcraft 3 com você apenas nos fins de semana, por exemplo, e não precisa ficar com o login ativo no resto do tempo. Neste caso, use o comando "passwd -l usuário" para bloquear o login e "passwd -u usuário" para desbloqueá-lo.
Para alterar as permissões de acesso de arquivos e pastas via linha de comando, você deve usar o comando chmod. A sintaxe dele parece um pouco complicada à primeira vista, mas nada que um pouco de prática não possa resolver:
# chmod 744 arquivo
Temos aqui o comando chmod propriamente dito, o arquivo ou pasta que terá suas permissões de acesso alteradas e um número de três dígitos que indica as novas permissões para o arquivo. Note que o "744" é só um exemplo.
Os três números indicam respectivamente:
7: Permissões para o dono do arquivo.
4: Permissões para o grupo.
4: Permissões para os demais usuários.
Você deve lembrar que temos três permissões: leitura, gravação e execução. Como é possível representar estes três atributos através de um único número?
Bem, os programadores costumam ser muito bons em matemática e, como em outros casos, usaram um pequeno truque para resolver este problema. Cada permissão é representada por um número:
4: Ler.
2: Alterar o conteúdo, criar novos arquivos (no caso de uma pasta).
1: Execução (no caso dos arquivos) ou listar os arquivos (no caso das pastas).
Você simplesmente soma estes números para ter o número referente ao conjunto de permissões que deseja:
0: Sem permissão alguma. Se for uma pasta, o usuário sequer pode ver o conteúdo.
1: Permissão apenas para executar (não é possível ler o arquivo ou alterá-lo, apenas executar um programa). No caso de uma pasta, 1 permite que se liste os arquivos dentro dela, mas sem ler ou alterar os arquivos.
4: Apenas leitura.
5 (4+1): Ler e executar (no caso de um arquivo) ou ver os arquivos e abri-los, no caso de uma pasta.
6 (4+2): Leitura + gravação.
7 (4+2+1): Controle total: leitura + gravação + permissão para executar.
Uma observação importante é que ao configurar as permissões de acesso de uma pasta, você sempre deve usar 5 (4+1) ou 7 (4+2+1), pois, sem permissão para listar o conteúdo da pasta, você não consegue ver os arquivos dentro dela.
Engenhoso, não é? Se você quer dar controle total do arquivo ou pasta para o dono e para o grupo, mas permissão de apenas leitura para os demais usuários, usaria o número 774; se você quisesse que todos os usuários tivessem permissão de leitura e gravação, mas sem poder executar nada, usaria o número 666; se quisesse dar controle total para todo mundo, usaria 777 e assim por diante. Como disse, parece um pouco complicado, mas depois de usar o comando algumas vezes você não vai esquecer mais.
Para alterar o dono e o grupo do arquivo, você deve usar o comando chown. O uso dele é simples, basta indicar qual é o novo dono e em seguida indicar o arquivo ou pasta que mudará de dono, como em:
# chown manuel projeto_apollo/
Se você quiser que a alteração se aplique a todos os arquivos e subpastas do diretório, use a opção -R (de recursivo) como em:
# chown -R manuel projeto_apolo/
Se você quiser alterar também o nome do grupo, acrescente o nome do novo grupo após o nome do dono, separando ambos por um ponto:
# chown -R manuel.apolo projeto_apolo/
Agora a pasta "projeto_apolo" passa a ser propriedade do usuário manuel e do grupo apolo. Fizemos a mesma coisa que no exemplo anterior, mas agora usando o comando de modo texto. Você escolhe qual forma prefere.

RODANDO PROGRAMAS COMO ROOT

No Linux, o usuário root é o deus do sistema, o único que tem acesso a todos os arquivos e configurações. Os usuários normais têm acesso apenas a seus arquivos dentro do diretório /home e outros para os quais você alterar as permissões manualmente.
Todos os programas salvam suas configurações dentro de pastas ocultas (o nome começa com ponto, como em ".kde"), dentro do home do seu usuário. Isso faz com que cada usuário tenha suas configurações separadas, sem que possa interferir com as configurações de outros ou alterar as configurações padrão do sistema.
Isso torna o sistema bastante seguro contra barbeiragens em geral feitas pelos usuários. Como eles podem apenas alterar suas próprias configurações, na pior das hipóteses você pode deletar o usuário e criar outro. Você pode criar uma conta de usuário separada para cada pessoa que precisar user seu micro e ter certeza de que eles não destruirão a instalação do sistema e seus arquivos.
Nas versões recentes do KDE, existe uma opção interessante, que permite abrir uma segunda seção do X, onde é possível se logar com um usuário diferente. Para usar esse recurso, clique no "Iniciar > Trocar de Usuário > Bloquear a atual & Iniciar nova sessão".
Como vimos no tópico sobre comandos, é possível também executar programas como root, usando o comando "su" e suas variantes.
Num terminal de texto, digite simplesmente "su" e forneça a senha de root. O símbolo do terminal muda de um "$" para um "#", indicando que a partir daí, todos os comandos digitados (apenas nesse terminal específico) serão executados como root. Use isso sempre que precisar editar arquivos do sistema, mover arquivos ou mudar permissões, criar novos usuários, etc.
Para abrir os programas gráficos, a melhor opção é usar o "kdesu", que exibe um prompt de senha gráfico e ajusta todas as permissões e variáveis do sistema de forma que o programa possa rodar sem sobressaltos.
Use o kdesu num terminal, ou usando o "Executar comando" do KDE (alt+F2), seguido do comando que será executado como root, como em "kdesu konqueror /etc", o que abrirá uma janela do Konqueror, como root e já mostrando os arquivos do diretório "/etc".
Muitas distribuições, como o Kurumin e o Ubuntu, usam o "sudo" como uma forma de facilitar o uso do sistema. O sudo é uma variante do su, que permite criar usuários "administrativos", que podem executar comandos como root, sem precisar fornecer a senha.
No Kurumin, o usuário padrão, "kurumin", vem configurado com permissão para executar qualquer comando como root, sem precisar fornecer a senha. Isso permite que os painéis e scripts de configuração funcionem diretamente, sem que você precise ficar fornecendo a senha de root toda hora, o que facilita sobretudo ao rodar do CD. Basta adicionar o "sudo" antes do comando, como em "sudo konqueror /etc".
O Ubuntu usa uma abordagem mais conservadora, confirmando sua senha de usuário antes de executar o comando, mas em ambos os casos a configuração de quais usuários podem usar o sudo vai no arquivo "/etc/sudoers".
A idéia é que você configure o sistema e instale todos os programas desejados e depois, se desejar, desative o sudo ou crie um novo usuário sem privilégios para uso normal do sistema.
Para que um determinado usuário tenha permissão para usar o sudo e, conseqüentemente, instalar programas através dos ícones mágicos e alterar a configuração do sistema, adicione uma nova linha no arquivo /etc/sudoers:
usuario ALL=NOPASSWD: ALL
... substituindo o "usuário" pelo login desejado. Você pode também comentar a linha referente ao usuário kurumin para tirar seus superpoderes, ou simplesmente criar outro usuário com seu nome e passar a usá-lo no dia-a-dia, deixando para usar o user kurumin apenas quando precisar instalar novos programas ou alterar a configuração do sistema.


MAQUINAS VIRTUAIS


Quase tudo pode ser simulado via software. É possível até mesmo simular um computador de arquitetura diferente, para que os softwares escritos pare ele rodem da mesma forma que rodam dentro do seu sistema nativo.
Um dos exemplos mais conhecidos são os emuladores de videogames antigos, que permitem rodar jogos de Atari, Nintendo 8 bits, Mega-Drive, Super-Nes, Playstation e outros.
Assim como é possível emular um videogame para rodar os jogos escritos para ele, é possível simular um PC completo e rodar outros sistemas operacionais, dentro de uma janela. Isso permite que você rode o Windows dentro do Linux ou vice-versa. Esse PC "de mentira" é chamado de máquina virtual.
O sistema principal neste caso passa a ser chamado de host (hospedeiro) e o outro sistema operacional que está rodando dentro da máquina virtual é chamado de "guest" (convidado). Ele acha que tem um PC completo para si, enquanto na verdade está rodando dentro de uma "matrix", na máquina virtual.
Naturalmente, este trabalho de simular um PC completo e ainda por cima com um bom desempenho não é simples, veja o caso dos emuladores de videogame de uma forma geral, que sempre precisam de um PC muito mais poderoso do que o sistema original. É preciso um Pentium 200 para emular um Super Nes (que usa um processador de 3.5 MHz e 128 KB de RAM) com qualidade.
Existem atualmente três softwares que se destacam nesta categoria, o VMware, Qemu e o Xen, que trabalham de forma ligeiramente diferente, mas com grandes diferenças práticas.
O VMware usa um conceito de virtualização. Ele tenta sempre que possível converter os comandos usados pelo sistema dentro da máquina virtual em comandos que o sistema host entenda e execute diretamente. Por exemplo, se o Windows dentro da máquina virtual tenta tocar alguma coisa na placa de som, o VMware simplesmente pega os dados e toca na placa de som "real" do micro, como se fosse outro programa qualquer. O mesmo se aplica a todo tipo de instruções básicas, que são executadas diretamente pelo processador principal. O VMware interpreta e converte instruções o mínimo possível.
O Qemu por sua vez é um emulador. Ele tenta processar todas as instruções, o que acaba demorando mais tempo e fazendo com que a performance seja menor. Em geral o VMware (nas versões recentes) consegue fazer com que o sistema guest rode com 60 a 90% do desempenho que teria se estivesse rodando diretamente, enquanto o Qemu obtém de 5 a 10%. O Qemu possui um módulo adicional, o Kqemu, que faz com que ele passe a funcionar de forma mais similar ao VMware, virtualizando as instruções básicas do processador, ao invés de emular tudo. O Kqemu melhora consideravelmente o desempenho do Qemu, mas ainda assim o deixa bem atrás do VMware em questão de desempenho.
O Qemu é um projeto open-source, enquanto o VMware é comercial, disponível em duas versões. O VMware Workstation é a versão completa, um software relativamente caro (199 dólares), mas que pode ser usado por 30 dias. O VMware Player por sua vez é a versão gratuita, com bem menos funções, que pode ser usada para rodar máquinas virtuais criadas através do VMware Workstation, praticamente sem limitações, mas sem criar novas máquinas virtuais (VMs). A dica é que você pode obter a versão trial do VMware Workstation e usá-la para criar as máquinas virtuais e passar a usar o VMware Player depois que o trial expirar. Você pode baixar ambas no http://www.vmware.com. Baixe o pacote genérico, que pode ser instalado em várias distribuições.
No Kurumin (a partir do 5.1) você encontra o VMware Player e um script para criar e alterar as configurações das VMs, provendo uma solução completa.
Estas máquinas virtuais são extremamente úteis no dia-a-dia, pois permitem que você rode outros sistemas operacionais dentro de uma janela, tendo acesso a todos os softwares que precisa. Muita gente utiliza este recurso para manter uma cópia do Windows à mão para quando precisam de algum programa específico. Muitos micros (e quase todos os notebooks) vêm com uma licença do Windows de qualquer forma e esta é uma boa maneira de aproveitá-la sem sair do Linux.
Conforme o Qemu e VMware forem evoluindo e os micros forem ficando cada vez mais rápidos, a perda de desempenho por rodar o Windows dentro da máquina virtual será cada vez menos significativo, permitindo que você tenha uma forma confortável de continuar rodando seus aplicativos antigos mesmo depois de migrar definitivamente para o Linux.
Outra grande utilidade é que você pode testar outras distribuições e ter um sistema "sparing", onde você pode testar de tudo sem medo de danificar sua instalação principal. Todos os arquivos da máquina virtual são salvos num "disco virtual", que nada mais é do que um arquivo comum, dentro da pasta com a VM, formatado de uma forma especial. Este arquivo é usado de tal forma que o sistema dentro da VM realmente acha que está usando um HD real, particionando, formatando e tudo mais.
Tudo começa com a criação da máquina virtual, que consiste basicamente no arquivo com o disco virtual e um arquivo de configuração, salvos dentro da pasta escolhida. No VMware, o tamanho do disco virtual é apenas um limite. O arquivo começa vazio, ocupando apenas alguns kbytes e vai inchando conforme são instalados programas dentro da máquina virtual, ocupando sempre um espaço equivalente ao espaço ocupado pelo sistema instalado.
A instalação do sistema dentro da máquina virtual é feita de forma normal. Você vai particionar e formatar o "HD" e tudo mais, só que tudo vai sendo feito dentro do disco virtual, sem que o Windows dentro da máquina virtual tenha acesso direto aos demais arquivos no HD. Se ele pega um vírus, apenas o que está dentro do disco virtual é afetado. Na pior das hipóteses você pode deletar o arquivo e começar de novo. Para todos os efeitos, a VM funciona como um PC real; você pode até mesmo instalar Windows e Linux em dual boot, ou experimentar a instalação de várias distribuições Linux no mesmo HD.
O VMware e o Qemu são os mais usados nos desktops, mas existe uma terceira opção, muito popular nos servidores, o Xen.
O Xen utiliza uma idéia diferente, a paravirtualização, que consiste em dividir de forma transparente os recursos do hardware, permitindo que o sistema guest rode com uma redução de performance muito pequena (menos de 5%, na maioria dos casos). O maior problema é que para rodar dentro do Xen é necessário que o sistema guest seja modificado. Não é possível rodar qualquer sistema diretamente, como no caso do VMware e do Qemu.
Isto não é um grande problema no caso das distribuições Linux, mas é no caso do Windows e outros sistemas de código fechado.
O Xen é muito mais complicado de configurar que o VMware. No caso dos servidores (onde temos um público da área técnica) isto não chega a ser um grande problema, mas nos desktops ele é ainda pouco usado. Mesmo assim, é possível que o Xen evolua em termos de facilidade de uso e, graças ao bom desempenho, comece a disputar diretamente com o VMware. A página do Xen é a http://www.xensource.com/.


INSTALANDO O KURUMIN


A primeira diferença fundamental entre live-CDs, como o Kurumin e o Slax e distribuições "tradicionais", como o Mandriva, Fedora e Slackware, é a forma como o sistema é instalado.
Tradicionalmente, os CDs de instalação contém pacotes individuais de instalação dos programas junto com um programa de instalação. Durante a instalação, você pode escolher quais pacotes quer instalar e o instalador se encarrega de "montar" o sistema, instalando individualmente os pacotes marcados, como neste screenshot do instalador do Mandriva:
Esta abordagem permite um controle maior sobre o que será instalado, mas possui também algumas desvantagens:
-Torna a instalação mais complexa e confunde os usuários iniciantes (e muitas vezes também os avançados), já que pouca gente conhece a função de cada pacote e não sabe bem quais instalar. Nem sempre as descrições dos pacotes dão uma visão clara sobre sua função e importância. Para amenizar isso, os instaladores adotam um "meio termo", onde você inicialmente escolhe entre algumas categorias, como "Ferramentas de escritório", "Programação", "Servidores", etc., e acessa a tela de seleção manual de pacotes apenas se quiser personalizar a instalação.
-Aumenta muito o trabalho dos desenvolvedores, que precisam se preocupar em checar as dependências de cada pacote, etc. para manter a instalação consistente, independentemente do que o usuário escolher.
-Neste caso o sistema pode ser apenas instalado, não roda direto do CD.
Nos live-CDs temos um sistema "base", já configurado que roda diretamente do CD. O instalador limita-se a copiar este sistema para o HD e fazer as alterações necessárias para que ele se adapte ao novo ambiente.
A instalação no HD mantém as configurações feitas durante o boot. Por isso, primeiro teste o sistema rodando a partir do CD e certifique-se que o vídeo está corretamente configurado, as placas de som e rede estão funcionando, etc. antes de iniciar a instalação.
Neste livro abordo a instalação e configuração de três distribuições: Kurumin, Ubuntu e Slax.
Esta não é uma escolha aleatória. O Kurumin é um dos melhores exemplos de distribuição amigável, que automatiza vários aspectos do uso do sistema, por isso uma das melhores opções para começar. Por baixo dos scripts e painéis de configuração, você tem uma instalação do Debian, que permite que você aprenda sobre a estrutura do sistema, sem ter que encarar o próprio logo no começo.
O Slax é um live-CD derivado do Slackware, que mantém a mesma estrutura básica (incluindo os scripts de configuração e utilitários disponíveis no Slackware), mas roda do CD e é muito mais simples de instalar.
Finalmente, temos o Ubuntu, o "Debian para desktops", que é oferecido em duas versões: um CD de instalação tradicional, que utiliza um instalador muito similar ao encontrado no Debian e um live-CD, que você pode usar para conhecer o sistema e ver se seu PC é compatível antes de instalar. O Ubuntu também difere do Kurumin e o Slax por utilizar o Gnome por padrão ao invés do KDE.
Depois de abordar os conceitos gerais, vamos começar a abordar temas específicos dentro de cada distribuição e ver dicas sobre os programas e ferramentas de configuração disponíveis. Este terceiro capítulo é dedicado à instalação do Kurumin, incluindo o particionamento do HD, dual boot com o Windows e outras distribuições, uso do home em uma partição separada e solução de problemas. O quarto capítulo é dedicado à configuração do Kurumin e do KDE, abordando também vários fundamentos sobre a organização do sistema (das distribuições Linux de uma forma geral), configuração de redes e placas Wireless e assim por diante. O capítulo 5 é dedicado aos programas Linux de uma forma geral, sem se prender a uma única distribuição, enquanto o capítulo 6 volta a ser específico, falando sobre a instalação e configuração do Ubuntu (incluindo dicas sobre o Gnome) e do Slax.
Os temas são abordados com um nível crescente de complexidade, sem repetir assuntos já abordados. O particionamento do HD e configuração do Lilo, por exemplo, são abordados apenas no capítulo 3, junto com a instalação do Kurumin, sem ser repetida no capítulo do Ubuntu. O ideal é que você realmente leia os capítulos seqüencialmente e pratique instalando cada uma no seu no seu micro.
Se você não tem espaço suficiente no HD para criar várias partições, ou não quer arriscar seus arquivos mexendo no particionamento do HD (lembre-se: Só Jesus salva, o homem faz backup! ;), você pode ainda treinar usando o VMware Player, um virtualizador que permite instalar as distribuições dentro de máquinas virtuais, que abordo no capítulo 5. Embora no livro fale apenas sobre a versão Linux, o VMware também roda sobre o Windows XP ou 2000, com os mesmos recursos.
OPÇOES DE BOOT NO KURUMIN
Um dos principais atrativos do Kurumin e outros live-CDs é o fato do sistema rodar diretamente a partir do CD-ROM, sem necessidade de alterar o que está instalado do HD e detectar o hardware da máquina no boot, dando-lhe um desktop funcional em poucos minutos.
Mas, ao contrário do que pode parecer à primeira vista, detectar todo o hardware de uma máquina atual e configurar o sistema para trabalhar sobre ele sem ficar perguntando, não é uma tarefa nada fácil.
Algumas placas-mãe mal projetadas podem travar durante o processo de detecção do ACPI, SCSI ou RAID, pode ser que a placa de vídeo não tenha um driver específico, ou que use um código de identificação diferente do padrão, pode ser que o mouse tenha scroll ou outro recurso especial que não seja possível detectar automaticamente e assim por diante. Além disso, o sistema simplesmente não tem como adivinhar que resolução de tela e taxa de atualização que você prefere usar, pode no máximo tentar "adivinhar" baseado nas características do monitor.
Logo no início do boot você verá uma tela gráfica que apresenta algumas opções de boot. Estas opções permitem alterar o comportamento padrão do sistema, fazendo com que ele dê boot em placas problemáticas ou que utilize a resolução de vídeo de sua preferência, entre outras configurações, que podem ser usadas em casas onde o sistema de detecção não dê conta do recado.
O Kurumin é capaz de dar boot diretamente em uns 90% dos micros, enquanto as opções permitem que ele funcione na maior parte dos 10% restantes. É raro um PC em que realmente não exista como fazer o Kurumin funcionar. Muitas destas opções são válidas também no Knoppix e nos outros live-CDs derivados dele, como o Kanotix e Mephis e também nos live-CDs derivados do Kurumin, como o Kalango e o Kurumin Games. A única mudança é que neles ao invés das opções começarem com "kurumin", começam com "knoppix", "kalango", ou o nome da distro.
Existem opções de boot para especificar a configuração do vídeo, para desabilitar a detecção de determinados componentes, opções para copiar a imagem do Kurumin para o HD e dar boot com o drive de CD livre, dar boot a partir de um arquivo .ISO salvo no HD e até algumas opções específicas, que variam de uma distribuição para outra.
No canto inferior da tela aparece um prompt (boot:) para digitar as opções. Se você apenas pressionar Enter, ou esperar 30 segundos, o sistema inicializa no modo default, tentando detectar tudo sozinho. As opções de boot permitem modificar o comportamento padrão do sistema, desabilitando algum recurso que está fazendo o micro travar no boot, alterar a resolução do vídeo e assim por diante.
No screenshot acima, estou usando como exemplo uma opção bem longa para configurar vídeo, especificando a resolução, taxa de atualização e o driver de vídeo e desabilitar o ACPI.
Basta digitar a opção desejada e pressionar Enter. Os parâmetros devem ser digitados exatamente como descritos abaixo, sempre em minúsculas. Todos estes parâmetros são opcionais, eles foram desenvolvidos para serem usados em casos de problemas.
OPÇOES DE VIDEO
As opções mais usadas são as referentes à resolução e taxa de atualização do monitor. Por default, o Kurumin tenta detectar automaticamente a sua placa de vídeo e utiliza uma resolução compatível com seu monitor, detectada via DCC.
A configuração do monitor é composta por três parâmetros:
1- O driver de vídeo
2- A resolução e profundidade de cor
3- A taxa de atualização.
O driver de vídeo é o que permite que o sistema se comunique com a placa de vídeo e, conseqüentemente, envie as imagens para o monitor. Cada placa de vídeo tem um conjunto próprio de recursos e se comunica numa linguagem diferente. O driver de vídeo é o "intérprete" que permite que o sistema converse com a sua.
O software responsável por mostrar imagens na tela (o "servidor gráfico" falando em linguagem mais técnica) é o X.org. É ele quem contém os drivers para todas as placas de vídeo suportadas pelo sistema. Nas versões atuais do X.org temos um conjunto relativamente pequeno de drivers, um para cada fabricante (e não um para cada placa de vídeo como antigamente).
O driver "sis", por exemplo, dá suporte a todas as placas de vídeo da SiS, o driver "nv" dá suporte a todas as placas da nVidia e assim por diante. Temos ainda dois drivers genéricos, o "vesa" e o "fbdev" que funcionam com quase todas as placas de vídeo. Eles podem ser usados, por exemplo, quando você tiver alguma placa de vídeo muito recente, que ainda não seja suportada.
A resolução determina a quantidade de pontos mostrados na tela. Os monitores sempre suportam várias resoluções diferentes, permitindo que você use a que achar mais confortável. Um monitor de 17", por exemplo, geralmente suportará de 640x480 a até 1280x1024.
O que muda ao usar resoluções diferentes é a taxa de atualização, que determina quantas vezes por segundo a imagem é atualizada no monitor.
O grande problema é que os monitores atuais utilizam células de fósforo para formar a imagem. Estas células não conservam seu brilho por muito tempo e por isso precisam ser realimentadas constantemente.
O ideal é usar uma taxa de atualização de 75 Hz (75 atualizações por segundo) ou mais. Usando menos que isso teremos um fenômeno chamado flicker, onde a tela fica instável, piscando, parecendo tremer, como se a tela do monitor fosse uma gelatina. É justamente o flicker que causa a sensação de cansaço ao se olhar para o monitor por muito tempo, e a médio prazo pode até causar danos à visão.
Outra coisa que ajuda e muito a diminuir o flicker é diminuir o brilho do monitor. O ideal é usar a tela o mais escura possível, dentro do que for confortável, naturalmente. Uma dica é deixar o controle de brilho no mínimo e ajustar apenas pelo contraste. Quanto maior for a taxa de atualização e quanto menor for a claridade da imagem menor será o flicker e menor será o cansaço dos olhos.
As taxas de atualização máximas dependem tanto da placa de vídeo quanto do monitor. Quanto mais baixa for a resolução de imagem escolhida, maior será a taxa de atualização suportada pelo monitor. A maioria dos monitores de 15" suportam 800x600 com 85 Hz de taxa de atualização ou 1024x768 a 70 Hz. Os monitores de 17" geralmente suportam 1024x768 a 85 Hz, enquanto os monitores mais caros, como os Flatron e Trinitron, de 17" (CRT) chegam a suportar 1600x1200 com 60 Hz.
A placas de vídeo também podem limitar a resolução máxima. Uma placa antiga, uma Trident 9680 por exemplo, não conseguirá trabalhar com mais de 70 Hz de refresh a 1024 x 768 (independentemente do monitor, é uma limitação da própria placa de vídeo). Muitas placas onboard são capazes de exibir 1024x768 com 85 Hz, mas apenas 70 Hz se você usar 1280x1024. Geralmente, apenas as placas de vídeo mais caras são capazes de trabalhar a 1600x1200 com 75 Hz de refresh ou mais, uma possibilidade que é suportada por alguns monitores de 19".
Tudo o que falei até agora sobre taxa de atualização e flicker se aplica apenas aos monitores de CRT (os grandões que ainda usam tubo de imagem). Hoje em dia temos um segundo tipo de monitores, os monitores de LCD, aqueles modelos fininhos e com tela 100% plana, usados desde sempre nos notebooks.
Nos monitores de LCD, cada ponto na tela é como uma lâmpada acesa, eles não possuem problemas com flicker, a imagem é sólida, independentemente da taxa de atualização usada. Em geral, os monitores de LCD suportam várias taxas de atualização, o mais comum é de 56 a até 75 Hz. Isto é feito para permitir que funcionem em conjunto com qualquer placa de vídeo e em várias configurações. Porém, neste caso, a taxa de atualização não afeta a qualidade da imagem.
Se você fica muito tempo na frente do micro ou, principalmente, se trabalha com um, os monitores de LCD são a opção ideal. Eles são mais caros, mas se você dividir a diferença de preço por 36 meses (a vida útil média de um monitor) vai ver que o custo mensal não é tão alto assim. Eles também consomem menos energia (35 watts em média, contra 100 watts ou mais de um monitor CRT) o que economizará alguns trocados todo mês na conta de luz, ajudando a amortizar a diferença de preço.
Mas, voltando à configuração do Kurumin, as opções de boot relacionadas com o vídeo permitem especificar a configuração que deseja usar e resolver os casos em que o sistema não consegue abrir o modo gráfico.
Basta digitar a opção desejada na tela de boot:
fb1024x768: Esta é uma espécie de opção à prova de falhas, que força a resolução de 1024x768 usando o driver fbdev (frame buffer). O frame buffer é um recurso suportado pelo kernel que permite exibir imagens manipulando diretamente o conteúdo da memória de vídeo. A grande vantagem é que não é preciso um driver de vídeo; este modo vai funcionar mesmo em placas de vídeo que não sejam oficialmente suportadas pelo Linux. O modo gráfico é aberto a 1024x768 usando 60 Hz de taxa de atualização, o que permite usar esta opção na grande maioria dos monitores de 14 e 15 polegadas. Funciona em cerca de 90% das placas de vídeo.
fb800x600: É uma variação da opção acima, que utiliza resolução de 800x600. Algumas placas de vídeo onboard e algumas placas antigas só funcionam usando esta opção.
kurumin xvrefresh=60: Esta opção força o sistema a utilizar uma taxa de atualização de apenas 60 Hz para o monitor. Ela é necessária em alguns monitores de LCD que não suportam taxas de atualização mais altas e em vários monitores antigos. O "60" pode ser substituído por qualquer outra taxa de atualização desejada, como em: kurumin xvrefresh=75. Você pode verificar qual é a configuração usada no Windows (ou no sistema atual) e especificar manualmente aqui.
kurumin xdepth=16: Esta opção complementa as outras, permitindo configurar a profundidade de cor. O "16" indica a quantidade de cores em bits. Lembre que 16 bits equivalem a 65 mil cores, 24 equivalem a 16 milhões de cores e 8 equivalem a apenas 256 cores. Em geral o Kurumin dá sempre boot usando 16 ou 24 bits de cor, de acordo com o suportado pela placa, mas caso você tenha um micro muito antigo, com uma placa de vídeo com apenas 1 MB, você pode preferir usar 256 cores para que a placa possa trabalhar a 1024x768.
kurumin desktop=fluxbox: Esta opção faz com que o Kurumin use o fluxbox como gerenciador de janelas ao invés do KDE. O Fluxbox é bem mais simples e menos amigável, mas permite usar o Kurumin em máquinas antigas, onde o KDE fica muito lento. Usando o Fluxbox o consumo de memória durante o boot (ao rodar do CD) cai quase pela metade, permitindo usar o sistema em micros com 64 MB de RAM.
Algumas remasterizações do Kurumin podem incluir outros gerenciadores de janelas, como o Gnome, IceWM ou o Blanes. Nestes casos, você pode usar esta opção para especificar qual gerenciador usar, como em "kurumin desktop=gnome".
kurumin screen=1280x1024: Esta opção é dedicada especialmente para quem usa monitores grandes, de 17" ou mais. É preciso que o monitor suporte 1280x1024 com 75 Hz de taxa de atualização.
kurumin screen=1024x768: Força o Kurumin a usar resolução de 1024x768. Este modo é diferente do "fb1024x768" pois neste a sua placa de vídeo é detectada e são ativados os recursos de aceleração de vídeo suportados por ela. Aqui você está especificando apenas a resolução e deixando que o sistema detecte o restante.
A opção "screen=" pode ser usada para especificar qualquer resolução suportada pelo monitor, mesmo que fora do padrão. Por exemplo, muitos notebooks usam telas wide, com resolução de 1280x800 ou 1280x768, por exemplo. Em muitos deles, o sistema detecta a resolução incorretamente e acaba abrindo sempre a 1024x768. Para que toda a área útil do monitor seja usada, basta especificar manualmente, como em: "kurumin screen=1280x800" no boot.
kurumin screen=1024x768 xvrefresh=60: Aqui estamos combinando as duas opções: resolução de 1024x768 e taxa de atualização de 60 Hz.
Em alguns casos raros, pode ser que o problema seja com a detecção do driver de vídeo, como, por exemplo, o sistema tentando usar o driver "sis" para uma placa recente da SiS que ainda não é suportada por ele. Neste caso, você pode usar a opção "xmodule=vesa" para especificar o driver de vídeo a ser utilizado. Lembre-se de que o vesa é um curinga, um driver genérico que funciona com praticamente todas as placas de vídeo. Você pode combinar esta opção com as outras que já vimos, como em: kurumin screen=1024x768 xvrefresh=60 xmodule=vesa
É possível também combinar várias opções no mesmo comando, basta ir colocando-as em seqüência, sempre começando com "kurumin", como em: kurumin screen=1280x1024 xvrefresh=60 xmodule=vesa desktop=fluxbox.
A configuração do vídeo pode ser também alterada através da opção "Configurar Vídeo", que está disponível no "Centro de Controle do Kurumin > Suporte a Hardware > Configuração do Vídeo, Som, Teclado e Joystick".
Aqui você tem acesso às mesmas opções disponíveis na hora do boot. Se não marcar nenhuma opção, o vídeo simplesmente é redetectado automaticamente. As opções permitem forçar o uso das configurações desejadas. O utilitário gera o novo arquivo de configuração, permite que você teste a configuração, para ter certeza que está realmente funcionando e, no final, confirma se você quer usá-la.