Jogando Urban Terror, as vezes trava.

A foto amarela e sem foco é cortesia do iPhone.

cash:~ lame$ sudo sysctl machdep.cpu
machdep.cpu.vendor: GenuineIntel
machdep.cpu.brand_string: Intel(R) Core(TM)2 Duo CPU     E8335  @ 2.66GHz
machdep.cpu.features:  FPU VME DE PSE TSC MSR PAE MCE CX8 APIC SEP MTRR PGE MCA CMOV PAT PSE36 CLFSH DS ACPI MMX FXSR SSE SSE2 SS HTT TM SSE3 MON DSCPL VMX EST TM2 SSSE3 CX16 TPR PDCM SSE4.1

Depois de todo o alvoroço sobre o Chrome OS, finalmente baixei e pude conferir. Usando este link, tive que criar uma conta e após confirmar o cadastro pelo email, pude baixar uma imagem de VMware e criei a máquina virtual usando o Fusion.

O boot é realmente rápido, e logo aparece a primeira tela: login. Procurei um pouco e descobri que o usuário e senha é o mesmo do Google Accounts. Porém, não funcionou pra mim, e tudo que consegui foi um erro informando: Network not connected and offline login fail.

Usando a rede da máquina virtual como NAT ou Bridge, não fez com que o login funcionasse. Procurando mais um pouco, encontrei a solução: usuário chronos, sem senha.

Usei um pouco, procurei algo sobre configuração de resolução, e nada. Também, não há botão algum para desligar ou reiniciar o sistema operacional. Logo, procurando um pouco mais, descobri como abrir um terminal: Ctrl-Alt-T. É um linux, bem simples e pequeno, com a interface baseada em GTK, e o Chromium.

Nada especial, mas essa simplicidade é bem interessante.

Para virar root, pode-se usar o sudo, e a senha é chronos. Não tem muito o que fazer no terminal, apenas um sudo reboot ou sudo halt.

Curti.

Pra quem ainda não baixou o Chromium, aqui tem todos snapshots para os sistemas operacionais suportados: http://build.chromium.org/buildbot/snapshots/

Há algum tempo venho fazendo testes com o MongoDB pra casos específicos onde um RDBM tradicional como MySQL ou PostgreSQL não se encaixa muito bem.

Um dos casos onde um banco de dados baseado em objetos como o MongoDB se encaixa perfeitamente, é em um dos meus sistemas comerciais de telefonia, o Nuswit.

Lá, o usuário pode criar uma campanha de tele mensagem e colocar variáveis, que serão usadas para ligar para as pessoas e falar algumas coisas dinâmicas, sintetizando o texto em voz. Hoje, cada vez que o usuário cria uma campanha, pode importar uma planilha ou arquivo CSV, e então o sistema uma cria nova tabela no Sqlite com os campos que o usuário definiu na campanha, de acordo com essas tais variáveis.

Por isso, não é possível ter uma tabela estática, muito menos fazer relacionamentos pra usar a tabela no estilo chave=valor, pois essa mesma tabela é usada pros relatórios que o usuário baixa após o término da campanha.

Nesse caso, o MongoDB se encaixa perfeitamente. É muito mais simples criar uma coleção de dados com o mesmo nome da campanha, e importar documentos tipo JSON (nome=x, telefone=y, cpf=z) do que criar uma nova tabela com esses campos.

Além do mais, a API do pymongo é muito mais decente do que qualquer coisa parecida com SQL, pois os databases e collections são objetos do Python.

O único problema com o pymongo é que ele foi feito pra controlar e manter um pool de conexões com o banco, totalmente síncrono. Pra usar o pymongo em servidores como os que tenho feito ultimamente, assíncronos, baseados em Twisted, é necessário mandar todas as chamadas do banco pra um thread (usando callInThread ou deferToThread).

Pra solucionar esse problema, passei a frequentar o #mongodb na freenode, e em contato com o autor do pymongo, acabei criando uma versão assíncrona do driver, baseado em Twisted, que mantém o mesmo estilo da API original.

Agora, a integração entre Twisted e MongoDB está muito mais decente, usando pymonga.

