Nerdica: renomear multiplos arquivos no console

yo!

Depois de um tempo parado, vamos com um tema novo (ainda em testes :P ) e o que importa: conteúdo.

Uma nerdica rápida sobre como renomear arquivos rapidamente no console. Por exemplo, renomear todos os arquivos que tenham JPG em maiúscula para jpg (minúsculo):

 

for file in `ls f*.JPG`; do export s=`echo $file | sed ‘s/JPG/jpg/g’`; mv $file $s; done

Se quiser testar antes de executar, basta trocar o mv em “mv $file $s” para echo, ficando “echo $file $s”.

 

 

 

Usando o chmod

Nesse tutorial entenderemos as permissões de arquivos mais usadas. Percebo que a maioria das vezes tenho muita dificuldade com permissionamento de arquivos por ficar com dúvida ou por não lembrar. Mostrarei de forma clara e objetiva o funcionamento das permissões no Linux.

Ao listar um arquivo com o comando:

# ls -l arquivo

Ele mostrará:

Tipo  Dono   Grupo  Outros  Arquivo
 -     ---    ---    ---    arquivo

Onde:

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.

O primeiro dígito determina o tipo de arquivo, os três seguintes a permissão do dono do arquivo, os três do meio a permissão do grupo que o arquivo pertence e os últimos a permissão de outros usuários. A regra para as permissão sempre será:

--- : 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.

As permissões para melhor entendimento se tratando das numéricas são:

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
Comando      Número      Permissão     Status
 chmod        000        ----------    Nenhuma
 chmod        400        -r--------    Leitura apenas para o dono
 chmod        444        -r--r--r--    Leitura para o dono, grupo e outros
 chmod        600        -rw-------    Leitura e gravação apenas para o dono
 chmod        620        -rw--w----    Leitura e gravação para o dono, gravação para o grupo
 chmod        640        -rw-r-----    Leitura e gravação para o dono, e leitura para o grupo
 chmod        644        -rw-r--r--    Leitura e execução para o dono, leitura para o grupo e leitura para outros
 chmod        645        -rw-r--r-x    Leitura e gravação para o dono, leitura para o grupo e leitura e execução para outros
 chmod        646        -rw-r--rw-    Leitura e gravação para o dono, leitura para o grupo e leitura e gravação para outros
 chmod        650        -rw-r-x---    Leitura e gravação para o dono e leitura e execução para o grupo
 chmod        660        -rw-rw----    Leitura e gravação para o dono e leitura e gravação para o grupo
 chmod        661        -rw-rw---x    Leitura e gravação para o dono, leitura e gravação para o grupo e execução para outros
 chmod        662        -rw-rw--w-    Leitura e gravação para o dono, leitura e gravação para o grupo e gravação para outros
 chmod        663        -rw-rw--wx    Leitura e gravação para o dono, leitura e gravação para o grupo e leitura e execução para outros
 chmod        664        -rw-rw-r--    Leitura e gravação para o dono, leitura e gravação para o grupo e leitura para outros
 chmod        700        -rwx------    Leitura gravação e execução para o dono e nada para os demais
 chmod        770        -rwxrwx---    Leitura e gravação e execução para o dono, leitura gravação e execução para o grupo e nada para outros
 chmod        777        -rwxrwxrwx    Permissão total para dono, grupo e outros

Usando o crontab

Crontab é um programa onde são especificados os comandos a serem executados e a hora e dia de execução pelo cron, um programa que executa comandos agendados nos sistemas operacionais do tipo Unix (como o Linux ou o Minix, por exemplo). O cron se encarregará de verificar a hora e determinar se existe ou não algum programa a ser rodado. Caso exista ele o rodará na hora e data solicitada.

Sintaxe:

Dentro do arquivo que se abre após o comando existe uma sintaxe conforme a seguir:

mm hh dd MM ss user script

00 13  *  *  * root /root/exemplo_script

Exemplo de script que roda todos os dias as 13 horas, com usuário root. Agora vamos detalhar mais este comandos.

mm = minutos, informe números de 0 a 59;

hh = hora, informe números de 0 a 23;

dd = dia, informe números de 0 a 31;

MM = mês, informe números de 1 a 12;

ss = dia da semanada, informe números de 0 a 6;

