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

iPad/iPod

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

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

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!

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.

Read more…

Olá a todos, estava tentando instalar o driver da ATI no meu notebook de mesa, no qual chamo carinhosamente de tenebroso (é um P3 – 850 com 256 MB e 20 GB de HD), instalei o driver,  mas quando reiniciei tive uma triste mensagem que não podia carregar meu Xorg, que coisa linda!

Bom como havia feito o backup do meu arquivo xorg.conf, pensei é só copiar e reiniciar. Fiz isso mas não fui muito feliz, pesquisei um pouquinho e descobri como restaura o xorg e vou postar como fiz…

Primeira passo remova seu xorg

# aptitude purge xserver-xorg

Segundo passo instale novamente

# aptitude install xserver-xorg

Depois de instalado, demorou alguns minutos aqui, mas creio que você consiguirá instalar mais rapido. Execute este comando.

# Xorg -configure

Este comando segundo a pesquisa que eu fiz, configura seu xorg com configurações padrões. E tem esta configuração sugerida pelo Debian:

# dexconf

Depois de tudo isso reinicie sua máquina para terminar a restauração, se deu tudo certo irá entrar na sua tela de login.

Bom é só isso e até a próxima!

Pessoal,

Estou divulgando aqui o compilador MASM32 para windows.

( Ref: http://www.masm32.com )

Ele possui umas features interessantes que o tornam muito bom para fazer programas minúsculos.

Tenho um exemplo de programa que é um backdoor para Windows feito pelo WhiteScorpion ele roda na porta 31337.

Este Exemplo é apenas para ilustrar o compilador dá pra ver as features do MASM32 pois é em um programa bastante simples e pequeno que usa recursos de TCP/IP.

Uma das coisas interessantes no MASM32, é que ele implementa um conjunto de pseudo instruções que facilitam muito a vida do programador.

Em Assembly, normalmente, você tem que criar os IFs, criar os WHILEs e todas as estruturas de loop e de condicionais de forma artesanal escrevendo tudo na unha usando as instruções e flags do processador..

Mas as pseudo instruções do MASM32 criam tudo isso para você e sem stress.

Vejam:

.IF eax==SOCKET_ERROR

    invoke WSACleanup

    invoke ExitProcess,eax

.ENDIF

Ele já cria a comparação para o registrador eax sem você ter que esquentar a cabeça. E olhe este WHILE:

.WHILE bytesRead>=1023

        invoke ReadFile,readout,addr bufferout,1023,addr bytesRead,NULL

        invoke lstrlen,addr bufferout

        invoke send,remsock,addr bufferout,eax,0

        mov eax,offset bufferout

        mov ecx,sizeof bufferout

zeromem2:

        mov byte ptr [eax],0

        inc eax

        dec ecx

        test ecx,ecx

        jnz zeromem2

.ENDW

Ele ainda entende os sinais de >,<.>=<= e != . Sem você ter que fazer isso tudo na unha.

Muito mais simples, não é mesmo ?

Qual a vantagem de usar Assembly e não usar um C por exemplo ?

Programas minúsculos, conhecimento do sistema maiúsculo e é muito mais sexy.

Todas as pseudo instruções são precedidas de ponto e dá pra criar macros ainda mais complexas.

Vocês podem pegar o programa exemplo que inclusive é funcional e tem os binários já compilados em: http://www.koflinux.com.br/backdoor.zip

A última e mais polêmica coisa sobre o MASM32 é que o autor é avesso ao GPL. Apesar do MASM32 ser freeware e você puder usa-lo como te der na telha. O autor NÃO quer que se produza programas sob a GPL usando o compilador.

Ah, ia me esquecendo, o programa exemplo que eu passei como exemplo está sob a GPL …

Vejam o que é dito no site do cara:

Exclusion of open source projects and software.

The MASM32 project cannot be used to create open source software or any other project under any form of licence that requires the user of the MASM32 project to surrender the rights they are afforded under the MASM32 licence. In particular the MASM32 licence completely excludes projects licenced under the GNU organisation’s published GPL licence and/or variants.

Em C não se pode criar variáveis no meio do programa.
Deve-se que cria-las somente no início das funções, Certo ?
Errado !

Isso é para Pascal que é amarrado, em C você pode criar as variáveis onde quiser.
Só precisa de um bloco de código que inicia co ‘{‘ (abre chaves) e termina com ‘}’ (fecha chaves).
Ou seja vc pode colocar entre um for(…){ }  entre um while(…) {  } ou até entre um bloco de programa composto apenas de ‘{‘ e ‘}’ …

Assim são válidas as seguintes formas de criar variáveis:

// estude com cuidado este exemplo pois os whiles tem pontos que podem causar bugs lógicos terríveis
//fique atento.
#include <stdio.h>

main(){
        int z=0;
        // neste while o x é zerado toda vez que dá loop
        while(z<=3){
                int x=10; // o valor de x volta a ser 10 noloop.
                printf("x somente existe neste bloco (x=%d)\n",x);
                x++;
                z++;
        }

        // neste while o x não é zerado.
        z=0;
        while(z<=3){
                int x; // o valor de x não é zerado no loop.
                if (z==0) x=0;
                printf("x somente existe nste bloco (x=%d)\n",x);
                x++;
                z++;
        }

        {
                int i;
                for(i=0;i<10;i++){
                        int y=0;
                        printf("i:%d y:%d\n",i,y);

                }
        }
}

Só uma coisa depois do ‘}’ fecha chaves o programa desconhece a variável, ela só vale para dentro daquele bloco. ou seja, é uma variável local do bloco e se for referenciada fora do bloco trata-se de OUTRA variável e não a mesma.
Por exemplo:

#include <stdio.h>
main(){
        int x=10;

        printf("x vale:%d\n",x);

        {
                int x=123;
                printf("x vale:%d\n",x);
        }

        printf("x vale:%d\n",x);
}

Nesse exemplo o x vale 123 somente dentro do bloco onde ele é referenciado, fora ele vale 10... o resultado pro programa é:
x vale:10
x vale:123
x vale:10

Também deve-se observar que dentro de um loop se declaramos um valor inicial á variável este valor inicial é novamente carregado na variável assim que ocorrer o loop.
Isso não deve ser esquecido (ler primeiro exemplo de código com cuidado).

Imagine agora que você tem um programa com uma função que é pequena e você só usa uma vez. e você quer refatorar e colocar esta função dentro do programa principal.
Basta copiar o conteúdo da função dês do ‘{‘ até o ‘}’. Não tem que mover as variáveis locais para fora nem nada disso. Somente tem que passar os parâmetros de outra forma mudando o nome das variáveis de parâmetro para os valores ou variáveis do programa principal.

Esite um outro uso: Alguns trechos do programa exigem variáveis que somente serão usadas naquele lugar. Então não é necessário declarar as variáveis lá no inicio da função ou como global. Você pode declarar dentro do bloco local. Isso é bom para usar a memória somente quando necessário.

/*
Pessoal,

Todos que usam C e C++ com mais seriedade sabem que a utilização da
memória pode ser um problema.
Matreizes dinâmicas, ponteiros de char e tudo o mais que pode crescer
e explodir o programa.
Não seria bom se a linguagem C tivesse um recurso para controlar a
memória ? Em alguns projetos, sim. Em outros é bom ter um controle
manual da memória.
Tudo que é automático falha automaticamente.
Mas e se fosse possível usar este recurso sempre que for conveniente
sem perder o poder de poder fuçar na unha quando for necessário ?

Hmmmm agora estamos falando como programadores de verdade!

A linguagem C é extensível e existe como adicionar uma lib que faça o
sujo trabalho de coletar o lixo para nós.

Sim, a biblioteca de GC (Garbage Colector),  possui um algoritmo de
"limpeza" de memória e basicamente você não vai ficar perdido em meio
a funções free() não finalizadas e também vai ter uma indicação melhor
em tempo de execução se alguma área de memória explodiu, e onde.
Isso dá uma grande agilidade e poder de depuração.
Bom, as referências dessa lib: Está hospedada e mantida pela HP. É
usada no projeto Mozilla, Inkscape, Mono e vários projetos.
Abaixo um simples exemplo de programa devorador de memória alocada e
como ele fica simples feito com a lib.
Vejam que basta utilizar GC_MALLOC() no lugar do mal-loco() original
ou seja a lib possui interface com o esquema de alocação de memória
feito por programadores cabra-macho sim senhor.
E notem também que o free() foi pra /dev/null

*/

//Exemplo de utilização da biblioteca. loop.c

#include "gc.h"
#include <assert.h>
#include <stdio.h>

int main()
{
        int i;

        GC_INIT();    /* Optional on Linux/X86; see below.  */
        for (i = 0; i < 10000000; ++i)
        {
                int **p = (int **) GC_MALLOC(sizeof(int *));
                int *q = (int *) GC_MALLOC_ATOMIC(sizeof(int));
                assert(*p == 0);
                *p = (int *) GC_REALLOC(q, 2 * sizeof(int));
                if (i % 100000 == 0)
                        printf("Heap size = %d\n", GC_get_heap_size());
        }
        return 0;
}
//EOF

// Compilação:
// cc -I/home/xyz/gc/include loop.c /home/xyz/gc/lib/libgc.a -o loop

//Referencias da lib:
//http://www.hpl.hp.com/personal/Hans_Boehm/gc/
//http://www.hpl.hp.com/personal/Hans_Boehm/gc/simple_example.html