Logo após o Facebook comprar o FriendFeed por meros U$50 milhões, não demorou pra começarem a publicar software gratuito.

O primeiro da fila foi o servidor e framework web usado pelo FriendFeed, chamado Tornado.

O FriendFeed é famoso por sua integração com Facebook, Twitter e Google. O que ninguém sabia, é que boa parte dessa integração é feita direto no servidor e framework web. Ainda, um dos recursos mais legais é o stream de dados do servidor assíncrono, também conhecido como comet, que permite long polling consumindo o mínimo de recursos.

É interessante como nos últimos anos essas tecnologias avançam no ambiente web. Na década de 90, a coisa mais moderna era desenvolver um CGI isolado, em Perl, que era executado pelo Apache, que por sua vez distribuía as requisições para um de seus processos usando um pool.

Depois, o procedimento de executar um programa externo foi se tornando um pouco ultrapassado, e o CGI foi parar dentro do Apache, com nomes como PHP e Coldfusion. Nessa época, enfiaram até Java dentro do Apache, colocaram o nome de Tomcat nele, e os CGIs passaram a se chamar Servlets.

Anos depois, fizeram o mesmo com o Python, e colocaram lá dentro do Apache o mod_python. No caso específico do Python, foram ainda mais longe: criaram um protocolo padrão para aplicativos web se comunicar com servidores web, chamado WSGI, e também foi parar dentro do Apache com nome de mod_wsgi.

Me lembro de cada uma dessas etapas, das dificuldades e dos benefícios de cada uma dessas adaptações. Programei em todas essas linguagens, nos últimos 15 anos. Meia vida.

Mais recentemente, antigas tecnologias como o FastCGI reabriram o caminho para aplicativos web 2.0. Servidores mais leves que o Apache, como o lighttpd e nginx começaram a ganhar muito espaço em sites com grande volume de acesso, por consumirem menos recursos trabalhando de forma assíncrona.

Mas antes do Apache, já existiam diversos serviços de rede que usavam o conceito de conexão assíncrona. Os servidores de irc, por exemplo, já formavam redes com centenas, e depois milhares, e depois centenas de milhares de usuários simultâneos, no bate-papo infinito.

Quanto mais o ambiente web cresce, mais pessoas acessam sites. Esses sites precisam de mais servidores, e esses servidores precisam de mais recursos. Usar conexões assíncronas permite aceitar mais pessoas simultâneas, consumindo menos recursos que tecnologias baseadas em thread, por exemplo. É uma espécie de redução de custo com otimização de recurso, ao mesmo tempo. Para programadores, é um conceito bem diferente do tradicional, especialmente para web, e exige um pouco de cérebro para se adaptar.

Os sistemas operacionais já vêm evoluindo suas internas para aceitar mais e mais conexões simultâneas, consumindo menos e menos recursos. Nomes como epoll, kqueue e /dev/poll estão cada vez mais no dia-a-dia dos programadores. E facilitadores como a libevent também.

O resultado disso é que os novos frameworks para aplicativos web já possuem servidores web embutidos, como é o caso do Tornado, Twisted Web, Merb, etc etc… Na frente deles, lighttpd e nginx fazem a distribuição de carga, e milhares de conexões web simultâneas, em um único computador físico, começa a se tornar realidade.

Coisas que você precisa saber antes de atualizar pro Snow Leopard, Mac OS X 10.6:

1. Logo após a atualização, é comum “quebrar” o sistema de autenticação. Aquela janela que costuma aparecer solicitando seu usuário e senha para desbloquear as propriedades de configuração, e também pra atualizar o Mac OS. Comigo aconteceu nos dois Macs, e a solução é remover no diretório do seu usuário, o diretório Library/Preferences/ByHost
2. O Xcode continua, mas o gcc na linha de comando não. Logo após atualizar pro Snow Leopard, terá que reinstalar o Xcode. Pode apagar manualmente o /Developer e /Library/Developer, pois não servem pra mais nada. A versão mais atual é o 3.2
3. De fato, MacPorts também vai pro espaço. Tudo que você já tem no port continua funcionando, menos o comando port. É necessário baixar a versão pro Snow Leopard, e depois de instalar, atualizar tudo que você tem: sudo port -v selfupdate; sudo port -v upgrade –force installed
4. Programas como o Snapz Pro não reconhecem mais sua licença, e a única maneira de resolver é mandando e-mail pro help@ambrosiasw.com. Tentei ir no site, na sessão my account, mas também estava quebrado – dei azar!
5. VMware Fusion e afins, só funcionam com kernel 32 bits. Já existe um beta pro kernel 64 bits, mas não funciona direito.