user  =  é o usuário que vai executar o comando (não é necessário especificá-lo se o arquivo do próprio usuário for usado);

script = a tarefa que deve ser executada.

  •  Obs 1: Em dia_da_Semana, 0 refere-se a domingo; e 6, ao sábado. No caso de dia da semana funciona também as três primeiras letras (em inglês) do dia da semana (SUN,MON,TUE,WED,THU,FRI,SAT);
  •  Obs 2: Em qualquer posição pode-se usar o * (asterisco) quando não se importar com o campo em questão;
  •  Obs 3: Pode-se utilizar intervalos nesses campos. O caracter para intervalo é o – (hifen);
  •  Obs 4: Pode-se utilizar lista de valores nesses campos. O caracter para a lista é a , (vírgula);
  •  Obs 5: Qualquer texto colocado após o programa que será executado será considerado comentário e não será interpretado pelo cron.

Seguem alguns exemplos:

Todo dia de hora em hora (hora cheia)

00 * * * * /bin/script

De cinco em cinco minutos todos os dias (note a divisão por 5 do intervalo 00-59)

00-59/5 * * * * /bin/script

Nas seguintes horas: 10, 12, 16, 18, 22 aos 15 minutos da hora

15 10,12,16,18,22 * * * /bin/script

Nos primeiros cinco dias do mês às 19:25

25 19 01-05 * * /bin/script

De segunda a sexta ao meio-dia e a meia-noite

00 00,12 * * 1-5 /bin/script

Script rodar Segunda,Quarta,Sexta às 2 horas

0 2 * * mon,wed,fri /bin/script

Script para rodar Terça,Quinta às 3 horas

0 3 * * tue,thu /bin/script

Script para ser executado minuto a minuto

*/1 * * * * /bin/script

XFCE 4.10 no Slackware 13.37

yo! Vamos a mais uma dica para o Slackware Linux, a distro que simplesmente funciona.

O xfce padrão do Slackware 13.37 é o 4.6.2 e ele já está um pouco velhinho. Felizmente ficar de olho no fórum[1] do Slackware Linux sempre traz boas dicas e foi lá que achei algumas pessoas que compilaram e disponibilizaram[2] pacotes do xfce 4.10. Eu vou complementar esse novo xfce com alguns pacotes do slackbuilds.org, melhorando o ambiente mas não pense nesse artigo como algo para ter um super xfce completo,  mesmo porque o completo pode significar algo diferente para nós.

Vamos instalar alguns slackbuilds primeiro. Se você já tiver algum instalado, apenas ignore.

sbopkg -i "webcore-fonts gtk-aurora-engine gtk-engines gtk-nodoka-engine equinox murrine tls libnice gst-python farsight2 libmusicbrainz3 dconf gnome-mplayer ORBit2 GConf libtasn1 libatasmart sg3_utils"

Eu tive problemas ao instlar o udisks e upower pelo sbopkg. O problema é com um argumento errado em alguns Makefile e para corrigir isso, basta, como root, entrar no diretório /var/lib/sbopkg/SBo/13.37/system/udisks/ e editar o arquivo udisks.Slackbuild e acrescentar por volta da linha 84 (antes do make):

* UPDATE * : esse problema com o udisks e upower não ocorreu no Slackware 64bits, somente na versão i486.

sed -i s/-nonet//g doc/dbus/Makefile*
sed -i s/-nonet//g doc/man/Makefile*

Desse modo o arquivo udisks.Slackbuild fica assim:

./configure \
  --prefix=/usr \
  --libdir=/usr/lib${LIBDIRSUFFIX} \
  --sysconfdir=/etc \
  --localstatedir=/var \
  --mandir=/usr/man \
  --docdir=/usr/doc/$PRGNAM-$VERSION \
  --build=$ARCH-slackware-linux

sed -i s/-nonet//g doc/dbus/Makefile*
sed -i s/-nonet//g doc/man/Makefile*

make
make install DESTDIR=$PKG

 

Agora é só gerar o pacote e instalar:

wget `grep DOWNLOAD= udisks.info|cut -d= -f2|sed s/\"//g `
./udisks.Slackbuild
installpkg /tmp/udisks-*.t?z

