Month: enero 2012

Bueno, recientemente viendo videos en youtube me encuentro con uno muy interesante llamado how to add Google DNS on your Android Phone

Pueden verlo haciendo clic aqui

bueno, en el video explica como agregar las DNS de google a nuestro equipo android aunque no se ve muy bien la ruta es la siguiente:

``` /system/etc/host ```
El archivo que debemos editar es `host` Colocar: `8.8.8.8 nameserver` Debemos tener nuestro equipo con root ya para poder hacer esto y una herramienta que nos permita navegar y llegar a esa ruta, por ejemplo Root Exporer o ES Explorador, solo deben darle permisos de root a esas app y listo...

@sinfallas paso un rato configurando un Squid y DNSmasq y como a él no le gusta documentar yo me encargue de eso y esto fue todo lo que se hizo en un rato, esto también lo publique recientemente en VaSlibre ..

Squid+DNSMasq

Squid+DNSMasq=WIFI

PROBLEM?

Para poder usar el Squid obviamente lo instalamos, en cualquier distro basada en Debian:

``` sudo apt-get install squid ```
Ahora el DNSMasq:
``` sudo apt-get install dnsmasq ```
Ok bueno, Imaginemos lo siguiente... Tenemos la nube, que ira conectada a nuestra tarjeta wifi y la salida (_bridge_) de esa conexión será por _eth0_ hacia nuestro router y de ahi tendremos wifi. Ok, _eth0_ tendra la IP (_en nuestro caso_) **_192.168.0.10/24_** el router (**_TP-Link_**) tendrá la IP **_192.168.0.11/24_** a partir de aquí los rangos de IP serán:
``` **192.168.1.100 ---\> 149** 192.168.1.150 ---\> gateway ***192.168.0.10 ---\> DNS 1*** 8.8.8.8 ---\> DNS 2 8.8.4.4 ---\> DNS 3 ```
\* _Que podemos usar OpenDNS (208.67.222.222) o los de COMODO (8.26.56.26), para una "mayor seguridad"._ Los rangos de IP pueden cambiar según nuestras necesidades. **PROXY (_Squid_)** El proxy tendrá la IP **_192.168.0.10_** (**_si, la de eth0_**) con el puerto **_3128_** (**_default squid_**) y por DNS: **192.168.0.10** 8\.8.8.8 8\.8.4.4 Ver la configuración del squid.conf en este [enlace](http://vaslibre.org.ve/publicaciones/squid.conf "Enlace de descarga para el squid.conf")o editalo usando:
``` sudo gedit /etc/squid/squid.conf ```
Ahora, las reglas para la IPTables: Esto en la consola, claro!! ;)
``` iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o wlan0 -j MASQUERADE echo 1 > /proc/sys/net/ipv4/ip\_forward iptable-save ```
Despúes, levantamos el squid:
``` /etc/init.d/squid start ```
A medida de que vayas navegando se notará el cambio de velocidad en las páginas que más visitas, debido a que estaran "cacheadas" en dos directorios del disco duro se puede cambiar la configuración del squid para que use un pendrive de 2gb para acelerar el tiempo de respuesta del proxy. Luego les digo como cambiar eso ;) Y chan, chan!! :D Más información: [http://www.squid-cache.org/](http://www.squid-cache.org/ "Sitio oficial de Squid") [http://www.thekelleys.org.uk/](http://www.thekelleys.org.uk/ "Sitio oficial de DNSMasq") [http://es.wikipedia.org/wiki/Netfilter/iptables](http://es.wikipedia.org/wiki/Netfilter/iptables "Que es IPTables") **_\*\* Nota:_** Si eres nuevo en esto quizás existan algunas cosas (por no decir todo xD) que no entiendas pero en este caso te explicaré algo que es más notorio que otra cosa: **192.168.0.10/24** \\<-- Seguro quedaste con cara de **_o\_O_** Bueno, esto quiere decir que la mascara de red será de la siguiente forma: **255.255.255.0** Es decir, la IP del router tendrá la misma mascara de red de eth0. **Cualquier otra duda, google con eso \*xD**\* Ahora bien, si sacan cuentas tendremos: _1 modem CANTV_ 1 tarjeta de red. 1 tarjeta wifi 1 router 4 mascaras que haran entretenida la noche a cualquiera que quiera entrar sin permiso a su red!! Gracias a @[Sinfallas](http://twitter.com/sinfallas "Sigue a Sinfallas en twitter")por ayudarnos a configurar todo esto y a @[xombra](http://twitter.com/xombra "Sigue a xombra en twitter") por ponerlo puyuo!! Y obvio, me tienes que seguir a mi!! ¬¬" @[abr4xas](http://twitter.com/abr4xas "Sigue a abr4xas en twitter")
Singleton es un patrón de diseño cuya función es evitar que un objeto pueda ser instanciado más de una vez. En este post traigo una receta simple para implementar el patrón singleton en Python.

En esta implementación utilizaremos un archivo de bloqueo (lock file) para indicar si la aplicación está en ejecución o no. Python cuenta con el módulo fcntl que nos proporciona una interfaz bastante cómoda para el control de archivos pero está disponible solo para Linux/Unix, eso implica que debemos usar medidas alternativas para Windows.

Detectar SO e importar módulos

Lo primero que debemos hacer es detectar el sistema operativo y ejecutar los import correspondientes para cada caso. Usaremos además el módulo tempfile para generar el lock file como un archivo temporal del sistema. 
#!/usr/bin/python2
# -*- coding: utf-8 -*-

import os
import sys
import tempfile

OS = None
if sys.platform.startswith('linux'):
    OS = 'linux'
    import fcntl
elif sys.platform.startswith('win32'):
    OS = 'windows'


Definir la clase Singleton

Después de detectar el sistema operativo definimos la clase Singleton. Básicamente, esta clase será la encargada de crear el lock file al inicio o generar una advertencia y termina la ejecución en caso de que el archivo ya exista (es decir, que ya existe una instancia de la aplicación en ejecución). 
class Singleton:
    def __init__(self):
        # Variable para almacenar el file descriptor
        self.fd = None
        # Ruta para el lock file en la carpeta temporal del sistema
        self.filepath = os.path.abspath(os.path.join(tempfile.gettempdir(), 
            'myapp.pid'))
        
        if OS == 'linux':
            # Para el caso de linux usamos el módulo fcntl para crear el archivo
            # y bloquearlo automáticamente. Si la operación falla es porque el
            # archivo ya existe y está bloqueado.
            self.fd = open(self.filepath, 'w')
            try:
                fcntl.lockf(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
            except IOError:
                self.__exit()
        elif OS == 'windows':
            try:
                # Para el caso windows simplemente creamos el archivo "a mano",
                # pero verificamos primero si el archivo existe e intentamos 
                # removerlo (para casos en que la ejecución previa haya sido 
                # interrumpida)
                if os.path.exists(self.filepath):
                    os.unlink(self.filepath)
                self.fd = os.open(self.filepath, os.O_CREAT|os.O_EXCL|os.O_RDWR)
            except OSError, err:
                if err.errno == 13:
                    self.__exit()
    
    def __del__(self):
        # Para el caso de windows también debemos destruir el archivo "a mano" 
        # al finalizar la ejecución del programa.
        if OS == 'windows':
            if self.fd:
                os.close(self.fd)
                os.unlink(self.filepath)
    
    def __exit(self):
        print 'Ya hay una instancia en ejecución. Saliendo'
        sys.exit(-1)
En el __init__ se observa que creamos una variable para almacenar el file descriptor (fd), luego generamos una ruta para el lock file. Posteriormente creamos un lock file con el módulo fcntl (en el caso linux) o creamos un archivo regular (para el caso windows). Adicionalmente, en el caso windows necesitamos hacernos cargo del archivo al finalizar la ejecución, para eso sobreescribimos el método __del__ y colocamos nuestro código. Adicionalmente tenemos la función __exit(), que es la encargada de detener la ejecución del programa de forma elegante.

Clase de pruebas

Con los pasos anteriores tenemos lista nuestra implementación simple del patrón singleton. Ahora, ¿Cómo la usamos? Creamos una clase (por ejemplo MyApp) que herede de singleton y ponemos un bucle infinito para que se mantenga haciendo "algo". 
class MyApp(Singleton):
    def __init__(self):
        Singleton.__init__(self)
        print 'Ejecutando MyApp'
        # Creamos un bucle infinito solo para mantener la aplicación en
        # ejecución
        while 1:
            continue


¿Cómo se vería nuestro script?

El código completo de nuestro script se vería así: 
#!/usr/bin/python2
# -*- coding: utf-8 -*-

import os
import sys
import tempfile

OS = None
if sys.platform.startswith('linux'):
    OS = 'linux'
    import fcntl
elif sys.platform.startswith('win32'):
    OS = 'windows'

class Singleton:
    def __init__(self):
        # Variable para almacenar el file descriptor
        self.fd = None
        # Ruta para el lock file en la carpeta temporal del sistema
        self.filepath = os.path.abspath(os.path.join(tempfile.gettempdir(), 
            'myapp.pid'))
        
        if OS == 'linux':
            # Para el caso de linux usamos el módulo fcntl para crear el archivo
            # y bloquearlo automáticamente. Si la operación falla es porque el
            # archivo ya existe y está bloqueado.
            self.fd = open(self.filepath, 'w')
            try:
                fcntl.lockf(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
            except IOError:
                self.__exit()
        elif OS == 'windows':
            try:
                # Para el caso windows simplemente creamos el archivo "a mano",
                # pero verificamos primero si el archivo existe e intentamos 
                # removerlo (para casos en que la ejecución previa haya sido 
                # interrumpida)
                if os.path.exists(self.filepath):
                    os.unlink(self.filepath)
                self.fd = os.open(self.filepath, os.O_CREAT|os.O_EXCL|os.O_RDWR)
            except OSError, err:
                if err.errno == 13:
                    self.__exit()
    
    def __del__(self):
        # Para el caso de windows también debemos destruir el archivo "a mano" 
        # al finalizar la ejecución del programa.
        if OS == 'windows':
            if self.fd:
                os.close(self.fd)
                os.unlink(self.filepath)
    
    def __exit(self):
        print 'Ya hay una instancia en ejecución. Saliendo'
        sys.exit(-1)

class MyApp(Singleton):
    def __init__(self):
        Singleton.__init__(self)
        print 'Ejecutando MyApp'
        # Creamos un bucle infinito solo para mantener la aplicación en
        # ejecución
        while 1:
            continue
    
if __name__ == '__main__':
    app = MyApp()


Probando el singleton

Para probarlo abrimos un terminal, nos colocamos en la carpeta donde esté ubicado nuestro script y lo ejecutamos por primera vez. Eso nos dará como resultado algo como: 
$ python myapp.py 
Ejecutando MyApp


Abrimos una terminal nueva (sin cerrar la terminal anterior) e intentamos ejecutar la aplicación por segunda vez. Eso nos devolverá: 
$ python myapp.py 
Ya hay una instancia en ejecución. Saliendo
¡Y voilá! Logramos que un script de Python pueda ser ejecutado una sola vez.

Hay implementaciones más complejas que almacenan el ID del proceso dentro del lock file y cada vez que se intenta ejecutar una nueva instancia se lee el ID y se verifica que realmente exista un proceso en ejecución con ese identificador. Pero como dije al principio, esta es una receta simple, así que as implementaciones más complejas las dejamos como tareas para el lector ;)
Actualmente estoy colaborando con el desarrollo de canaima-instalador, una aplicación para Canaima GNU/Linux que permitirá al usuario instalar/probar Canaima de una manera fácil e intuitiva, y he decidido hacer una propuesta sobre cómo debe lucir y funcionar el nuevo instalador. La propuesta a continuación.

Paso 1: LiveCD

Lo primero que hace falta cambiar es el menú de inicio del liveCD. Actualmente tenemos una pantalla llena de opciones que, más allá de facilitar el uso, pueden confundir a los usuarios menos experimentados. Mi sugerencia es que el liveCD arranque automáticamente y presente un menú inferior con las posibles opciones para usuarios más experimentados.


Paso 2: Bienvenida

Aquí es donde comienza a ejecutarse canaima-instalador. La idea es que sea tipo OEM, es decir, que no cargue el escritorio sino lo mínimo necesario para ejecutarse. Se le preguntará al usuario si desea probar la distribución o instalar. Para el primer caso se cierra canaima-instalador y se continúa con la carga del escritorio, para el segundo caso se sigue el flujo normal de la aplicación.


Paso 3: Requisitos

Se le muestra al usuario cuáles son los requisitos mínimos necesarios para obtener mejores resultados al instalar Canaima. En caso de que no se cumpla con un requisito crítico (por ejemplo, el espacio en disco) la instalación no debería continuar.


Paso 4: Modo de instalación

Acá (luego de haber analizado el hardware) se le presentan al usuario las distintas opciones que tiene para instalar. En teoría todas deberían ser automáticas excepto la de "Particionamiento Avanzado" que ejecutará una instancia de gparted y bloqueará canaima-instalador hasta que el usuario termine de definir sus particiones. Una vez que el usuario haga clic en "Siguiente" no podrá volver atrás. Acá termina la primera fase de instalación y comienza el copiado de los archivos en el disco duro en segundo plano. La idea es aprovechar el tiempo, mientras se copian los archivos solicitamos al usuario el resto de la información y una vez terminada la copia se ejecutan las tareas correspondientes. De esta forma logramos minimizar considerablemente el tiempo de instalación (tal como lo hace Ubuntu).


Paso 5: Configuración de teclado

Como expliqué en el punto anterior, mientras se copian los archivos en segundo plano solicitamos el resto de la información al usuario. Acá se le pedirá que seleccione la distribución del teclado. Es importante observar que el botón de "Anterior" no estará disponible en este paso.


Paso 6: Configuración de usuarios

En esta fase se le pedirán los datos de las cuentas (root y usuario regular). Es importante habilitar un link (o botón) de ayuda donde se pueda explicar qué significa root y por qué es importante definir esa contraseña. Es importante recalcar que si el usuario no ha terminado de introducir la información complementaria y la copia de archivos finaliza entonces las tareas en segundo plano se detendrán hasta que se culmine esta fase.


Paso 7: Imágenes aleatorias sobre las bondades de Canaima

Al igual que Ubuntu y otros sistemas operativos, podemos mostrar una serie de imágenes aleatorias que informen al usuario sobre las bondades de Canaima GNU/Linux y del Software Libre mientras termina la instalación.


Paso 8: Fin de la instalación

Al finalizar todo exitosamente se le mostrará un pequeño diálogo al usuario para que reinicie el equipo y comience a disfrutar de las bondandes del SL.



Bueno, esta es mi idea de lo que debería ser un instalador fácil e intuitivo para Canaima GNU/Linux. Se escuchan comentarios Update para los haters: Sí, mi propuesta está basada casi enteramente en el instalador de Ubuntu porque me parece un excelente instalador ¿Cuál es el problema con eso?

El dia de hoy ley la conversación entre un par de conocidos en twitter, planteaban que seria genial poder ver los twits favoritos de un Cheff como para hacerse una lista gourmet.

Sigue los twits favoritos de quien quieras

La logica me decía que esto ya debía de existir aunque no pude encontrar como hacerlo directo desde la pagina web, logre conseguir como obtener un feed de estos:

la URL tiene el siguiente formato https://twitter.com/favorites/<usuario>.rss que en mi caso quedaria asi: | https://twitter.com/favorites/orvtech.rss

La salida de esto será un XML que puedes leerlo fácilmente con cualquier navegador web moderno o cualquier lector de RSS feeds. Aquí les dejo como se inicio la conversación..

Es un excelente tema para nuestra shell... Basado en ICS 4.0

Lo que necesitamos para que funcione es lo siguiente:

  • Primero descargamos la fuente Android 4 roboto
  • Luego abrimos e instalamos cada elemento haciendo doble clic
  • Luego descargamos el temaIce Cream Shell
  • Para poder instalar los temas en gnome shell es necesario tener instalada la extensión theme
``` sudo add-apt-repository ppa:webupd8team/gnome3 sudo apt-get update sudo apt-get install gnome-shell-extensions-user-theme ```
Y eso es todo!! :D [fuente](http://ociolinux.blogspot.com/2012/01/tema-android-ics-40-para-gnomw-shell.html "http://ociolinux.blogspot.com/2012/01/tema-android-ics-40-para-gnomw-shell.html")

Debido a una reciente mudanza, he bajado unos servers que tenía corriendo en casa de mis padres. Sin embargo, en mi nuevo hogar estoy en proceso de generar una nueva DMZ, esta vez, sin ventiladores.

El primer paso de este proceso ocurrió en forma de weekend project y consiste en hacerme de un "servidor". Las comillas hacen referencia a que no se trata de un gran server sino un procesador ARM de 200Mhz y 32MB de RAM, lo que es suficiente para que corra Debian y algunos otros servicios que pueden ser interesantes.

Los ingredientes

  • Un all-in-one LAN server que es la forma en que DealExtreme llama a unos dispositivos con chips de la familia str8132. Dado que vamos a instalar snake-os en ellos (en este caso se trata de la versión 1.3.2-20111019), es importante chequear la lista de compatibilidad. En particular me hice de un NS-K330 por 40 dólares.
  • Storage USB, puede ser en la forma de stick o como disco portable.
  • Un RS232 to TTL level converter, también conocido como cable para Nokia N1200/1208/1650/2630/2670. Es para conectarse por serie a la consola. No lo necesitamos ahora mismo, pero está bueno tenerlo a mano en caso de brickearlo, aunque es un procedimiento que no explicaré esta vez.

Instalación de Snake-OS

Es realmente sencillo. Lo primero es bajar snake-os, desde la sección de downloads de la web. Es importante que el archivo sea de la forma snakeos-<versión>-from-original.zip Instalar el que dice from-snake lleva definitivamente al brickearlo y recuperarlo puede ser complejo.
Desde la página de administración del dispositivo hay que subir el archivo snakeos-<versión>-from-original.bin contenido en el zip bajado. Confirmar el md5sum no está de más.

Acceso inicial

Los datos para acceder a la nueva interfaz con el browser:

http://192.168.0.240 (si es que no hay un DHCP en la red)
usuario: admin
contraseña: snake

Por SSH la contraseña de root la misma y, al cambiarla por la página de administración, se cambia en todos los accesos.

Post instalación

Incluso cuando Max opine que el uso de memoria virtual está rumbo a la extinción (lo cierto es que tal vez no es la mejor idea cuando el storage es de estado sólido como en los pendrives), activé el uso de SWAP desde el menú Service-Swapfile.

Si se quieren las mismas prestaciones que se tenían con el firmware original, hay que instalar unos paquetes adicionales. El sistema de paquetes que utiliza snake-os es opkg y tiene que ser primero activado desde Service-Opkg. Los paquetes pueden bajarse desde la página de download de snake-os y se instalan desde System-Packages. En particular, pueden ser interesantes (siempre pensando en los features originales):
Transmission: Es un cliente de BitTorrent, para dejar tus descargas corriendo. Es bastante mejor que el original.
miniDLNA: Es el server de streaming compatible con DLNA/UPnP-AV. Está un poco verde, pero se está trabajando en su mejora.

Corriendo Debian dentro

Las instrucciones están acá. Aunque esto es lo más obvio y necesario:

wget http://snake-os.googlecode.com/files/debian_chroot.tgz
tar -xvf debian_chroot.tgz
mount -o bind /proc /usb/sda1/debian/proc
mount -o bind /dev /usb/sda1/debian/dev
chroot /usb/sda1/debian/

Esta instalación base requiere unos 200MB. Tiene todo el potencial de un Debian (¡porque lo es!).
Claro que falta ajustar varios detalles, pero será la piedra inicial para el resto.

Una de las discusiones más comunes y que tiene tanto gente a favor como en contra es el tema de rootear los terminales, es decir, tener control absoluto de todo lo que ocurre en el gracias a ser superusuario.

Como siempre hay gente a favor y en contra, y los motivos son de lo más diverso y variopinto. Lejos de ponerse a favor o en contra, lo que yo voy a exponer aquí son mis razones por las que yo pienso que vale la pena hacer root (rootear) nuestro terminal. Desde la experiencia y vivencia de usuario. Así que espero que os sirvan de ayuda y aclaración.

Imagen

Las limitaciones del fabricante desaparecen

Es bastante habitual que nuestros terminales vengan en muchas ocasiones “capados” o con limitaciones. Algo totalmente ilógico si tenemos en cuenta el dinero que hemos pagado por el terminal, que nos lo den limitado o con su potencial recortado. Con el acceso root se eliminan estas limitaciones pudiendo disfrutar del terminal al 100% con el software adecuado. Un ejemplo, poder usar ICS en terminales que dicen sus fabricantes que no lo soportarán y si lo hacen (aunque no sobrados en algunos casos, todo hay que decirlo).

Mejorar el rendimiento del terminal

Indudablemente en su momento, las versiones de Android que nos proporcionan los fabricantes están pensadas para correr adecuadamente en nuestros terminales. Pero en realidad esto puede mejorar sustancialmente. Es la ventaja de usar código abierto, que cualquiera puede mejorarlo y tú beneficiarte de esta mejora. Mediante la ROM adecuada podemos hacer que el rendimiento de nuestro terminal sea muy diferente a como es su rendimiento de origen. Y si no me creéis, ¡probadlo!

La ventaja principal es el acceso a todo el potencial del móvil, todo el hardware a disposición de la versión y “cocinero” de la ROM que más nos guste. Hay una amplia variedad donde elegir con sus ventajas y desventajas. Pero es una de las principales razones por las que hacerle root a tu terminal, sin duda.

Aplicaciones especiales

Gracias a tener acceso total a nuestro sistema, podremos tener acceso también a cantidad de aplicaciones en las que ser root es condición indispensable para su funcionamiento. Sin duda una de las más populares es Titanium Backup, con la que podemos hacer backup absolutamente de todo nuestro teléfono, incluídos los apk de las aplicaciones que tengamos. Las posibilidades son ámplias y no se quedan en el backup: overclockear, controlar la velocidad de nuestra cpu o cambiar de rom fácilmente son solo algunas de ellas.
Actualizaciones al día, sin esperas

Esta es la razón por la que yo rooteé mi android por primera vez. Desgraciadamente una de las peores cosas de Android es su alto nivel de fragmentación. Dependiendo del terminal del fabricante, hay un abismo en cuanto a ritmo y velocidad de actualizaciones. De hecho, hasta hay fabricantes que directamente no se molestan en actualizar los terminales y estos quedan relegados a una muerte prematura.

Pero gracias a ser root, y a una gran comunidad muy activa, puede que tu terminal tenga una segunda oportunidad. Gracias a los desarrolladores o también comunmente conocidos como “cocineros” de ROMS, puedes disfrutar de una versión más reciente de Android en tu terminal. Si eres impaciente puedes disfrutarlo de los primeros, con los problemas que eso puede conllevar, o bien ser paciente y esperar a una versión estable.

Tener control total

Porque nosotros somos dueños de nuestro terminal y como tales podemos escoger y conocer todo lo que corre por nuestro teléfono. Y no nos engañemos, ni siquiera hace falta tener unos conocimientos avanzados para ello. Ahora cambiar una rom es cuestión tan o más fácil que bajarse una aplicación del market (en la mayoría de terminales). La ventaja de ser root es que podemos controlar hasta la última gota de nuestro terminal, modificar parámetros o hacerlo más o menos completo. Con responsabilidad y sabiendo paso a paso qué se hace no hay nada que temer. Pero eso sí, siempre hay que estar seguro de lo que se está haciendo. Aunque ya no hay riesgos de rootear el terminal y cargárselo. De hecho compañías como Samsung o Sony Ericsson ya lo permiten sin riesgo a perder la garantía. Los últimos métodos que existen para rootear ya no modifican el bootloader y por tanto, no se pierde garantía.

Porque puedes

Si, así de claro. Porque puedes hacerlo, porque como dueño de tu terminal tu puedes decidir qué hacer con él. Puedes rootear y disfrutar de todas estas ventajas que hemos comentado, o dejarlo tal y como está. Puedes experimentar, aprender, disfrutar y sentir android en todo su esplendor. Aventurarte más allá de la versión de fábrica y esperar ansioso nuevas actualizaciones con miles de mejoras, o esperar que el fabricante se espabile.

Así que si todavía tienes dudas, espero que mis razones te sirvan para guiarte un poco. Es cuestión de perderle el miedo, ni es tan difícil, ni hay que tener dos masters para hacerlo. Sólo es cosa de buscar la manera y tener la seguridad de lo que se está haciendo. ¡A por todas!

Fuente: El Androide Libre