Por enquanto, foi isso que rolou por aqui. Assim que encontrar mais alguma zica, publico aqui.

No mês passado escrevi um artigo com um programa para capturar todos os items da primeira página de cada categoria do MercadoLivre.

Lá, lidava com alguns problemas como:

• limite de concorrência no download das páginas
• processamento de html em thread, síncrono
• manter a maior parte do processo assíncrono, para ganhar tempo e CPU

Depois disso, precisei fazer umas alterações no código e acabei modificando um pouco programa, usando outras técnicas como:

• cooperação de tarefas para limitar a concorrência
• processamento de html inline, mais rápido (pois usa backend em C)
• encadear algumas funções, executando inline

Cada item desta lista corresponde aos itens da lista mais acima, respectivamente.

O esquema de cooperação do twisted é muito melhor que o Controller que havia criado anteriormente. Porém, muito mais complicado para jovens aprendizes. Recomendo este link para mais detalhes.

Sobre o processamento do html, vale a pena verificar o lxml. Antes, havia usado BeautifulSoup, que é muito bom, mas perde violentamente em desempenho e suporte a broken-html.

Por fim, o truque de usar generators para executar alguns callbacks inline é incrível, e absurdamente prático em casos como esse, do programa abaixo.

O resultado é final é o mesmo, mas a melhoria em desempenho é absurda. Fiz alguns testes na minha máquina e obtive o seguinte:

• esta versão consome, em média, 20% menos de CPU
• como não há necessidade de gravar os arquivos no disco, não consome disco
• o processo todo ficou 657% mais rápido, simplesmente
• ainda, o código é muito menor +_+

Veja ai:

#!/usr/bin/env python
# coding: utf-8

from lxml import html
from twisted.web import client
from twisted.python import log
from twisted.internet import task, defer, reactor

class MercadoLivre:
    def __str__(self):
        return 'http://www.mercadolivre.com.br/jm/ml.allcategs.AllCategsServlet'

    def parse_categories(self, content):
        category = subcategory = ''
        doc = html.fromstring(content)
        for link in doc.iterlinks():
            el, attr, href, offset = link
            try: category = el.find_class('categ')[0].text_content()
            except: pass
            else: continue
            if category:
                try: subcategory = el.find_class('seglnk')[0].text_content()
                except: continue
                else: yield (href, category, subcategory)

    def parse_subcategory(self, content):
        doc = html.fromstring(content)
        for element in doc.find_class('col_titulo'):
            yield element[0].text_content()

class Engine:
    def finish(self, result):
        reactor.stop()

    @defer.inlineCallbacks
    def fetch_categories(self, link, parser):
        try:
            doc = yield client.getPage(link)
            defer.returnValue(parser(doc))
        except Exception, e:
            print e

    def fetch_subcategory(self, links, parser, limit):
        coop = task.Cooperator()
        work = (client.getPage(link[0]).addCallback(parser).addCallback(self.page_items, *link) for link in links)
        result = defer.DeferredList([coop.coiterate(work) for x in xrange(limit)])
        result.addCallback(self.finish)
        result.addErrback(log.err)

    def page_items(self, items, href, category, subcategory):
        print 'Categoria: %s / %s' % (category.encode('utf-8'), subcategory.encode('utf-8'))
        for item in items: print ' -> %s' % item.encode('utf-8')
        print ''

def main(limit, *parsers):
    e = Engine()
    for parser in parsers:
        links = e.fetch_categories(str(parser), parser.parse_categories)
        links.addCallback(e.fetch_subcategory, parser.parse_subcategory, limit)