Depois faça a mesma coisa com o upower em /var/lib/sbopkg/SBo/13.37/system/upower.  Após instalar, termine adicionando mais esses pacotes:

sbopkg -i "libdaemon libunique libsoup libproxy libgnome-keyring gnome-keyring avahi gvfs"

Se você tiver o xfce padrão do slackware, será necessário removê-lo antes:

removepkg /var/log/packages/xfce*
removepkg /var/log/packages/thunar*

Agora baixe os pacotes do xfce para i386[3] ou para amd64[4] (não se esqueça do pacote no diretório dep) e então é só instalá-los:

installpkg *.t?z

Por fim, atualize seu .xinitrc executando o xwmconfig.

E tudo pronto! Agora você possui o xfce mais novo.

 

[1]: http://www.linuxquestions.org/questions/slackware-14

[2]: http://www.linuxquestions.org/questions/slackware-14/xfce-4-10-a-937767/page3.html

* UPDATE * : atualizei os links abaixo pois os antigos não existe mais

[3]: http://download.tuxfamily.org/salixbang/depot/i486/13.37/salixbang/xfce/

[4]: http://download.tuxfamily.org/salixbang/depot/x86_64/13.37/salixbang/xfce/

Slackware64 + multilib + KDE 4.8 + Virtualbox + wine

yo! Nesse artigo vou mostar como usar o Slackware64 “rolling-release”, também conhecido como -current. Como o foco é desktop, vou mostrar com habilitar o suporte à multilib que é necessário para o wine e o virtualbox.

Os nossos passos serão:

- Baixar o mutilib e o kde 4.8.0

- Instalar o Slackware64 13.37

- Atualizar para o -current

- Instalar o multilib

- Instalar o driver de vídeo proprietário no caso de placas da NVIDIA ou AMD

- Instalar o kde 4.8.0

- Compilar e instalar o wine

- Instalar o Virtualbox

 

Passo 1: Baixar o mutilib e o kde 4.8.0

Primeiro vamos baixar o multlib e o kde-4.8.0 e deixá-los num pen-drive ou partição para já instalarmos logo após atualizar para o current:

rsync -av --delete rsync://taper.alienbase.nl/mirrors/alien-kde/4.8.0/x86_64/deps /mnt/alien/kde48/deps/
rsync -av --delete rsync://taper.alienbase.nl/mirrors/alien-kde/4.8.0/x86_64/kde /mnt/alien/kde48/kde/
wget http://taper.alienbase.nl/mirrors/alien-kde/4.8.0/x86_64/kdei/kde-l10n-pt_BR-4.8.0-noarch-1alien.txz
rsync -av --delete rsync://taper.alienbase.nl/mirrors/people/alien/multilib/current /mnt/alien/multilib/

Pronto. Vamos para o próximo passo.

 

Passo 2: Instalar o Slackware64 13.37

Não vou explicar como instalar o Slackware Linux, já espero que você saiba como fazê-lo.

Durante a instalação não é necessário instalar o kde, afinal vamos usar o kde mais novo do alien.

 

Passo 3: Atualizar para o -current

Agora vamos atualizar o novo sistema para a versão -current.

Edite o /etc/slackpkg/mirrors escolhendo um mirror e mudando o 13.37 para current.

Atualize para o current:

slackpkg install-new
slackpkg upgrade-all

Quando o slackpkg perguntar se quer rodar o lilo, diga que sim (Y). Quando ele perguntar sobre o arquivos de configuração novos, respoda que quer sobrescrever.

Reinicie o sistema e depois vamos ao próximo passo.

 

Passo 4:  Instalar o multilib

Monte o pen-drive ou partição aonde salvou o multilib e o kde 4.8:

mkdir /mnt/alien
mount /dev/sdb1 /mnt/alien
cd /mnt/alien/mutilib/current
upgradepkg --reinstall --install-new *.t?z
upgradepkg --reinstall --install-new slackware64-compat32/*-compat32/*.t?z

Pronto. Agora vamos colocar os pacotes do alien na blacklist do slackpkg para evitar que ao atualizar o slackware você sobrescreva os pacotes da glibc e do gcc.

Edite o /etc/slackpkg/slackpkg.conf e adicione no final do arquivo:

# Alien's multilib packages
 [0-9]+alien

 

Passo 5: Instalar o driver proprietário de vídeo

Essa parte é só para quem tem placa de vídeo da NVIDIA ou AMD e quer usar o driver proprietário. Não vou explicar como executar o procedimento em si (entrar no site do fabricante, baixar o driver e executar a instalação), mas deixarei registrado a pós-instalação.

Contudo, antes um detalhe importante: é necessário instalado o mutilib antes do driver de vídeo, assim ele detecta que o sistema suporta 32bits e já instala as bibliotecas 32bits junto com as 64bits.

Após a instalação do driver, adicione o driver opensource na blacklist:

Para placas AMD:
echo "radeon" >> /etc/modprobe.d/blacklist.conf
Para placas ATI:
echo "nouveau" >> /etc/modprobe.d/blacklist.conf

Isso é imporante pois o driver opensource “conflita” com o driver proprietário e coisas estranhas acontecem se os dois estiverem carregados.

E depois configure o xorg, bastando criar o arquivo /etc/X11/xorg.conf.d/50-device.conf:

Section "Device"
   driver "fglrx"
EndSection

Passo 6: Instalar o kde 4.8.0

Para instalar o kde, você tem 2 opções:

1. Pode instalar tudo com upgradepkg –reinstall –install-new kde/*t?z

2. Pode instalar só o que precisa, então entre no diretório do kde e execute pkgtool. Ele irá mostrar o pacote com sua descrição e então você escolhe quer instalar ou não. Lembre-se se instalar o pacotes importante do kde (kde-*, kdeadmin*, kdeartwork*, kdegraphics*, kdelibs*, kdemultimedia*, kdenetwork*, kdepim* kdeplasma*, ark*, kcalc*, kcolor*, konsole*, ksecrets*, kwallet*, kwebkitpart*, lib*, marble*,  okular*, oxygen*, perl*, polkit*, pykde*, qtruby*)

cd /mnt/alien/kde48
upgradepkg --reinstall --install-new deps/*.t?z

Procure por novos arquivos de configuração: slackpkg new-config

Instale o pacote de idioma: installpkg kde-l10n-pt_BR-4.8.0-noarch-1alien.txz

Pronto. Reinicie o computador.

 

Passo 7: Compilar e instalar o wine

O wine não funciona bem em 64bits, pelo menos por enquanto e por isso precisamos do multilib (sem contar outros programas como o skype).

Um detalhe importante é que você pode instalar as dependências somente em 32bits. No meu caso eu instalo o pacote 64bits e refaço o pacote 32bits para só possuir a libs e os binários. Logo abaixo mostrei as duas opções.

Vamos precisar e instalar dos slackbuilds (na ordem): OpenAL, fontforge, webcore-fonts, prelink e wine. Desses só o webcore-fonts é que pode ser instado 64bits já que ele não depende de arquitetura.

sbopkg -i webcore-fonts

Para instalar os slackbuilds 32bits são necessários dois passos: o primeiro é rodar o script 32dev.sh do Alien que serve para preparar o ambiente e o segundo é alterar a variável LIBDIRSUFFIX do arquivo pacote.Slackbuild. Também vamos alterar o OUPUT para gerar o pacote num diretório especifico ao invés do padrão que é o /tmp. Irei mostrar para como fazer isso para um dos pacotes e cabe a você fazer nos outros.

O pacote será o OpenAL

Edite o OpenAL.Slackbuild e altere:

de: OUTPUT=${OUTPUT:-/tmp}
para: OUTPUT=${OUTPUT:-/home/slackbuilds32}

e em outra linha

de: elif [ "$ARCH" = "x86_64" ]; then
 SLKCFLAGS="-O2 -fPIC"
 LIBDIRSUFFIX="64"

 para:
 elif [ "$ARCH" = "x86_64" ]; then
 SLKCFLAGS="-O2 -fPIC"
 LIBDIRSUFFIX=""

Lembre-se de criar o diretório /home/slackbuilds32

Prepare o ambiente para compilação 32bits:

. /etc/profile.d/32dev.sh

(sim, o . antes faz parte do comando)

Compile o slackbuild:

./OpenAL.Slackbuild

Tudo pronto. Agora é que tem a diferença que comentei no ínicio dessa parte.

Se você quiser ter apenas a versão 32bits, então basta instalar o pacote com o comando installpkg /home/slackbuilds32/OpenAL*.t?z

Se você quiser ter o pacote 64bits e as libs e binários do mesmo em 32bits, então vamos modificar o pacote 32bits para só instalar as libs e os binários. Para isso:

cd /home/slackbuilds32
tar xvf OpenAL*.t?z

Irão surgir os diretórios aonde o pacote instala seus arquivos, que geralmente são install, usr e etc. Precisamos apagar o etc, usr/doc, usr/man, usr/share/ usr/include e quaisquer outros diretórios que sejam independente de arquitetura.

Depois movemos os binários para um outro diretório:

mkdir usr/bin/32
mv usr/bin/{arquivos} usr/bin/32/
mv usr/sbin/* usr/bin/32/
NOTA: {arquivos} são os binários do programa. Mova-os para do diretório usr/bin para usr/bin/32

Agora refazer o pacote:

tar czf OpenAL-1.13-x86_64-lib32-1.tgz install usr

Agora basta instalar o pacote.

Precisamos instalar a versão 64bits do mesmo programa, para ter os arquivos 64bits e os independente de arquitetura que removemos do pacote 32bits. Para isso, você precisa abrir um outro terminar, já que o atual está modificação para compilação de programas em 32bits. No novo terminar basta instalar o pacote:

sbopkg -i OpenAL

Agora é só repetir os passos com os outros programas.

 

Passo 8: Instalar o Virtualbox

Baixe o Virtualbox de www.virtualbox.org. Por exemplo:

wget http://download.virtualbox.org/virtualbox/4.1.8/VirtualBox-4.1.8-75467-Linux_amd64.run
chmod +x VirtualBox-4.1.8-75467-Linux_amd64.run

entre como root e instale-o com

./VirtualBox-4.1.8-75467-Linux_amd64.run

Para instalar o extension pack e ter suporte à usb, rdp e etc., baixe o extpack e instale

http://download.virtualbox.org/virtualbox/4.1.8/Oracle_VM_VirtualBox_Extension_Pack-4.1.8-75467.vbox-extpack

Por fim, adicione seu usuário no grupo vboxusers:

gpasswd -a seu_usuário vboxusers

 

Tudo pronto! E por fim, seguem algumas dicas:

-  montar pen-drives com ntfs não tem permissão de escrita porque é usado o driver ntfs do kernel ao invés do ntfs-3g. Para corrigir isso faça com root:

 cd /sbin; ln -s mount.ntfs-3g mount.ntfs

Referência: http://www.linuxquestions.org/questions/showthread.php?p=4441319

- configurar o teclado em pt-br:

Crie o arquivo /etc/X11/xorg.conf.d/10-keyboard.conf:

Section "InputClass"
        Identifier "mykeyboard"
        MatchIsKeyboard "on"
        Option "XkbLayout" "br"
        Option "XkbOptions" "terminate:ctrl_alt_bksp"
EndSection

Referências:

http://alien.slackbook.org/dokuwiki/doku.php?id=slackware:multilib

http://taper.alienbase.nl/mirrors/alien-kde/4.8.0/

http://alien.slackbook.org/blog/

Patentes da Apple preveem tela holográfica e bateria de um mês

Pensando no futuro, a Apple deixa registradas muitas patentes que parecem ideias de filmes futuristas. No Patently Apple, o blogueiro Jack Purcher mostra alguns desses planos. Um deles é o de um sistema de projeção holográfica, com o qual imagens de dispositivos poderiam ser vistas em 3D sem a necessidade de óculos especiais.

Recentemente, a Apple registrou patente relacionada à tecnologia Liquidmetal, para fazer células de combustível capazes de produzir energia necessária para mais de um mês de uso de um celular. Outra patente registrada é a de um projetor de tela acoplado ao iPhone e ao iPad, capaz de reproduzir as imagens dos aparelhos em superfícies.

Fonte: http://www1.folha.uol.com.br/tec/969491-patentes-da-apple-preveem-tela-holografica-e-bateria-de-um-mes.shtml

iPod

iPad/iPod

Lançado o FreeBSD 8.2 e 7.4 Releases

yo! Saiu ontem os novos releases do FreeBSD, a 8.2-RELEASE e a 7.4-RELEASE. Dentre as novidades da versão 8.2-RELEASE estão:

- Suporte à Xen HVM no FreeBSD/amd64 e Xen PV no FreeBSD/i386 melhorados.

- ZFS on-disk format atualizado para a versão 15.

- Suporte completo à GPT (GUID Partition Table).

- Adicionado o driver aibs(4). Ele suporta os sensores de placas-mãe ASUS e substitui o acpi_aiboost(4).

- O driver xhci(4), que suporta Extensible Host Controller Interface (xHCI) e USB 3.0, foi adicionado.

- O emulador de linux no FreeBSD agora suporta a API video4linux. Ele requer hardware e drivers nativos do video4linux como os disponíveis em multimedia/pwcbsd e multimedia/webcamd.

- O sysinstall agora usa os seguintes número como padrão e mínimo para as partições: 1GB para /, 4GB para /var e 1GB para /tmp.

- O ISC BIND foi atualizado para a versão 9.6-ESV-R3 e o OpenSSL para 0.9.8q.

- O GNOME foi atualizado para a versão 2.32.1.

- O KDE foi atualizado para a versão 4.5.5.

Para mais detalhes, veja a páginas de anúncio[1] e as notas de lançamento[2].

[1]: http://www.freebsd.org/releases/8.2R/announce.html

[2]: http://www.freebsd.org/releases/8.2R/relnotes.html

SSH Reverso

Iae Galera, estou de volta ;P

Bom uma rápida introdução do que é o ssh reverso.

Ssh reverso consiste em: o cliente se conectar ao servidor, assim habilitando o servidor se conectar ao cliente. De que maneira?

Vamos lá!
No cliente o comando é o seguinte:
ssh -R ${porta}:localhost:22 ${login}@${ipservidor}
Na pratica:
ssh -R 2222:localhost:22 user@server.com

Depois do cliente conectado o servidor pode se conectar ao cliente, sem saber o ip e nem nada só pela porta

No servidor fica assim então:
ssh -p ${porta} ${login}@localhost
Na pratica:
ssh -p 2222 user@localhost

Os usuário não precisam ser os mesmo e ambos servidor e cliente, pode ser qualquer usuário existente, por exemplo: do cliente eu acesso o servidor com o usuario “halfling” e do servidor eu acesso o cliente com o usuário “root”

Cliente:
ssh -R 2222:localhost:22 halfling@server.com

Servidor:
ssh -p 2222 root@localhost

Beleza agora que sabem disso, vale lembrar que o acesso não é insento de senhas, você precisa digitar a senha em ambos os casos, cliente e servidor.

Pois bem, agora vamos a uma parte interessante do tipo, pra que serve isso?

Exemplos:
Da minha casa eu deixo uma conexão ssh reversa aberta em um servidor e do meu trabalho consigo acessar o servidor que acesso minha casa.
Coloco num cliente da empresa para se conectar a empresa e da empresa conecto no cliente.
E por ae vai…

Tá bacana até aqui, mas e se o cliente cair, e se reiniciar o PC, como faço?

Bom ae entramos na parte que me fez criar esse artigo.

Primeiro vamos trabalhar com chaves publicas ssh, onde eu autorizo chaves no meu ssh para que entre sem senha.
A idéia é que o cliente entre sem senha no servidor e o servidor entre sem senha no cliente.

Rápida nota sobre chaves.
Criando uma chave:
comando: “ssh-keygen -t rsa”

A chave criada estará em ~/.ssh/id_rsa.pub

Beleza faça isso no cliente e no servidor

Se você der um “cat ~/.ssh/id_rsa.pub” vai ter em sua tela o conteudo da chave.

Muito bem você precisa pegar o conteudo da chave do cliente e inserir dentro de um arquivo no servidor.
O arquivo é: ~/.ssh/authorized_keys
normalmente ele não existe então é só criar, depois de criado adicione a chave do cliente dentro do authorized_keys do servidor e a chave do servidor dentro do authorized_keys do cliente

Muito bem agora cliente e servidor se conectam sem senha um com o outro(com o usuário que você criou a chave)

Beleza, voltando ao conectar automaticamente, mesmo se reiniciar o PC ou cair a conexão.

Com uma grande ajuda do meu pai(Ricardo Leite), criei um script para automatizar a conexão, então segue ele ae:

#!/bin/bash
{
echo “Iniciando SSH REVERSO…”
ipremoto=192.168.1.1 #ip do servidor que você quer se conectar
login=halfling #login que você quer se conectar ao servidor
porta=2222 #porta de conexão com o servidor
dorme=300 #tempo(em segundos) que ele espera pra verificar se a conexão ainda está ativa

iplocal=$(lynx –dump charlesgoncalves.com.br/myip.php | tr -d ‘ ‘) #pega o IP de internet do cliente de um script PHP que retorna o IP de internet
reverso=$(host $(lynx –dump charlesgoncalves.com.br/myip.php) | awk -F ‘ ‘ ‘{print $NF}’ | sed ‘s|\.$||g’) #igual ao anterior, mas depois de pegar o IP ele pega o reverso do IP

while [ 1 ] ; do

porip=$(ssh ${login}@${ipremoto} “who”| grep ${iplocal} | wc -l)#conecta no servidor e vê se já tem conexão aberta pelo IP de internet
porname=$(ssh ${login}@${ipremoto} “who”| grep ${reverso} | wc -l)#conecta no servidor e vê se já tem conexão aberta pelo reverso do IP
#echo “Checa se existe uma conexáo aberta…”
if [ "$porip" -gt "0"  -o "$porname" -gt "0" ] ; then #compara se tem conexão aberta por IP ou por reverso do IP
#echo “Ja esta conectado…”
sleep 1
else #caso não tenha conexão aberta, nem pelo IP nem pelo reverso do IP, abre uma nova conexão
#echo “Conectando…”
screen -wipe #remove as screen mortas
screen -r sshreverso -X quit #mata a screen antiga
screen -AmdS sshreverso ssh -R ${porta}:localhost:22 ${login}@${ipremoto} #abre uma nova  screen com o SSH REVERSO
fi
#echo “durmindo por $dorme segs…”
sleep $dorme #espera o tempo até a próxima checagem
done
} &

Bom tentei comentar ao máximo o que o script faz.

Outra coisa eu coloquei o link pra meu server com meu “myip.php” se você tem seu próprio server e quer por um “myip.php” segue o conteudo do “myip.php” :

<?php $ip=$_SERVER['REMOTE_ADDR']; echo $ip; ?>

Só isso gente espero ter ajudo em algo

Qualquer dúvida mande-me um e-mail nos meus dominios:
@halfling.com.br
@charlegoncalves.com.br

Reproduzir DVD protegiro no Kubuntu 10.04

Como de costume, comprei a coleção completa do homem de aço, um clássico desde os tempos do Christopher Reeve e estava com problemas de reprodução.

Simples, instale o kubuntu-restricted-extras, certo?

Quase..isso é a metade do trampo….para reproduzir dvds protegidos precisamos da libdvdcss2, que agora não se encontra mais no instalador de pacotes.

Para isso, instale (se o restricted-extras não instalou) o pacote libdvdread4

e depois

sudo /usr/share/doc/libdvdread4/install-css.sh

Aproveite e instale o SMPLAYER

É isso, curto, direto ao ponto!

:)

gmirror em slice no FreeBSD

yo! Como está difícil conseguir 2 discos rígidos do mesmo tamanho, mesmo comprando o modelos iguais no final eles são diferentes! Desse modo, fazer raid 1 com geom mirror do disco inteiro como mostra no handbook é impossível. Depois de adquirir 2 discos Samsumg e 2 Western Digital de 500Gb para no final descobrir que eles tem o número de blocos diferentes, eu resolvi tomar uma abordagem diferente e fazer o gmirror do slice, assim não importa o tamanho do disco, apenas o tamanho do slice que é controlado pelo sysadmin.

Existem dois jeitos mais comuns de se fazer isso. O primeiro é com o sistema offline através do Fixit e o segundo é online, criando o raid1 no disco vazio e depois migrando os dados para ele.

A vantagem do primeiro é que é mais rápido o processo todo, pois não é necessário replicar os dados no segundo disco e a desvantagem que vejo é que o sistema precisa ficar offline por cerca de 10 minutos, tempo mais que suficiente para criar o raid1.

Continuar lendo