Recursivamente procurar e substituir uma palavra em vários arquivos

O sistema operacional Linux oferece várias ferramentas para gerenciamento e edição de arquivos, neste artigo mostram como usar alguns comandos para substituir uma ou mais palavras em um arquivo de texto. Um comando bastante útil quando você precisa substituir uma ou mais palavras em alguns arquivos é este:

sed -i 's/parola1/parola2/g' *.txt

desta forma será substituído por word1 word2em todos os arquivos de texto no diretório atual.

Mas se tivéssemos que fazer isso também substituir os arquivos em algumas pastas, então sob o comando torna-se:

find ./ -type f -exec sed -i 's/parola1/parola2/g' '{}' \;

neste caso, eu fiz sem o filtro do tipo de arquivo .txt e depois serão levados em conta todos os arquivos no diretório atual e seus subdiretórios.

Com o comando find que foi utilizado o “-exec” que permite executar um comando de cada vez que um arquivo é encontrado, que respeite as regras estabelecidas para a pesquisa. No caso anterior, a pesquisa inclui todos os elementos de “file” tipo e excluir os diretórios.
Tudo está coberto por “-exec” é o comando a ser executado e seus parâmetros, para o caractere “;” indicando o final da cadeia de comando.
Outro elemento-chave é o símbolo “{}“Indica que o nome real do arquivo e descobriu que, desta forma ser usado como um parâmetro do comando que deseja executar. No comando anterior chaves” {} “foram listadas e no final de comando é precedido de uma barra “\” para proteger esses símbolos de ‘expansão shell.
O comando é executado no diretório de partida, então se o comando digitado necessita de uma saída deve ser levado em conta.

Conselho a buscar em primeiro lugar a palavra, só para ver o que será encontrado e substituído:

find ./ -type f -exec grep -r "parola1" '{}' \;

Ou você pode usar o comando:

find ./ -type f -print0 | xargs -0 grep "parola1"

desta forma irá exibir todas as linhas que contêm a string.

Em particular, a directiva tem sido usado “-print0” que permite a saída do nome completo terminada por um caractere nulo. Desta forma, o string produzida pode ser interpretado corretamente pelo programa a seguir.
Na verdade, a saída do findestá conectada com um tubo para xargs comando cujo parâmetro “-0” indica que os nomes dos arquivos recebidos como um fim de entrada com um caractere nulo.

O comando “xargs” é responsável por receber os nomes dos arquivos e executar o comando ” grep “, que por sua vez usa os parâmetros passados ​​para xargs.

Se você só quer ver exibido o nome do arquivo que a contém, o comando é:

find ./ -type f -print0 | xargs -0 grep -l "parola1"

O parâmetro “-l” indica que temos como saída uma lista de nomes de arquivos, mas não as linhas, foram encontrados nos jogos.

Faço notar que em todos os comandos listados tem sido sugerido que a pesquisa para acontecer no diretório atual e todos os seus sub-diretórios, mas se quisermos olhar para qualquer diretório que você deve inserir o caminho (relativo ou absoluto):

find /home/user/ -type f | xargs grep -l "parola1"

Finalmente, se não fosse necessário o uso de parâmetros complexos para a busca de arquivos e deseja apenas pesquisa recursivamente uma palavra ou frase dentro dos arquivos em subdiretórios múltiplas, muito mais simples basta usar o comando grep com o “-r

grep “this text” *.php -rDesta forma ele vai olhar para a string “este texto” em todos os arquivos. “Php” no diretório atual e todos os seus subdiretórios.

Configurando 3g no Mikrotik

Modem 3G da Tim no Mikrotik
Essa configuração foi feita no Mk 3.30 licenciado.

Conecte o Modem 3G na USB e ligue o Servidor.

Vá em Ports
Na usb3 coloque 9600 em Baud Rate.

Em PPP > Profiles crie o seguinte Profile
name=ppp-3G
Remote Address=212.93.97.200

Em Interface crie um PPP-Client
name=ppp-3G
Max MTU=1500
MAx MRU=1500
port=usb3
Modem Init=AT+CGDCONT=1,”ip”,”tim.br”
Menu PPP
Phone=*99***1#
Dial Command=ATDT
User=tim
Password=tim
Profile=ppp-3G
Add Default Route=Yes
User Peer DNS=Yes
Allow
Pap=Yes
Mschap=Yes
Chap=Yes
Mschap2=Yes

e Pronto, seu servidor Mikrotik já está preparado para utilizar o Modem 3G da Tim, o restante das configurações do servidor todos já sabemos.

Ligando a máquina remotamente e desativando o botão power