if __name__ == '__main__':
    reactor.callWhenRunning(main, 150, MercadoLivre())
    reactor.run()

Aos poucos, vou tirando meu serviço de Geo Localização do ar. Apesar de bastante acesso por dia no freegeoip.appspot.com, os problemas com o datastore do GAE me desanimam.

O serviço está no ar há cerca de 1 ano, e a média de acesso é de 10 e 15 requests por segundo. A recente redução das cotas tiram o serviço do ar muitas vezes, e isso porque diminuí ao máximo o nível de processamento, e a maioria das buscas é feita em memória direto no memcache.

Apesar do sistema ainda funcionar, não tenho mais paciência pra atualizar os dados lá. O datastore não permite deletar os dados antigos de uma maneira simples, e por isso gasta muito processamento quando uso o bulkloader, ou mesmo a remote_api.

Cansado de todos esses problemas, acabei pegando um VPS no slicehost.com e fiz uma versão nova do sistema. Tornei o código fonte disponível pela GPL v2, e daqui um tempo vou redirecionar o serviço do GAE pro slicehost.

Além de rodar mais rápido, é muito mais fácil pra atualizar o banco de dados de IPs, e tenho shell na máquina.

Se você costumava usar o serviço antigo, passe a usar o novo:

http://freegeoip.net

Espero que em breve possa atualizar meu banco de dados usando a Geolocation API que está sendo definida pelo W3C.

Sobre o slicehost: é o melhor serviço de hosting que já encontrei, por um preço ótimo. O formulário de signup é bem simples, e a configuração do ambiente é incrível. Ainda, permitem adicionar seus domínios direto no DNS deles, e apontar pras máquinas virtuais.

Acabo de resolver um problema que vem me irritando muito nos últimos meses: sincronizar uma quande quantidade de dados com o appengine.

Depois de passar muita raiva com o bulkloader, que inevitavelmente acaba gerando esses Datastore Timeout, decidi fazer um outro esquema que funcionou muito melhor. Um dia coloco aqui, mas não agora.

O lance é que pra enviar os dados, habilitei o https e também autenticação. Assim, os blocos de dados podem ser sincronizados com segurança, apenas por um administrador da aplicação.

O problema foi fazer meu script se autenticar no Google Accounts. Apesar da API de autenticação do appengine, preferi não usá-la pois não há necessidade no meu caso, e optei por usar o formulário genérico do Google.

Encontrei este documento com alguns exemplos e dúvidas, mas não foi suficiente. Finalmente, entendi como o negócio funciona:

• Faz um POST no serviço do Google Accounts enviando usuário, senha, nome de identificação e URL do app;
• O Google Accounts irá fornecer um token, que então deve ser passado pro sistema de autenticação do próprio app (igual ao dev_appserver.py)
• Nesse último request, o Google fornece um Cookie chamado ACSID, que deverá ser usado em todos as próximas requisições.

E pra resolver esse problema, escrevi uma classe chamada GoogleAuth, que recebe os dados necessários, se autentica no Google Accounts, e passa a fornecer o ACSID como string. Em caso de falha, tipo usuário ou senha errada, a classe gera um ValueError.

#!/usr/bin/env python
# coding: utf-8

import sys, urllib, urllib2

class GoogleAuth:
    cookie = ''

    # save the ACSID cookie before redirecting
    class RedirectHandler(urllib2.HTTPRedirectHandler):
        def __init__(self, klass): self.klass = klass
        def http_error_302(self, req, fp, code, msg, headers):
            try: self.klass.cookie = headers.get('Set-Cookie').split(';')[0]
            except: pass
            return urllib2.HTTPRedirectHandler.http_error_302(self, req, fp, code, msg, headers)

    # authenticate
    def __init__(self, appurl, appname, username, password):
        googauth = 'https://www.google.com/accounts/ClientLogin'

        # prepare the request data
        request_data = dict(
            Email=username,
            Passwd=password,
            source=appname,
            service='ah',
            accountType='HOSTED_OR_GOOGLE',
            )

        # get the token from google auth
        fd = urllib2.urlopen(googauth, urllib.urlencode(request_data))
        auth_dict = dict(x.split('=') for x in fd.read().split('\n') if x)
        fd.close()

        token = auth_dict.get('Auth')
        if auth_dict.get('Error') or not token:
            raise ValueError('authentication failed.')

        # get the ACSID cookie for further athenticated requests
        opener = urllib2.build_opener(self.RedirectHandler(self))
        fd = opener.open(appurl+'_ah/login?'+urllib.urlencode({'continue':appurl, 'auth':token}))
        fd.close()

    # return the cookie
    def __str__(self):
        return self.cookie

if __name__ == '__main__':
    appurl = 'http://myapp.appspot.com/'
    appname  = 'My App'
    username = 'foo'
    password = 'bar'

    # authenticate
    try: acsid = GoogleAuth(appurl, appname, username, password)
    except Exception, e:
        print str(e)
        sys.exit(1)

    # now access resources that require authentication...
    print 'authentication cookie:', acsid
    request = urllib2.Request(appurl, headers={'Cookie':acsid})
    chunk = urllib2.urlopen(request).read()

Já pensou em fazer um programa que acessa o Mercado Livre, identifica o link de cada categoria, e extrai todos os produtos da primeira página de cada uma dessas categorias?

Pode até parecer complexo, mas não é. Esse programa existe, é simples, e está aqui, neste artigo, pronto pra você testar e modificar. :)

A algumas semanas tenho feito alguns crawlers pra esses sites que vendem produtos, como o Web Motors, Submarino, e até mesmo o eBay. A idéia é simplesmente extrair todos os produtos da primeira página de cada categoria, e montar uma base de dados com essas informações. O objetivo? Segredo de Estado.

Um dos problemas que encontrei ao fazer esse tipo de crawler, é controlar a concorrência de acesso. Se o programa acessa uma categoria por vez, demora uma eternidade pra baixar e processar cada página. Por outro lado, se ele acessa todas as categorias descontroladamente, o processo acaba criando muitos File Descriptors e isso causa diversos outros problemas pro sistema operacional – e não adianta falar em aumentar o limite usando ulimit -n, porque esses crawlers têm baixado milhões de links por dia.

A melhor maneira que encontrei pra solucionar esse problema, foi criando uma classe chamada “Controller”, que coloca as requisições em uma fila, baixa N páginas por vez, e ao invés de processá-las, simplesmente salva em um arquivo no disco.

Todos esses arquivos, com nomes únicos, são gerados usando um hash SHA1, e colocados em uma lista para serem processados offline, após o processo de download terminar.

O twisted tem um recurso muito interessante, que permite agrupar diversos deferreds em um único, e quando todos eles terminam, executa um callback. Nesse caso, quando todos os processos de baixar a página da subcategoria terminam, executa a função “offline”, que começa a processar cada uma, e extrair os produtos de lá.

Esta segunda etapa também poderia ser feita em paralelo, usando o twisted-parallels, mas decidi não colocar porque o código ficaria muito maior e você não teria tanta paciência pra entendê-lo. Usar um thread pool pra isso não valeria a pena, pois vale lembrar que o python usa o GIL, e I/O em thread só consome recurso e não aumenta em nada o desempenho.

A classe “MercadoLivre” tem 3 funções:

• __str__: retorna o link com todas as categorias do Mercado Livre
• parse_categories: um parser que retorna uma lista composta por tuples de (url, nome)
• parse_subcategory: um parser pro conteúdo de cada categoria, que retorna uma lista com o título dos produtos anunciados lá

Todos esses parsers são baseados no BeautifulSoup 3.1. É necessário tê-lo instalado pra usar o programa.

Por fim, para usar este programa em outros sites, basta substituir a classe “MercadoLivre” pela sua própria, tipo “Submarino”.

Detalhe: essa porcaria de WordPress mostra a identação do código errada no artigo, mas se você clicar em “view plain”, poderá copiar e colar o código correto. Chame o suporte!

Aqui o código (muito belo, por sinal…):

#!/usr/bin/env python
# coding: utf-8