Configurando o gerenciamento de energia usando ACPI O ACPI (Advanced Configuration and Power Interface – Interface de Configuração e Gerenciamento de Energia Avançado) é uma camada de gerenciamento de energia que opera a nível de sistema operacional. Apresenta os mesmos recursos que o APM, e outros como o desligamento da máquina por teclas especiais de teclado, controle de brilho e contraste de notebooks, suspend para RAM, suspend para disco, redução de velocidade de CPU manualmente, monitoramento de periféricos, temperatura, hardwares, etc. Desta forma, o ACPI varia de sistema para sistema em questões relacionadas com suporte a recursos especiais, estes dados são armazenados em tabelas chamadas DSDT. O Linux inclui suporte a recursos ACPI genéricos entre placas mãe, recursos específicos devem ser extraídos diretamente da BIOS e disassemblados manualmente para a construção de um kernel com suporte específico a tabela DSDT do hardware (não falarei das formas de se fazer disso aqui, somente do suporte genérico). Quanto mais nova a versão do kernel, maiores as chances do seu hardware ser suportado plenamente pelo ACPI, principalmente no caso de notebooks. Para compilar estaticamente, marque com Y a opção ACPI, depois marque os módulos que você quer que ele monitore: button (botão power), fan (ventoinhas), etc. Se compilou como módulo, adicione o nome do módulo acpi no arquivo /etc/modules. Não há problema em compilar também o suporte a APM, pois não causará problemas com um kernel com ACPI também compilado. Caso não saiba quais módulos ACPI seu sistema aceita, marque o suporte a todos e carregue-os. Após isto, entre no diretório /proc/acpi e de um ls entrando nos diretórios e vendo se existem arquivos dentro deles. Remova o módulo correspondente daqueles que não tiver conteúdo. Após isto, instale o daemon acpid e configure-o para monitorar algumas características do seu sistema. Por padrão o acpid monitora o botão POWER, assim se você pressionar o power, seu sistema entrará automaticamente em run-level 0, fechando todos os processos e desligando sua máquina. O suporte a ACPI pode ser desativado de 3 formas: Removendo seu suporte do kernel, passando o argumento acpi=off ao kernel (caso esteja compilado estaticamente) ou removendo o módulo de /etc/modules (caso tenha compilado como módulo. Após isto, remova o daemon acpid do seu sistema.

Ativando WakeUP on Lan Algumas placas mãe ATX possuem suporte a este interessante recurso, que permite sua máquina ser ligada através de uma rede. Isto é feito enviando-se uma seqüência especial de pacotes diretamente para o MAC (endereço físico) da placa de rede usando um programa especial. Para usar este recurso, seu sistema deverá ter as seguintes características: Placa mãe ATX Fonte de alimentação ATX compatível com o padrão 2.0, com fornecimento de pelo menos 720ma de corrente na saída +3v. Placa de rede com suporte a WakeUP-on-Lan (WOL), você poderá confirmar isto vendo um conector branco de 3 terminais instalado na placa que é o local onde o cabo wake-up é conectado. Suporte na BIOS também deverá ter a opção para WakeUP-on-Lan. Com todos esses ítens existentes, instale em uma máquina da rede o pacote etherwake. Depois disso, pegue o MAC address a placa de rede da máquina que tem o wakeup on lan e na máquina da rede onde instalou o pacote execute o seguinte comando:

ether-wake AA:BB:CC:DD:EE:FF

Onde AA:BB:CC:DD:EE:FF é o endereço MAC da placa de rede. A máquina deverá ligar e realizar o procedimento padrão de POST normalmente. Algumas das situações onde o WOL não funciona é quando sua rede é controlada por Switches (devido a natureza de funcionamento deste equipamentos) ou caso esteja atrás de um roteador que não faz proxy arp.

Fazendo backup no OpenLDAP

Só uma pequena dica, principalmente para mim que provavelmente irei esquecer disso daqui a alguns dias! 🙂

Para fazer o backup do OpenLDAP (estou usando o Debian Sarge), uso a ferramenta slapcat, onde usando o backend bdb é possível fazer o backup com o serviço rodando (atenção, em alguns backends pode dar problema rodar o slapcat com o serviço rodando).

O slapcat gera um arquivo no formato LDIF, usado pelo OpenLDAP. Para isso uso a seguinte linha:

# /usr/sbin/slapcat -f /etc/ldap/slapd.conf -b “dc=domínio,dc=com” | bzip2 -9 > slapdb.ldif.bz2

Com isso no cron você pode ter backups diários, semanais ou como você escolher.

Para restaurá-lo uso a ferramenta slapadd, para isso é necessário ter o arquivo /etc/ldap/slapd.conf semelhante ao do servidor original (mesmo domínio, schemas e ACL), os arquivos de schema todos no lugar. Não sei garantir se é necessário o diretório /var/lib/ldap vazio, mas eu limpo antes de importar o backup de qualquer maneira.

Com o serviço desligado (é importante), uso o comando:

# bunzip2 slapdb.ldif.bz2 slapadd -l slapdb.ldif

Como superusuário, inicie o serviço e pronto, o backup está restaurado.

Um pouco sobre IPTABLES – Firewall do Linux

====== Firewall e roteamento avançado no Linux ======

===== Introdução =====

==== Objetivo =====

Apresentar as diversas ferramentas e funcionalidades existentes no Linux para implementação de 
Firewall e roteadores. O uso específico de cada ferramenta não será coberto por este artigo e 
caberá ao leitor se aprofundar nestes assuntos.

==== Pré Requisitos ====

É assumido que o leitor tenha conhecimentos básicos sobre sistemas GNU / Linux e redes TCP/IP 
(incluindo firewalls e roteamento).

É recomendado que o leitor acompanhe o artigo com o manual de cada ferramenta aberto para 
consulta.

====== Firewall: IP Tables ======

A ferramenta atual para firewall no Linux é o http://www.netfilter.org/projects/iptables/|iptables]]. 
O iptables é constituído de uma série de aplicativos existentes no [[wp>Userland_(computing)|
userland]] que interagem com o [[http://www.netfilter.org/|netfilter]], que é a implementação de 
firewall em nível de [[wppt>Kernel|kernel]].

O iptables se baseia em pares de regras e ações. As regras definem em quais pacotes atuar 
(eg. pacotes originados de uma rede em específico) e a ação define qual atitude deve ser 
tomada quando um pacote bater com a regra em questão (eg. recusar pacotes de origens duvidosas). 
O netfilter irá processar todas as regras sequencialmente, e quando encontrar uma que especifique 
um dado pacote, ele atuará com a ação par daquela regra. As ações podem ser terminativas ou não. 
Por exemplo, uma ação que diz ao netfilter para ignorar um pacote é executada e nenhuma outra é 
executada. Esta é uma ação terminativa. Por outro lado, uma ação especificando para apenas 
notificar a existência de um pacote, faz seu papel e diz ao netfilter para continuar processando
 as demais regras (eg. fazer log quando certo pacote passa pela máquina).

A principal ferramenta é o comando ''iptables'', que pode ter seu manual acessado com

  # man iptables

As próximas sessões explicam como e quais são as partes que compõe este funcionamento.

===== Tabelas =====

O nome iptables vem do fato de internamente o iptables funcionar em cima de tabelas, cada uma 
especializada num tipo de tratamento de pacotes. As tabelas existentes são (kernel 2.6.8, pode 
variar para outras versões):

  * ''raw:'' onde são feitas algumas alterações em mais baixo nível nos pacotes
  * ''filter:'' nesta tabela cabem as regras responsáveis pela filtragem de pacotes
  * ''nat:'' mudanças nos cabeçalhos dos pacotes (incluindo NAT e //IP Masquerade//)
  * ''mangle:'' usada para alterações específicas nos pacotes

Portanto, dependendo do que se deseja fazer com um pacote em específico, existe uma tabela 
adequada para tal.

===== Cadeias =====

No iptables, existem diversas cadeias, a cada uma associado um certo tipo de tráfego. São elas:

  * ''PREROUTING'': tráfego ingressante na máquina (incluindo tráfego gerado localmente com destino local)
  * ''INPUT'': tráfego que tem como destino a própria máquina
  * ''FORWARD'': tráfego passante pela máquina
  * ''OUTPUT'': tráfego gerado localmente (tanto com destino local como remoto)
  * ''POSTROUTING'': todo tráfego que "sai" da máquina (incluindo tráfego gerado localmente com destino local)

Também é possível a criação de tabelas personalizadas, tópico que não será abordado.

A cadeia ''FORWARD'' tem um tratamento especial na kernel do Linux, e vem com uma trava fora do 
firewall, que por padrão bloqueia tráfego por ela. Para permitir seu funcionamento, é necessário 
configurar o seguinte parâmetro da kernel do Linux:

  net.ipv4.ip_forward=1

Sua ativação é feita pelo comando ''sysctl'', e pode ser automatizada na maioria das 
distribuições adicionando esta linha ao arquivo ''/etc/sysctl.conf''. Para ativar manualmente:

  # sysctl -w net.ipv4.ip_forward=1

**Nota:** Nas versões do Debian GNU/Linux anteriores (e incluindo) a Sarge, o arquivo 
''/etc/network/options'' pode ser usado para configurar este e outros parâmetros. É uma 
configuração tida como legado e errada e não aparece mais em novas versões. Tenha certeza de que 
nenhum método (''sysctl.conf'' ou ''options'') está sobrepassando a configuração do outro.

===== Fluxograma =====

O fluxo de dados que ocorre internamente na kernel do Linux pode ser descrito pelo fluxograma 
abaixo. Em cada caixa, está evidenciada a cadeia atuante do iptables, e as tabelas válidas na 
cadeia em questão. O tráfego passa por cada uma das tabelas em sequência em uma dada cadeia. 
Por exemplo, na cadeia ''PREROUTING'', existem as tabelas ''raw'', ''mangle'' e ''nat''. 
Tráfego que se enquadra nesta cadeia irá passar sequencialmente pelas três tabelas indicadas.

         Tráfego
        de Entrada
            |
            |
            V
       +----------+
       |PREROUTING|
       +----------+
       |   raw    |  <--------------+
       |  mangle  |                 |
       |   nat    |                 |
       +----------+                 |
            |                       |
            |                       |
         Decisão                    |
      +-   de     -+                |
      | Roteamento |                |
      |            |                |
      V            V                |
   Destino       Destino            |
    Local        Remoto             |
      |            |                |
      |            |                |
      V            V                |
  +--------+  +---------+           |
  | INPUT  |  | FORWARD |           |
  +--------+  +---------+           |
  | mangle |  | mangle  |           |
  | filter |  | filter  |           |
  +--------+  +---------+           |
      |            |                |
      |            |                |
      V            |                |
   Máquina         |                |
    Local          |                |
      |            |                |
      |            |                |
      V            |                |
   Decisão         |                |
     de            |                |
  Roteamento       |                |
      |            |                |
      |            |                |
      V            |                |
  +--------+       |                |
  | OUTPUT |       |                |
  +--------+       |                |
  |  raw   |       |                |
  | mangle |       |                |
  |  nat   |       |                |
  | filter |       |                |
  +--------+       |                |
      |            |                |
      |      +-------------+        |
      |      | POSTROUTING |     Tráfego
      +----> +-------------+ -->  Local
             |   mangle    |
             |     nat     |
             +-------------+
                   |
                   |
                   V
                Tráfego
                de Saída

Tomemos como exemplo um acesso da máquina para ela mesma. O tráfego irá passar sequencialmente 
por estas cadeias / tabelas:

  * Pacote gerado por um processo / kernel local
  * Decisão de roteamento
  * ''OUTPUT'': ''raw''
  * ''OUTPUT'': ''mangle''
  * ''OUTPUT'': ''nat''
  * ''OUTPUT'': ''filter''
  * ''POSTROUTING'': ''mangle''
  * ''POSTROUTING'': ''nat''
  * ''PREROUTING'': ''raw''
  * ''PREROUTING'': ''mangle''
  * ''PREROUTING'': ''nat''
  * Decisão de roteamento
  * ''INPUT'': ''mangle''
  * ''INPUT'': ''filter''
  * Pacote entregue a um processo / kernel local

Portanto, se desejamos permitir tal tráfego, devemos garantir que não exista nenhuma ação em 
nenhum dos casos acima que bloqueie os pacotes deste acesso.

===== Regras =====

Dada uma cadeia / tabela em específico, é necessário o uso de regras para selecionar em quais 
pacotes uma dita ação irá atuar. Nem todas as regras se aplicam a todas as cadeias (por exemplo,
 uma regra que especifica a interface de saída de pacote não se aplica a cadeia ''PREROUTING'', 
uma vez que a decisão de roteamento ainda não foi tomada).

Existem regras gerais (ou padrão) e existem extensões (referidas como //match extensions// no 
manual). A existência e variedade das regras extras dependem da versão da kernel em uso e da 
versão do iptables em uso (lembre-se que o iptables é simplesmente uma interface para conversar
 com a kernel). É possível o caso em que exista determinada regra extra no iptables, mas não a
 correspondente implementação na kernel. Neste caso, a tentativa de uso desta regra resultará 
em erro.

As regras gerais são:

  * ''-p PROTOCOLO'': especifica um protocolo (por exemplo tcp ou udp)
  * ''-s ENDEREÇO'': especifica um endereço de origem
  * ''-d ENDEREÇO'': especifica um endereço de destino
  * ''-i INTERFACE'': especifica a interface de rede na qual o pacote ingressou
  * ''-o INTERFACE'': especifica a interface de rede na qual o pacote irá sair da máquina

As regras extras serão tratadas mais adiante.

Lembre-se que nem todas as regras se aplicam a todas as cadeias.

===== Alvo =====

Especifica a ação a ser tomada quando um pacote casar com uma dada regra de seleção. 
Esta ação pode ser uma das ações padrão ou uma extenção (similares ao caso das regras acima). 
As ações padrão são:

  * ''ACCEPT'': aceita o pacote, e diz ao netfilter para continuar o processamento do pacote na próxima cadeia/tabela
  * ''DROP'': diz ao netfilter para ignorar completamente o pacote
  * ''QUEUE'': indica que o pacote deve ser passado ao userspace
  * ''RETURN'': instrui o netfilter para parar de processar a cadeia em questão e continuar na próxima regra na cadeia anterior

Na prática, a grandíssima maioria das vezes será usado apenas ''ACCEPT'' ou ''DROP''.

===== Escrevendo regras =====

Segundo o manual do utilitário iptables, existem diversas maneiras de se acrescentar / remover 
pares de regras / ação. Todas são operações discretas, o que sugere que criemos um 
//Shell Script// contendo todas as chamadas discretas das regras que irão compor o firewall 
completo.

Para adicionar discretamente uma regra (ao final das pré existentes), a forma geral é:

  # iptables -t TABLE -A CADEIA REGRAS -j ALVO

Onde:

  * ''TABLE'' identifica a tabela
  * ''CADEIA'' identifica a cadeia
  * ''REGRAS'' compõe as regras de seleção de pacotes no qual o ''ALVO'' deve atuar
  * ''ALVO'' ação a ser executada

Por exemplo, para permitirmos que a rede 192.168.0.0/24 ligada a interface de rede eth0 possa 
enviar tráfego a rede 192.168.1.0/24 conectada a interface de rede eth1, devemos escrever a 
seguinte regra:

  # iptables -t filter -A FORWARD -s 192.168.0.0/24 -d 192.168.1.0/24 -i eth0 -o eth1 -j ACCEPT

Note pelo fluxograma que esta regra não seria suficiente para permitir tal tráfego, uma vez que 
ele passa por muitas outras cadeias e tabelas.

No caso de não existir alguma regra específica para um determinado tráfego, é possível 
configurar uma política padrão para cada cadeia / tabela. Esta política aponta um alvo a ser 
executado, caso nenhuma regra terminativa nesta mesma cadeia / tabela atue no pacote. Para 
definir uma política padrão:

  # iptables -t TABELA -P CADEIA ALVO

Por exemplo:

  # iptables -t raw -P OUTPUT ACCEPT

irá permitir tráfego livre por padrão na dada cadeia / tabela.

Até aqui, os recursos são bem limitados. O próximo tópico irá abordar os extras do iptables.

==== Regras Extras ====

Como citado anteriormente, existem regras extras que podem ajudar na seleção de pacotes. 
O uso geral das extenções de regras é:

  ... -m NOME OPÇÕES

onde

  * ''NOME'' identifica a extenção a ser usada
  * ''OPÇÕES'' opções específicas de cada extenção

No manual do iptables no tópico ''MATCH EXTENSIONS'' há uma descrição detalhada das extenções 
existentes. Adiante, falaremos de algumas de maior relevância.

  * **tcp**
Permite a especificação de estado ou portas de uma conexão TCP. Exemplo:

  ... -m tcp --dport www

especifica a porta de destino como www (80, veja ''/etc/services'') de uma conexão TCP.

  * **udp**
Permite a especificação de portas de uma conexão UDP.

=== Conexões ===

As regras vistas até agora conseguem identificar apenas casos estáticos. Por exemplo, um servidor 
web recebe uma conexão em sua porta 80. Porém, a porta de origem do cliente é indeterminada. 
Existe porém uma funcionalidade de se rastrear conexões. Você identifica somente o destino 
(eh. servidor web porta 80) e todo o tráfego relacionado, poderá ser identificado facilmente.

Continuando o exemplo anterior, podemos escrever:

  # iptables -t filter -A FORWARD -d SERVIDOR_WEB -i INTERFACE_EXTERNA -o INTERFACE_INTERNA -j ACCEPT
  # iptables -t filter -A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT

A primeira regra irá permitir que nosso roteador garanta acesso externo a um servidor web. 
A segunda regra diz que será permitida a volta deste tráfego (mais especificamente, qualquer 
tráfego relacionado a uma conexão existente qualquer). A regra extra ''state'' permite ter acesso 
ao estado da conexão. Neste caso, estamos explicitamente dizendo que qualquer tráfego relacionado 
a uma conexão pré estabelecida é permitido (não necessariamente apenas esta conexão ao servidor
 web).

O sistema de rastreamento do conexões possui diversos módulos, podendo rastrear até mesmo as 
conexões de transferência de dados de uma conexão FTP, sem a necessidade de um servidor proxy 
para tal. Para o caso em que não é definida uma conexão (como no caso de UDP ou ICMP) o sistema 
de rastreamento abre uma janela para o tráfego de retorno, mediante a existência do tráfego de 
ida, tratando ambos como parte da mesma conexão.

Um bom negócio é manter uma regra como a segunda regra genérica do exemplo acima apenas uma vez,
e ao escrever as regras específicas para rastrear conexões de cada tráfego. A existência de tal 
regra é também recomendada para garantir o tráfego de mensagens ICMP.

Consulte o manual do iptables para encontrar outras possibilidades de rastreamento de conexões e 
outras formas de utilização da ferramenta.

==== Alvos Extras ====

Os alvos extras permitem recursos mais interessantes, tais como NAT ou balanceamento de carga. 
Ao selecionar um alvo extra, uma nova gama de opções se abre para cada um deles. 
Por favor consulte sempre o manual para conhece-las.

  * **LOG**
Permite que se notifique os pacotes via mensagens da kernel (accessíveis via o comando ''dmesg''). 
Uma boa dica, é sempre incluir uma regra com alvo LOG exatamente antes de qualquer regra que vá recusar 
algum pacote. Desta maneira, é possível identificar facilmente se o seu firewall está bloqueando algum 
tráfego que não deveria.
O uso deste alvo, dá acesso a opção ''--log-prefix'', que permite incluir um prefixo na depuração.

  * **MASQUERADE, SNAT, DNAT**
São 3 possibilidades da implementação de NAT ([[http://www.faqs.org/rfcs/rfc1631.html|RFC1631]]). 
Desta maneira, é possível integrar uma rede privada ([[http://www.faqs.org/rfcs/rfc1918.html|RFC1918]]) 
a internet sem problemas. Por favor, consulte o manual para maiores detalhes de como utilizar 
estes alvos.

====== Roteamento Avançado ======

O Linux possui uma implementação diferenciada de outros UNIX para o sistema de roteamento. 
Os utilitários ''ifconfig'' e ''route'' tradicionais de sistema UNIX continuam válidos, porém 
existe uma outra camada de implementação mas avançada. O utilitário ''ip'' (parte do pacote ''
iproute2'') permite o acesso a novos sistemas de roteamento. Ele será a ferramenta que estaremos 
operando agora.

O sistema de roteamento no Linux é implementado em duas partes:

  - Regras
  - Tabelas de roteamento

As regras são responsáveis por indicar em qual tabela de roteamento a kernel deve procurar por 
uma rota. Portanto, é possível a existência de múltiplas tabelas de roteamento.

===== Regras =====

Para listar as regras existentes, fazemos:

  # ip rule list
  0:	from all lookup local 
  32766:	from all lookup main 
  32767:	from all lookup default

As regras são processadas em ordem crescente de prioridade (1a coluna). Neste caso, a prioridade 
0 instrui a kernel a, para qualquer tráfego,  procurar por uma solução de roteamento na tabela 
de nome local. O conteúdo desta tabela pode ser acessado com:

  # ip route list table local
  local 192.168.1.1 dev eth3  proto kernel  scope host  src 192.168.1.1 
  local 200.170.111.237 dev eth0  proto kernel  scope host  src 200.170.111.233 
  broadcast 192.168.1.0 dev eth3  proto kernel  scope link  src 192.168.1.1 
  broadcast 192.168.2.255 dev eth1  proto kernel  scope link  src 192.168.2.1 
  local 200.170.111.236 dev eth0  proto kernel  scope host  src 200.170.111.233 
  broadcast 127.255.255.255 dev lo  proto kernel  scope link  src 127.0.0.1 
  broadcast 200.170.111.239 dev eth0  proto kernel  scope link  src 200.170.111.233 
  local 200.170.111.239 dev eth0  proto kernel  scope host  src 200.170.111.233 
  local 200.170.111.238 dev eth0  proto kernel  scope host  src 200.170.111.233 
  local 200.170.111.233 dev eth0  proto kernel  scope host  src 200.170.111.233 
  broadcast 200.170.111.232 dev eth0  proto kernel  scope link  src 200.170.111.233 
  local 200.170.111.235 dev eth0  proto kernel  scope host  src 200.170.111.233 
  local 201.20.202.11 dev eth0  proto kernel  scope host  src 201.20.202.11 
  broadcast 201.6.149.0 dev eth2  proto kernel  scope link  src 201.6.149.41 
  local 200.170.111.234 dev eth0  proto kernel  scope host  src 200.170.111.233 
  local 192.168.2.1 dev eth1  proto kernel  scope host  src 192.168.2.1 
  broadcast 192.168.1.255 dev eth3  proto kernel  scope link  src 192.168.1.1 
  broadcast 192.168.2.0 dev eth1  proto kernel  scope link  src 192.168.2.1 
  broadcast 201.20.207.255 dev eth0  proto kernel  scope link  src 201.20.202.11 
  broadcast 201.20.200.0 dev eth0  proto kernel  scope link  src 201.20.202.11 
  broadcast 127.0.0.0 dev lo  proto kernel  scope link  src 127.0.0.1 
  broadcast 201.6.149.255 dev eth2  proto kernel  scope link  src 201.6.149.41 
  local 201.6.149.41 dev eth2  proto kernel  scope host  src 201.6.149.41 
  local 127.0.0.1 dev lo  proto kernel  scope host  src 127.0.0.1 
  local 127.0.0.0/8 dev lo  proto kernel  scope host  src 127.0.0.1

A tabela é extensa e é gerenciada pela própria kernel, portanto não se preocupe com ela. 
A tabela local contém informações de que o tráfego associado aos endereços das interfaces 
de rede local, devem ser tratados localmente.

Quando ocorre de a tabela local não satisfazer um determinado destino (eg. tráfego destinado 
a outra máquina) a kernel procura a regra seguinte de menor prioridade (maior número) para 
achar uma solução de roteamento. No caso, a regra de prioridade 32766 diz para procurar na 
tabela de nome main.

  # ip route list table main
  200.170.111.232/29 dev eth0  proto kernel  scope link  src 200.170.111.233 
  192.168.2.0/24 dev eth1  proto kernel  scope link  src 192.168.2.1 
  192.168.1.0/24 dev eth3  proto kernel  scope link  src 192.168.1.1 
  201.6.149.0/24 dev eth2  proto kernel  scope link  src 201.6.149.41 
  201.20.200.0/21 dev eth0  proto kernel  scope link  src 201.20.202.11 
  default via 201.6.149.1 dev eth2 

Esta tabela contém as regras de roteamento encontradas pelo comando ''route'':

  # route -n
  Tabela de Roteamento IP do Kernel
  Destino         Roteador        MáscaraGen.    Opções Métrica Ref   Uso Iface
  200.170.111.232 0.0.0.0         255.255.255.248 U     0      0        0 eth0
  192.168.2.0     0.0.0.0         255.255.255.0   U     0      0        0 eth1
  192.168.1.0     0.0.0.0         255.255.255.0   U     0      0        0 eth3
  201.6.149.0     0.0.0.0         255.255.255.0   U     0      0        0 eth2
  201.20.200.0    0.0.0.0         255.255.248.0   U     0      0        0 eth0
  0.0.0.0         201.6.149.1     0.0.0.0         UG    0      0        0 eth2

Esta tabela portanto, contém o sistema de roteamento tradicional.

A última tabela (default) vem vazia.

As tabelas mostradas até aqui compõe o sistema de roteamento tradicional. 
Porém é possível incluir novas regras de acordo com a necessidade, apontando para 
tabelas de roteamento diferentes.

==== Regras personalizadas ====

Podemos por exemplo, inlcuir uma regra especificando que tráfego de determinada origem
 deve ser resolvido com uma tabela de roteamento especial:

  # ip rule add type unicast from 192.168.4.0/24 priority 55 table 55

Isso dirá a kernel para quando receber tráfego com origem na rede 192.168.4.0/24, 
procurar roteamento na tabela de número 55. Esta tabela deverá ser criada pelo administrador,
 e conter as regras de roteamento aplicáveis somente a rede em questão.

Neste caso:

  # ip rule list
  0:	from all lookup local 
  55:    from 192.168.4.0/24 lookup 55
  32766:	from all lookup main 
  32767:	from all lookup default

Note que tanto a prioridade 55 e o número 55 para a tabela, foram absolutamente arbitrários, 
e não há necessidade alguma de ambos serem iguais.

Por favor, consulte o manual do utilitário '''ip''' para obter maiores informações de como 
adicionar e remover regras.

===== Tabelas =====

As tabelas de roteamento são identificadas por números de 0 a 255. As tabelas local e main 
tem os números 255 e 254 associados a elas respectivamente. Existe um arquivo de configuração 
em que se pode associar nome a tabelas (como no caso da loca e main, que já vem de fábrica assim)
 que não será coberto neste artigo.

A existência de uma tabela, contendo suas próprias regras não implica em que ela esteja em uso. 
Uma tabela apenas estará em uso se existir uma regra apontando para ela.

Consulte o manual para aprender como adicionar e remover regras de roteamento nas tabelas. 
Não deve haver dificuldade quanto a isso, uma vez que a operação é similar ao sistema de 
roteamento clássico (comando ''route'').

===== Nota =====

A kernel do Linux possui uma proteção "anti-spoff" separadamente do firewall.
 Esta proteção serve para proteger uma rede interna contra ataques externos. 
Dependendo da situação de roteamento desejada (especialmente com diversos links de internet) 
esta opção tem que ser desabilitada.

Esta opção é accessível pelo sysctl

  net.ipv4.conf.all.rp_filter 

que muda a configuração para todas as interfaces de rede. Também existe a possibilidade de 
habilitar ou desabilitar por itnerface (basta substituir ''.all.'' por ''.eth0.'' para mudar 
apenas a eth0).

Colocando a linha

  net.ipv4.conf.all.rp_filter=0

no arquivo ''/etc/sysctl.conf'', deverá desligar esta proteção automaticamente durante 
a inicialização.

====== Integrando Firewall e Roteamento ======

Uma das possibilidades de escrita de regra de roteamento é a opçãp ''fwmark''. 
Esta opção faz com que pacotes que tenham uma marca feita pelo firewall caiam na 
tabela de roteamento desejada.

  # ip rule list
  0:	from all lookup local 
  33:	from all fwmark 0x1 lookup 33 
  32766:	from all lookup main 
  32767:	from all lookup default 

Neste caso, pacotes que contenham uma marca de firewall 1 (0x1 é o mesmo número, 
porém em hexa-decimal) devem cair na tabela de roteamento 33. A escolha deste número é 
absolutamente arbitrária.

É importante saber que esta marca é local, e não altera de forma alguma qualquer conteúdo 
do pacote.

===== Marcando pacotes =====

Para marcar pacotes com o iptables usa-se o alvo ''MARK'':

  # iptables -t mangle -A PREROUTING -i eth0 -j MARK --set-mark 1

Nesta regra de exemplo, todo tráfego entrante pela interface eth0 será marcado como 1 
(a escolha do número 1 é absolutamente arbitrária). Feito isso, é possível incluir uma 
regra de roteamento como no tópico anterior que irá se aplicar somente aos pacotes que 
entrarem pela interface eth0.

Note pelo fluxograma do iptables exposto anteriormente que a marca está sendo feita antes 
da decisão de roteamento. Neste caso, como o tráfego é passante pela máquina, ele deve 
acontecer no ''PREROUTING''. Caso se desejasse marcar tráfego gerado localmente, 
deve-se utilizar a cadeia ''OUTPUT''.

==== Conexões ====

É possível também marcar todos os pacotes relativos a uma conexão. O alvo ''CONNMARK'' 
permite a marcação de uma conexão (referida como //connection mark//, interna ao firewall), 
que não é a mesma marcação utilizada pelo roteamento (referida como //netfilter mark//, 
acessível pelo sistema de roteamento), não confunda as duas. Portanto, pode-se fazer o 
seguinte para marcar todos os pacotes de uma conexão:

  # iptables -t mangle -A OUTPUT -d SERVIDOR -j CONNMARK --set-mark 1
  # iptables -t mangle -A OUTPUT -m connmark --mark 1 -j MARK --set-mark 1

A primeira regra marca todas as conexões desejadas. A segunda regra usufrui da extensão ''-m 
connmark'' para identificar tais conexões e marcar seus pacotes com o alvo ''MARK'' (marca que 
pode ser utilizada pelo sistema de roteamento).

**Nota**: A kernel 2.6.8 distribuida com o Debian GNU/Linux Sarge não possui tal 
funcionalidade (''CONNMARK''). Esta funcionalidade apareceu apenas em kernels posteriores e 
é necessária uma atualização de kernel para usar este recurso.2

Referencia: http://ornellas.apanela.com

Utilitários em modo texto

Olá,

Um dia desses usando meu veio e bom linux hehe, pensei comigo mesmo será que é possível usar o mesmo para executa programa sem ser em modo Gráfico / X. Foi quando comecei a pesquisar e achei alguns programas bacanas, com varias funcionalidade desde ouvir mp3 ate navegar a net hehe.

Fique ai minha sugestão para tão, e uma forma a mais de falar o quanto o linux é um “mavagilha”.

Navegar na Internet

Lynx : http://lynx.browser.org/

Links : http://links.sourceforge.net/

w3m : http://w3m.sourceforge.net/

elinks: http://elinks.or.cz/

Email

Pine? http://www.washington.edu/pine/

Mutt: http://www.mutt.org/

Chat

Jabber/GTalk – freetalk http://www.gnu.org/software/freetalk/

AIM – Naim http://naim.n.ml.org

IRC – IRSSI http://www.irssi.org/

Vídeo

MPlayer – http://www.mplayerhq.hu/

Imagens

ZGV http://www.svgalib.org/rus/zgv/

Edição de Texto

vim : http://www.vim.org/

emacs: http://www.gnu.org/software/emacs/

Gravar CDs

Bashburn – http://bashburn.sourceforge.net

É isso ai é só uma ponta o iceber, existem muito outros, mais não to aqui para listar todos.. mais sim, para passar uma idéias do quanto o linux é show..

Abraço a todos


Rodrigo Lima
kbca

Entendendo e utilizando permissões no LINUX

As permissões são um dos aspectos mais importantes do Linux (na verdade, de todos os sistemas baseados em Unix). Elas são usadas para vários fins, mas servem principalmente para proteger o sistema e os arquivos dos usuários. Manipular as permissões é algo muito interessante, tanto quanto complexo. Mas tal complexidade não deve ser interpretada como dificuldade e sim como grande variedade de configurações, o que permite criar vários tipos de proteção de arquivos e diretórios.

Como você deve saber, somente o super-usuário (root) tem ações irrestritas no sistema, justamente por ser o usuário responsável pela configuração, administração e manutenção do Linux. Cabe a ele por exemplo, determinar o que cada usuário pode executar, criar, modificar, etc. Naturalmente, a forma usada para determinar o que o usuário pode fazer é a determinação de permissões. Este artigo visa explicar as configurações de permissões de arquivos e diretórios, assim como modificá-las.

Entendendo as permissões

drwx—— 2 wester …………. 512 Jan 29 23:30 .. Arquivos/
-rw-rw-r– 1 wester ……. 280232 Dec .. 16 22:41 notas.txt

As linhas acima representam um comando digitado (ls -l) para listar um diretório e suas permissões. O primeiro item que aparece na linha (drwx—– e -rw-rw-r-) é a forma usada para mostrar as permissões que o diretório Arquivos e o arquivo notas.txt têm. É esse item, que recebe o nome de string, que vamos estudar. Um ponto interessante de citar é que o Linux trata todos os diretórios como arquivo também, portanto, as permissões se aplicam de igual forma para ambos. Tais permissões podem ser divididas em quatro partes para indicar: tipo, proprietário, grupo e outras permissões. O primeiro caractere da string indica o tipo de arquivo: se for “d” representa um diretório, se for “-” equivale a um arquivo. Entretanto, outros caracteres podem aparecer, já que existem outros tipos de arquivo no Linux, conforme mostra a tabela abaixo:

d => diretório
b => arquivo de bloco
c => arquivo especial de caractere
p => canal
s => socket
– => arquivo normal

Repare agora que no restante da string temos 9 caracteres. Você já sabe o que significa o primeiro. Os demais são em 3 grupos de 3, cada um representado o proprietário, o grupo e todos os demais respectivamente. Pegando a linha 2 do exemplo (-rw-rw-r-) e dividindo a string em 3 partes, ficaria assim:

-rw => indicação de permissões do proprietário
-rw => permissões do grupo que o usuário pertence
-r- => permissões para os demais usuários

Vamos entender agora o que significa esses caracteres (r, w, x, -). Existem 3 tipos básicos de permissões: leitura, gravação e execução. Leitura permite aos usuários ler o conteúdo do arquivo mas não altera-lo. Gravação permite que os usuários alterem o arquivo. Execução, como o nome diz, permite que o usuário execute o arquivo, no caso de ser executável. Mas acontece que as permissões não funcionam isoladamente, ou seja, ou o usuário tem permissão de leitura ou de gravação ou de execução. As permissões funcionam em conjunto. Isso quer dizer que cada arquivo/diretório tem as 3 permissões, cabendo ao dono determinar qual dessas permissões é habilitada para os usuários ou não. Pode ser que uma determinada quantidade de usuários tenha permissão para alterar um arquivo, mas outros não. Daí a necessidade de se usar grupos. Neste caso, a permissão de gravação desse arquivo será dada ao grupo e todo usuário membro dele poderá alterar o arquivo.

É necessário ter um certo cuidado com as permissões. Por exemplo, do que adianta o usuário ter permissão de gravação se ele não tem permissão de leitura habilitada? Ele poderá ler o arquivo para poder modifica-lo? Não! De certo, isso tem utilidade em arquivos de log. Fazendo associação com as letras r, w, x e o caractere -, vamos entender cada uma:

r => significa permissão de leitura (read);
w => significa permissão de gravação (write);
x => significa permissão de execução (execution);
– => significa permissão desabilitada.

A ordem em que as permissões devem aparecer é rwx. Sendo assim, vamos entender as strings do nosso exemplo, dividindo-a em 4 partes:

Linha 1:
drwx—— 2 wester …………… 512 Jan 29 23:30 .. Arquivos/

é um diretório (d);
o proprietário pode altera-lo, grava-lo e executa-lo (rwx);
o grupo não pode altera-lo, grava-lo e nem executa-lo (—);
os demais usuários não podem altera-lo, grava-lo e nem executa-lo (—).

Linha 2:
-rw-rw-r– 1 wester ………. 280232 Dec .. 16 22:41 notas.txt

é um arquivo (-);
o proprietário pode altera-lo, grava-lo, mas não executável. Como este arquivo não é executável, a permissão de execução aparece desabilitada (rw-);
o grupo tem permissões idênticas ao proprietário (rw-);
o usuário somente tem permissão de ler o arquivo, não pode altera-lo (r–)

A tabela abaixo mostra as permissões mais comuns:

— => nenhuma permissão;
r– => permissão de leitura;
r-x => leitura e execução;
rw- => leitura e gravação;
rwx => leitura, gravação e execução.

Configurando permissões com chmod

Acima, você dever tido pelo menos uma noção do que são permissões e sua importância no Linux. Chegou a hora de aprender a configurar permissões e isso é feito através do comando chmod (de change mode). Um detalhe interessante deste comando é que você pode configurar permissões de duas maneiras: simbolicamente e numericamente. Primeiramente veremos o método simbólico.

Para ter uma visão mais clara da forma simbólica com o chmod, imagine que tais símbolos se encontram em duas listas, e a combinação deles gera a permissão:

Lista 1
Símbolo
u => usuário
g => grupo
O (letra o maiúscula) => outro
a => totos

Lista 2
Símbolo
r => leitura
w => gravação
x => execução

Para poder combinar os símbolos destas duas listas, usam-se os operadores:

+ (sinal de adição) => adicionar permissão
– (sinal de subtração) => remover permissão
= (sinal de igualdade) => definir permissão

Para mostrar como essa combinação é feita, vamos supor que você deseje adicionar permissão de gravação no arquivo teste.old para um usuário. Então o comando a ser digitado será:

chmod u+w teste.old

O “u” indica que a permissão será dada a um usuário, o sinal de adição (+) indica que está sendo adicionada a permissão e “w” indica que a permissão que está sendo dada é de gravação.

Caso você queira dar permissões de leitura e execução ao seu grupo, o comando será:

chmod g+rw teste.old

Agora, vamos supor que o arquivo teste.old deverá estar com todas as permissões disponíveis para o grupo. Podemos usar então:

chmod g=rwx teste.old

Dica: crie arquivos e diretórios e teste a combinação de permissões com chmod. Isso lhe ajudará muito no entendimento deste conceito.

Usando chmod com o método numérico

Usar o chmod com valores numéricos é algo bastante prático. Em vez de usar letras como símbolos para cada permissão, usam-se números. Se determinada permissão é habilitada, atribui-se valor 1, caso contrário, atribui-se valor 0. Sendo assim, a string de permissões r-xr—– na forma numérica fica 101100000. Essa combinação de 1 e 0 é um número binário. Mas temos ainda que acrescentar a forma decimal (ou seja, números de 0 a 9). Para isso, observe a tabela abaixo:

Permissão Binário Decimal
000 0
–x 001 1
-w- 010 2
-wx 011 3
r– 100 4
r-x 101 5
rw- 110 6
rwx 111 7

Se você não conhece o sistema binário deve estar se perguntando o que esse “monte” de 0 e 1 tem a ver com os números de 0 a 7. Como o sistema binário somente trabalha com os números 0 e 1 (decimal trabalha com os números de 0 a 9, ou seja, é o sistema de numeração que utilizamos no nosso dia-a-dia), ele precisa de uma seqüência para representar os valores. Sendo assim, na tabela acima, a coluna Binário mostra como são os valores binários dos números de 0 a 7 do sistema decimal.

Chegou a hora então de relacionar a explicação do parágrafo acima com a coluna Permissão. Para exemplificar, vamos utilizar a permissão rw-, cujo valor em binário é 110, que por sua vez, em decimal corresponde ao número 6. Então, em vez de usar rw- ou 110 para criar a permissão, simplesmente usa-se o número 6. Repare então que com o método numérico, usamos somente um dígito para representar uma permissão, ao invés de três. Com isso a string de permissões r–r–r– pode ser representa por 444, pois r– em decimal é igual a quatro. Observe o exemplo abaixo:

chmod 600 notas.txt

Acima, estão sendo dadas as permissões rw——- ao arquivo notas.txt, pois 6 equivale a rw- e 0 equivale a —. Como zero aparece duas vezes, forma-se então o valor 600. Faça o comando acima com um arquivo de teste e depois digite ls- l notas.txt e veja o que aparece (notas.txt deve ser substituído pelo arquivo que você está usando para teste). A tabela abaixo mostra as configurações de permissões mais usadas:

As três últimas permissões da tabela são freqüentemente usadas para programas e diretórios.

Como você viu, é muito mais prático utilizar o chmod com método numérico. Mas você pode ter ficado confuso com todo esse esquema de permissão. No entanto, talvez isso não tenha sido por causa da minha possível ineficiência ao explicar permissões nesta coluna. A questão é que nos sistemas baseados em Unix, permissões são um dos aspectos mais complexos existentes. Tal complexidade é equivalente à eficiência do uso de permissões. Por isso, a melhor maneira de entender as permissões é treinando. Sendo assim, ao trabalho! Treine, crie permissões e veja seus resultados. Bom aprendizado!

Fonte: www.infowester.com.br

——— 000
r——– 400
r–r–r– 444
rw——- 600
rw-r–r– 644
rw-rw-r– 666
rwx—— 700
rwxr-x— 750
rwxr-xr-x 755
rwxrwxrwx 777

Utilização do CRONTAB


1. Apresentação
CRON ou CRONTAB, é um agendador de tarefas, utilizado para executar algo automaticamente em determinados momento/tempo.

2. Configurando
O crontab tem seu funcionamento bem simples, mas requer atenção para a sua projeção.
Para editar ele, basta executar o comando:
# crontab -e

Irá abrir uma janela estilo o editor de texto “vi”.
Seus comandos são iguais ao “vi”, então, sem problemas …
INSERT – para editar
ESC – para finalizr edição
:x! – salvar e sair
:q! – sair sem salvar

* * * * * comando
| | | | | |_ _ _ _ Comando a ser executado
| | | | |_ _ _ _ _ Semana (0-7 – domingo à domingo)
| | | |_ _ _ _ _ _ Mês (01-12)
| | |_ _ _ _ _ _ _ Dia (01-31)
| |_ _ _ _ _ _ _ _ Hora (00-23)
|_ _ _ _ _ _ _ _ _ Minuto (00-59)

2.1. Minuto
Varia de 00 à 59

2.2. Hora
Varia de (00 à 23)

2.3. Dia
Varia de 01 à 31
Lembrando sempre que ao executar uma tarefa nos dias acima de 28, essa tarefa não será executa no mês de fevereiro.
Usando o dia 31, você irá eliminar todos os meses que terminam em 30 ou menos.

2.4. Mês
Varia de 01 à 12
Podendo também ser usando nomes em inglês (digitados em MAIÚSCULOS ou minúsculos).
Use apenas as 3 primeiras letras do nome.

2.5. Semana
Varia de 0 à 6 ou 1 à 7
Sendo, assim: 0 à 6 de domingo à sábado ou 1 à 7 de segunda à domingo.
Podendo também ser usando nomes em inglês (digitados em MAIÚSCULOS ou minúsculos).
Use apenas as 3 primeiras letras do nome.

2.6. Comando
O comando é você que define, é importante lembrar que o “%” (porcento) é usado para quebra de linha, então, caos você queira usá-lo, digite: “\%”, usando a “\” barra invertida antes.

3. Caracteres especiais
Você pode também trabalhar com “coringas”, veja abaixo alguns exemplos.

3.1. Usando “*”
Executar uma tarefa (“echo teste”) sendo que por 10 minutos, usando o “*”, seja:
–>  10 * * * * echo teste

3.2. Usando “/”
Executar uma tarefa de 5 em 5 minutos, usando o “/”, seja:
–>  */5 * * * * echo teste

3.3. Usando “/”
Executar uma tarefa de 5 em 5 minutos durante os 30 primeiros minutos, usando o “/”, seja:
–>  0-30/5 * * * * echo teste

3.4. Usando “-“
Executar uma tarefa no período de 0 à 5 minutos, usando o “-“, seja:
–>  0-5 * * * * echo teste

3.5. Usando “,”
Executar uma tarefa no minuto 1, 3 e 5, usando a “,” (vírgula), seja:
–>  1,3,5 * * * * echo teste

4. Exemplo
Executando uma tarefa dia 15/03, quando for segunda-feira, no horário das 23h e 54min.

54 23 15 03 01 echo “Exemplo de tarefa”
|  |  |  |  |  | _ _ _ _ Comando a ser executado
|  |  |  |  |_ _ _ _ _ _ Semana
|  |  |  | _ _ _ _ _ _ _ Mês
|  |  |_ _ _ _ _ _ _ _ _ Dia
|  | _ _ _ _ _ _ _ _ _ _ Hora
|_ _ _ _ _ _ _ _ _ _ _ _ Minuto

Papo construtivo com Jabber ou openfire

jabber

No meio de uma reunião importante, resolvendo um caso urgentíssimo todos ali na empresa conectados ao msn discutindo ações e coisas importantes, quando menos espera “PUTZ O SERVIDOR DO MSN CAIU”.. Sei que não é constantemente que isso acontece mas pode acontecer, e visando por este lado é melhor se prevenir e isso é o que mostrarei neste tuto. Como instalar um servidor jabber.

Mas o que é um servidor jabber?

Um servidor Jabber nada mais é que um “MSN interno”, mas com vantagens, pois você pode monitorar e somente deixar se registrar quem quiser, pode colocar para que funcione somente internamente e pode colocar para funcionar em uma VPN com filiais, evitando ligações de ramal para ramal, ou de filial para matriz, ou filial para filial.

Mas porque não uso o msn padrão?

Bem, o querido MSN pode trazer vírus que algum usuário gente boa aceite e o tempo que se gasta conversando com pessoas que não são do trabalho? viiii. E a ocupação de banda? Aí pronto, já deu pra convencer né?

Mas existem servidores externos?

Sim existem, o mais conhecido é o jabber.org, também temos o soapbox.net e por aí vai.

Mas imagine você fazer uma implantação dessas na empresa e um certo dia o servidor do jabber.org cai (coisa que já me aconteceu muitas vezes) e seu chefe quer falar com a filial pelo Jabber ou com as outras pessoas, já viu né, você é chamado disso e daquilo…

Então, vamos montar nosso servidor Jabber! 🙂

Primeiro passo é baixar todas as dependências que nem são muita:

Se não instalar todos o jabber não roda de jeito algum…

ftp://ftp.ossp.org/pkg/lib/pth/pth-1.4.1.tar.gz

Baixe ele e extraia com o tar:

$ tar -zxvf pth-1.4.1.tar.gz

Entre na pasta correspondente:

$ cd pth-1.4.1.tar.gz

Agora:

$ ./configure
$ make
$ make test
# make install

Download:

Caso o link não funcione, procure em:

Extraia ele:

$ tar -vzxf jabberd-1.4.4.tar.gz

Bem, agora entre na pasta que foi criada:

$ cd jabberd-1.4.4
$ ./configure
$ make
# make install

Prontinho, o Jabber está instalado, agora vamos instalar o jabber quickstart, um aplicativo que serve para ajudar na administração do serviço, muito bom aliás.

Baixe o jabberd-quickstart-0.2-linux.tar.gz em:

Descompacte lá na mesma pasta em que descompactou o Jabber, ele vai criar outra pasta, a jabberd-quickstart. Entre nela e dê:

$ chmod 777 *

Dê um:

$ sh setup.sh

Pronto, vai abrir uma tela, vamos configurar.

1. Clique na primeira opção e registre o número IP ou DNS da sua máquina.

2. Ele vai perguntar qual o nome da máquina, da rede, blablabla, tudo opcional.

3. Vai perguntar a conta do administrador, digite o seu nome, depois uma senha.

Pronto, agora clique em outra opção chamada “START”, o resto você vai configurando por intuição, nada muito difícil. Seu servidor está iniciado, agora vá em um cliente em outra maáuina e digite usuarioquevccriou@ip com a sua senha.

NÃO ESQUECENDO O SEGUINTE:

Digite:

# iptables -F

Pois o iptables dele vem com uma configuração defaut que bloqueia o serviço, depois você vai bloqueando e liberando o que quiser.

E pronto, sei que fui muito objetivo, mas QUALQUER dúvida irei responder, não quis foi me estender muito.

Espero ter ajudado alguém, precisei muito de um tuto desses e não encontrei muita coisa, por isso eu fiz esse pra ajudar vocês!

Agora vc tb pode utilizar o openfire que tem a mesma função e é mais fácil de instalar, siga abaixo.

1. É necessário instalar o JAVA(JRE).

Baixe o binário do JAVA em:

Download jre-6u7-linux-i586-rpm.bin

Caso o link não funcione, acesse a página de downloads da Sun (Java) em:

Java Downloads for All Operating Systems

2. Salve este arquivo em uma pasta separada, de preferência em /opt/jre/.

3. Agora acesse o seu terminal preferido como usuário ROOT:

# cd /opt/jre/
# chmod a+x jre-6u3-linux-i586-rpm.bin
# ./jre-6u3-linux-i586-rpm.bin

Aparecerá um termo de licença do Java, tecle [ENTER] até aparecer a pergunta se você concorda ou não. Informe [YES].

Automaticamente o pacote será descomprimido e instalado.

4. Baixe o pacote do OPENFIRE em:

Download openfire-3.6.0a-1.i386.rpm

Caso o link não funcione, procure no site do desenvolvedor:

Ignite Realtime downloads

5. Salve o arquivo em uma pasta separada, de preferência em /opt/openfire/.

6. Vamos instalar o servidor openfire, novamente como usuário ROOT:

# cd /opt/openfire/
# rpm -ivh openfire-3.6.0a-1.i386.rpm

Após a instalação é necessário iniciar o serviço do openfire:

# /opt/openfire/bin/openfire.sh

Agora aguarde, pois este procedimento pode demorar, ele inicia o levantamento do servidor, scripts e portas de escuta.

Estará tudo ok quando aparecer algo assim:

Openfire 3.6.0a-1 [16/010/2008:12:10]
Console de Administração ouvindo em http://localhost:9090

Etapa 5: Finalização.

Bem, agora entre na pasta que foi criada e la dentro tem uma pasta chamada bin e dentro dela contem o arquivo para inicializar o openfire, se quiser pode copiar ele pro /usr/local/sbin e por no rc.local pra inicializar automatico, basta inserir a linha /usr/local/sbin/openfire start caso contrário na própria pasta de um ./openfire start para inicializar o serviço depois acesse no browser http://localhost:9090 e administre o seu servidor jabber.
Após feito tudo isso você irá precisar de um cliente jabber ou seja um softw semelhante ao msn para comunicar, eu indico o spark ou o pandion mas qualquer outro irá servir muito bem e aqui estão eles.

http://www.jabber.org/web/Clients#Windows