import os, re, sys
import shutil, hashlib
from Queue import Queue
from BeautifulSoup import BeautifulSoup

# twisted
from twisted.web import client
from twisted.internet import defer, threads, reactor

class MercadoLivre:
    noscript = re.compile(r"(?is)<script[^>]*>(.*?)</script>")

    def __str__(self):
	return 'http://www.mercadolivre.com.br/jm/ml.allcategs.AllCategsServlet'

    def parse_categories(self, content):
	catlist = {}
	cleanup = lambda s: s.replace('\n', '').strip()

	# parse the document
	soup = BeautifulSoup(content)

	# find all categories and their items
	current = ''
	for item in soup.findAll('a', {'class':['categ','seglnk']}):
	    text = cleanup(item.contents[0])
	    attrs = dict(item.attrs)
	    if attrs.get(u'class') == u'categ':
		current = text
		catlist[current] = []
	    else:
		catlist[current].append((attrs.get(u'href', ''), text))

	# return the list of categories and their items
	return catlist

    def parse_subcategory(self, content):
	result = []
	soup = BeautifulSoup(self.noscript.sub('', content),
	    convertEntities=BeautifulSoup.HTML_ENTITIES)

	for item in soup.findAll('div', {'class':'col_titulo'}):
	    result.append(item.find('a').contents[0].strip())

	return result

class Controller:
    def __init__(self, fetch):
	self.count = 0
	self.limit = fetch
	self.queue = Queue()
	self.tmpdir = '/tmp/mercadolivre.%d' % os.getpid()
	self.dispatch()

    def encode(self, text):
	return unicode(text).encode('utf-8', 'replace')

    def getPage(self, url, *args, **kwargs):
	d = defer.Deferred()
	self.queue.put((d, url, args, kwargs))
	return d

    def dispatch(self):
	while True:
	    try:
		assert self.count < self.limit
		d, url, args, kwargs = self.queue.get_nowait()
	    except: break
	    self.count += 1
	    deferred = client.getPage(url, *args, **kwargs)
	    deferred.addBoth(self.decrease_count)
	    deferred.chainDeferred(d)
	reactor.callLater(1, self.dispatch)

    def decrease_count(self, result):
	self.count -= 1
	return result

class main(Controller):
    def __init__(self, fetch, parser):
	# set the concurrent download limit for the crawler
	Controller.__init__(self, fetch)

	# fetch the main categories page
	self.total = 0
	self.files = []
	self.parser = parser
	d = self.getPage(str(parser), timeout=60)
	d.addCallback(self.fetch_categories)
	d.addErrback(self.error_categories)

    def error_categories(self, error):
	# hmmm... fatal error, cannot continue
	print 'cannot fetch categories from %s: %s' % (str(self.parser), str(error))
	reactor.stop()

    def error_subcategory(self, error, href, category, subcategory):
	# problem fetching subcategory contents...
	print 'error "%s / %s": [%s] %s' % (category, subcategory, href, error.value)

    def fetch_categories(self, content):
	# parse the contents in a thread
	reactor.callInThread(self.parse_categories, content)

    def parse_categories(self, content):
	try: categories = self.parser.parse_categories(content)
	except Exception, e:
	    print 'error parsing categories: %s' % str(e)
	    reactor.stop()
	    return

	print 'going to fetch %d categories...' % len(categories)
	tasks = []
	for category, contents in categories.items():
	    category = self.encode(category)
	    for href, subcategory in contents:
		href, subcategory = self.encode(href), self.encode(subcategory)
		d = self.getPage(href, timeout=60)
		d.addCallback(self.save_subcategory, href, category, subcategory)
		d.addErrback(self.error_subcategory, href, category, subcategory)
		tasks.append(d)

	# call the offline subcategory parser after downloading everything...
	d = defer.gatherResults(tasks)
	d.addCallback(self.offline)

    def save_subcategory(self, contents, href, category, subcategory):
	# create the tmpdir if it doesn't exist
	if not os.path.exists(self.tmpdir): os.mkdir(self.tmpdir)

	# create a unique hash for each category
	hash = hashlib.new('sha1', category+subcategory).hexdigest()
	filename = os.path.join(self.tmpdir, hash+'.dump')
	try:
	    fd = open(filename, 'w')
	    fd.write(contents)
	    fd.close()
	except: return
	self.files.append((href, category, subcategory, filename))
	print 'saving "%s / %s": %s' % (category, subcategory, hash)

    def offline(self, null):
	# start processing each subcategory...
	reactor.stop()
	for item in self.files:
	    href, category, subcategory, filename = item
	    sys.stdout.write('parsing "%s / %s": ' % (category, subcategory))
	    sys.stdout.flush()
	    fd = open(filename)
	    try: results = self.parser.parse_subcategory(fd.read())
	    except Exception, e:
		print 'error! %s' % str(e)
		continue

	    lr = len(results)
	    self.total += lr
	    print '%d items' % lr
	    for result in results:
		print '  ' + self.encode(result)

	print '\n%d items processed. cleaning up!' % self.total
	shutil.rmtree(self.tmpdir)

if __name__ == '__main__':
    reactor.callWhenRunning(main, 10, MercadoLivre())
    reactor.run()

Agora, é só você se dedicar e fazer isso pros sites que te interessam.

Notas?

Depois de tanto tempo sem escrever nada, volto logo com uma boa: fazer chamadas de voz por SIP ou Skype, no iPhone, usando a rede 3G !

Aproveitando o assunto (iPhone), vale lembrar que tem apenas duas coisas que me irritam profundamente (até agora) com este telefone:

1. Não permitir SIP/VoIP/Skype pela rede 3G (olho gordo das operadoras)
2. Não ter suporte a Flash (idiotice da Apple por causa dos jogos)

De resto, pra quem curte Interweb, é o melhor aparelho que existe.

Voltando ao assunto… a primeira coisa necessária pra ignorar as restrições de SIP/VoIP/Skype apenas pela conexão WiFi é fazer o jailbreak do telefone. O melhor programa que encontrei pra fazer isso, à partir do Mac OS X, é o PwnageTool – não sei o que tem pra Linux nem Windows, não me xinguem.

O jailbreak irá instalar o Cydia automaticamente, que é um front-end pro APT, exatamente igual ao do Debian.

Depois disso é necessário conectar o iPhone a uma rede WiFi, saber o endereço IP dele, e pelo Cydia, instalar os pacotes OpenSSH, APT7 (Strict) e Bigboss Recommended Tools (este irá prover tudo que interessa: ps, vim, etc…).

Com isso feito, você precisa conectar via SSH no iPhone, usando o seu programa preferido: ssh no console, ou PuTTY pros usuários de Windows. Pra conectar no iPhone, o usuário é root e a senha padrão é alpine.

No console, é necessário instalar dois pacotes:

• mobilesubstrate : resumindo, insere código em um app durante sua execução
• voipoverip3g: biblioteca do mobilesubstrate pra enganar o iPhone, assim os programar não sabem que estão usando 3G, e pensam que é WiFi (duh!)

Para instalar, o procedimento é padrão de debian/ubuntu, mas no console do iPhone:

apt-get install mobilesubstrate voipoverip3g

Com isso feito, reinicie o iPhone, re-instale o Skype, e seja feliz. Quando abrir o Skype pela primeira vez, ele vai reclamar que “não foi feito pra rodar em iPhoneOS modificado”, mas é “apenas uma mensagem”.

Pros mais interessados: o pacote voipoverip3g instala esse “plugin” pro mobilesubtrate, e sua configuração fica em

/Library/MobileSubstrate/DynamicLibraries/VoIPover3G.plist

Você pode adicionar suporte a qualquer programa que seja restrito ao uso de SIP/VoIP pela rede WiFi, basta editar com vim e adicionar a chave do programa, seguindo o formato do arquivo. O padrão é adicionar suporte ao Fring e Skype.

Este é o conteúdo original do arquivo:

Bozo:~ root# cat /Library/MobileSubstrate/DynamicLibraries/VoIPover3G.plist
Filter = {Bundles = ("com.Fringland.Fring", "com.skype.skype");};

Boa?