Los números de 2011
Los duendes de las estadísticas de WordPress.com prepararon un reporte para el año 2011 de este blog.
Aqui es un extracto
Un teleférico de San Francisco puede contener 60 personas. Este blog fue visto por 3.100 veces en 2011. Si el blog fue un teleférico, se necesitarían alrededor de 52 viajes para llevar tantas personas.
Un nuevo hogar
He decidido migrar este blog a un nuevo hogar.
A partir de ahora este blog va a dejar de actualizarse definitivamente. Os espero en mi nuevo site.
Cómo crear un disco de arranque Linux con una memoria flash
Gracias a la popularización de los ultra-portátiles que no incluyen unidad de discos, se ha generalizado que las BIOS incluyan soporte para arrancar el ordenador desde un dispositivo USB. Primero fueron las unidades de CD/DVD externas y las disqueteras. Luego se amplió a discos duros y memorias flash.
Las memorias flash -en las que nos centramos en esta entrada- tienen la gran ventaja de ser muy pequeñas (puedes siempre llevarlas encima), resistente a golpes, reescribibles y mucho más veloces que los discos ópticos, por tanto son ideales para las tareas de instalar, reparar o probar un sistema Linux.
Por razones históricas, la gran mayoría de las distribuciones Linux cuando liberan una nueva versión de su distribución se amoldan a dos tamaños: tamaño CD de 700Mb o tamaño DVD de 4’7Gb. Así que nos encontramos que mientras las memorias flash se aproximan a capacidades de potencias de dos -esto es: 1Gb, 2Gb, 4Gb, … , 128Gb, …- las unidades ópticas tienen otras capacidades que siempre va a provocar que se vaya a desperdiciar sitio.
Por ejemplo, si tenemos una memoria flash de 2Gb y una imagen ISO de 689Mb, desperdiciaremos aproximadamente 1’3Gb de valioso espacio. Además, una vez que se ha generado la jerarquía típica de directorios cuando dicha memoria flash sea iniciable es muy engorroso encontrarse con esos ficheros que además podemos borrar accidentalmente (el Kernel, por ejmplo está perfectamente a la vista) o pueden infectarse con un virus. Por tanto, la solución pasa por crear dos particiones, una de arranque que contenga los ficheros ISO de 700Mb y el resto en otra partición, de la misma manera que explicamos en la entrada de la instalación de Clonezilla. Lo ideal es que dicha partición de arranque no sea visible, por lo tanto sea más inmune a borrados accidentales.
Esta solución funciona muy bien y luego la memoria flash es visible corractamente tanto en Mac OS, como en cualquier Linux, el problema una vez más viene de la mano de Windows, que se empeña en montar la primera partición que ve, que en nuestro caso es la de arranque, exactamente la que no nos interesa ni tan siquera montar. El problema viene de muy lejos; Windows, desde la época de los disquettes de 3.5» de 1.44Mb no permite ni crear particiones ni seleccionar el sistema de ficheros a contener dentro de lo que ellos denominan una unidad removible, por ejemplo, no nos permite formatear una unidad flash con NTFS y mucho menos tener dos o más particiones.
También existen soluciones a este problema, por ejemplo cambiando un cierto bit en el firmware de la memoria flash conseguimos que Windows crea que se trata de un disco duro y por tanto, ya te permite particionarlo (el problema es que el fabricante de las memorias flash debe proporcionarte ese software, algo a todas luces harto improvable), otra solución es toquetear los drivers de Windows para que lo detecte como un disco duro, por tanto, en cada Windows sería necesario este método para que monte la partición correcta, algo realmente engorroso.
La solución que vamos a explicar hace que tanto en Windows, como en Linux y como en Mac OS se monte la partición de datos y no la que contiene el sistema operativo.
Vamos por tanto a partir del siguiente supuesto:
- Una unidad flash de 4Gb, que convertiremos en una unidad de arranque Linux, deberemos copiar los datos que nos interese de ella, ya que va a borrarse completamente.
- Una imagen ISO de Linux Mint 8, que es la que me interesa, ya que es el sistema que tengo en el portátil. Ocupa 1071Mb, ya que es la versión universal con todos los idiomas.
- Un ordenador con Linux instalado para generar el disco de arranque.
Vamos a ir paso por paso:
- Entramos en la consola de Linux para realizar parte de las operaciones.
- Buscamos qué dispositivo tiene asociado la memoria flash, por ejemplo /dev/sdb (sin número), podemos averigüarlo con la orden dmesg | tail.
- Ejecutamos la utilidad fdisk /dev/sdb, creamos con ‘o’ una nueva tabla de particiones, y a continuación generamos dos particiones:
- Creamos una primera partición con la secuencia ‘n’ (enter) , ‘p’ (enter) , ‘2’ (enter) , ‘1’(enter) , ‘+1080M’ (enter), ‘t’ (enter) ‘6’, ‘a’ (enter), ‘2’ (enter). Es decir, creamos una partición primaria de arranque (la segunda de las cuatro posibles) al principio del disco con 1080Mb de tipo FAT16.
- Creamos la segunda con la secuencia ‘n’ (enter) , ‘p’ (enter) , ‘1’ (enter) , (enter), (enter), ‘t’ (enter), ‘1’ (enter), ‘7’ (enter). Es decir, una partición primaria (la primera de las cuatro posibles) al final del disco con el resto del espacio libre de tipo NTFS. Para terminar ejecutaremos ‘w’ (enter) para que guarde todos los cambios realizados.
- El esquema de particiones queda entonces de la siguiente manera: (nótese que el esquema de particiones está cruzado, ya que la primera partición del disco pertenece ocupa la segunda posición física y viceversa con la otra)
- Ahora formateamos las dos particiones con la orden mkfs:
mkfs.msdos /dev/sdc2 -n MINT8
mkfs.ntfs /dev/sdc1 -L "Memoria flash" -f
- Extraemos la unidad y la introducimos de nuevo para que las nuevas particiones que hemos creado se monten.
- Ahora utilizamos la utilidad Unetbootin, que es la que se encarga de copiar y hacer arrancable nuestra unidad flash, para ello seleccionamos la imagen ISO (opción que está en la mitad de la ventana) y nos fijamos que la unidad seleccionada (en la parte inferior de la ventana de la aplicación) sea la correcta, en nuestro caso /dev/sdc2. Presionamos sobre el botón de aceptar y esperamos a que copie todos los ficheros necesarios.
- La unidad ya está lista para su uso, pero ahora nos interesa convertir la partición de arranque de la unidad flash en oculta, para ello es conveniente que desmontemos /dev/sdc1 y /dev/sdc2. Volvemos a ejecutar fdisk /dev/sdc en la consola y ejecutemos la siguiente secuencia: ‘t’ (enter), ‘2’ (enter), ’16’ (enter), ‘w’ (enter). Con esto cambiamos la partición de arranque de FAT16 a FAT16 oculta, para que de esta manera no modifiquemos por accidente los datos que contiene.
Disco /dev/sdc: 3982 MB, 3982491648 bytes 123 cabezas, 62 sectores/pista, 1019 cilindros Unidades = cilindros de 7626 * 512 = 3904512 bytes Identificador de disco: 0xf35e2c28 Dispositivo Inicio Comienzo Fin Bloques Id Sistema /dev/sdc1 295 1019 2764425 7 HPFS/NTFS /dev/sdc2 * 1 294 1120991 6 FAT16 Las entradas de la tabla de particiones no están en el orden del disco
Et voilà, con esto ya tenemos una memoria flash de arranque en la que el espacio libre se puede utilizar como cualquier memoria flash y compartir información de un ordenador a otro. Incluso, cuando el Linux arranca, monta automáticamente /dev/sdc1 para que puedas utilizarla.
Compresión y encriptación asimétrica mediante GPG: sfxcompress
En la entrada que hablamos sobre el compresor que genera ficheros autoextraibles, explicamos la manera de generar dichos ficheros mediante un script de shell.
A este tipo de ficheros podemos añadir una nueva característica: encriptación asimétrica. La criptografía asimétrica es el método criptográfico que usa un par de claves para el almacenamiento o envío de información: una denominada pública y otra privada. La clave pública se puede entregar a cualquier persona y la privada debe mantenerse en secreto, de modo que con este método se encripta con la clave pública y se desencripta con la privada. Uno de los programas que se encarga de esta tarea es el denominado GNU Privacy Guard (GPG), pero existen otros, por ejemplo: DSA, PGP, SSH, SSL y TLS.
El objetivo del script de shell es simplificar las opciones a utilizar y generar ficheros comprimidos, encriptados y auto-extraibles, de modo que se facilite su uso. Para ello partimos del código explicado en la entrada mencionada.
Primero, dado que el número de opciones ha aumentado, es necesario tratar los parámetros de entrada de manera más cuidadosa. Se va a definir las siguientes opciones:
Opción | Parámetro | Descripción |
-f | filename | Indica el nombre base del fichero de salida y su path. |
-g | Indica que se utilice compresión gzip. | |
-b | Indica que se utilice compresión bzip2 (es la opción por defecto). | |
-k | Indica que debe encriptarse el fichero de salida. | |
-h | Muestra las opciones | |
-v | Muestra la versión del programa y la licencia |
Como se observa, se ha definido los parámetros como los estándares de UNIX: opciones de una sola letra con un guión delante.
Para hacer el análisis de los parámetros de entrada, se utiliza el siguiente bucle:
# Parse the parameters while getopts ":bf:ghkv" flag do chooseOptions $flag "$OPTARG" done
Donde la función chooseOptions
recibe cada parámetro y asigna las variables necesarias antes de la compresión:
# function name: chooseOptions, the function shows by screen the version of the program # parameters: - the valid option (b, f, g, h, k, or v) # - the parameter needed, for instance "f" needs the filename function chooseOptions { if [ "$1" = "g" ]; then compresor="z" extension="tgz" else if [ "$1" = "b" ]; then compressorByDefault else if [ "$1" = "k" ]; then encriptar="si" else if [ "$1" = "f" ]; then filename="$2" else if [ "$1" = "h" ]; then syntax else if [ "$1" = "v" ]; then version else echo "ERROR: \"$2\" is an invalid option." echo exit -1 fi fi fi fi fi fi } # chooseOptions
Si todo es correcto, el programa llama a la función compress
que se encarga de comprimir (y encriptar) el fichero de salida. Es importante señalar que la compresión se hace en la memoria de tal forma que no se generan ficheros intermedios que puedan comprometer información sensible. Primero comprueba si existe el fichero «.exclude» que indica los ficheros que deben ignorarse, por ejemplo, en ciertas circunstancias puede ser interesante ignorar los ficheros que terminen en ‘~’: «*~».
# function name: compress, the main function of the program # parameters: - the base name function compress { compressed=$(mktemp -t XXXXXXXXXXXXXXXX) encrypted=$(mktemp -t XXXXXXXXXXXXXXXX) # If .exclude exists, then the program must be work with it if [ -f ".exclude" ] ; then excluded=$(mktemp -t XXXXXXXXXXXXXXXX) echo >$excluded for i in $( cat .exclude ); do find . -name "$i" >>$excluded done if [ "$encriptar" = si ]; then rm -f $encrypted tar cvX$compresor $excluded . | gpg -o $encrypted --encrypt else tar cvXf$compresor $excluded $encrypted . fi else if [ "$encriptar" = si ]; then rm -f $encrypted tar cv$compresor . | gpg -o $encrypted --encrypt else tar cvf$compresor $encrypted . fi fi # The compressed (and encrypted) file has been created # The last step is to encapsulate all in a self-extracting style bash-script comp=$(mktemp -t XXXXXXXXXXXXXXXX) SIZE=$(cat $encrypted | wc -c) SALIDA="$1.$extension.sfx" echo "#!/bin/bash" >$comp echo "">>$comp echo "SIZE=\"$SIZE\"">>$comp echo "compresor=\"$compresor\"">>$comp echo "filename=\"$(basename "$1")\"">>$comp echo "extension=\"$extension\"">>$comp echo "fecha=\"$(date)\"">>$comp echo "mdf=\"$(cat $encrypted | md5)\"">>$comp if [ "$encriptar" = si ]; then echo "encriptado=\"$encriptar\"">>$comp echo "adjetive=\" encrypted\"">>$comp fi # Take care!, the parameter in tail indicates the start of # the second part of the script, do not modify unless you # know what you do. cat "$0" | tail -39 >>$comp cat $encrypted >>$comp chmod 755 $comp # Delete temporary files rm -f $compressed rm -f $excluded rm -f $encrypted mv $comp "$SALIDA" echo echo The file $SALIDA has been created. echo } # compress
Para ver el código completo y descargarlo, puede dirigirse a la página oficial, alojada en SourceForge.
Plop, un gestor de arranque
En la entrada anterior hablé sobre cómo crear un disco USB que contenga una partición de arranque oculta con Clonezilla y el resto del espacio para almacenar las copias de seguridad u otros usos.
El problema se plantea cuando un ordenador no puede arrancar desde una unidad USB debido a las limitaciones intrínsecas de algunas BIOS. Para solventar parte del problema existe un gestor de arranque llamado Plop que permite arrancar desde un disco duro externo USB sin necesidad de tener soporte de la BIOS.
Este gestor de arranque ofrece un amplio abanico de posibilidades a la hora de configurarse y ejecutarse. Se puede instalar como gestor de arranque principal o como secundario. La manera más sencilla de ejecutarlo es añadirlo como una opción más al gestor de arranque de windows (NTLDR) o al gestor de arranque de linux (GRUB). He optado por GRUB debido a que lo utilizo como gestor de arranque en mis ordenadores. A continuación mostramos los pasos para instalarlo en el sistema.
Primero hay que descargar la última versión estable de Plop (en el momento de escribir esta entrada era plpbt-5.0.10.zip) y extraer el fichero plpbtrom.bin localizado dentro del subdirectorio rom.
El archivo binario plpbtrom.bin se copia al directorio /boot y añadimos las siguientes líneas al fichero /boot/grub/grub.cfg:
menuentry "Gestor de arranque Plop" { set root=(hd6,0) linux16 /plpbtrom.bin }
El parámetro root indica la partición donde se encuentra el /boot de tu sistema, en mi caso hace referencia a /dev/sda6 y dado que sda6 es independiente de la partición raíz de Linux, no hay que indicar el directorio boot en el parámetro linux16, para aprender más sobre GRUB puedes consultar este enlace.
Una vez guardado el fichero de configuración de GRUB, reiniciamos el ordenador y veremos que ha aparecido una nueva opción a nuestro menú, al seleccionar dicha opción aparece la siguiente pantalla de aspecto un tanto futurista:
La última opción en verde hace referencia a arrancar el ordenador desde un disco USB. Hay que tener en cuenta que el disco duro debe estar conectado directamente a un puerto USB de la placa base y no a un HUB. Otra limitación es que no puede arrancar desde unidades ópticas USB, ni desde unidades Flash, ni disqueteras USB.
Utilizar un disco USB externo arrancable como copia de seguridad con Clonezilla
Dada la vital importancia de poder tener nuestros datos salvaguardados en un disco USB externo, he escrito el siguiente mini-tutorial para crear un disco USB autoarrancable en el que se puedan almacenar las copias de seguridad.
Para llevar a cabo el tutorial necesitamos lo siguente:
- Un disco duro externo USB vacío, ya que va a ser reparticionado y reformateado.
- Un ordenador con Linux con la utilidad fdisk instalada, normalmente todos los Linux la traen de serie.
Comencemos:
- Sobre el disco USB crearemos desde Linux con fdisk dos particiones: una FAT16 de 128Mb y otra EXT3, NTFS o la que prefieras (que es donde se van a guardar las copias de seguridad). Las formateamos para que puedan ser montadas por el sistema. Personalmente he elegido NTFS ya que se va a usar tambien en Windows. La primera partición ha de marcarse como activa. El esquema de particiones queda así (suponiendo que el disco USB sea /dev/sdc):
Disco /dev/sdc: 500.1 GB, 500107862016 bytes 255 cabezas, 63 sectores/pista, 60801 cilindros Unidades = cilindros de 16065 * 512 = 8225280 bytes Identificador de disco: 0xdfd3bd69 Disposit. Inicio Comienzo Fin Bloques Id Sistema /dev/sdc1 * 1 17 131072 6 FAT16 /dev/sdc2 17 60802 488252416 7 HPFS/NTFS
Formatearemos las particiones de la siguiente forma:
mkfs.msdos -n clonezilla /dev/sdc1 mkfs.ntfs -L Datos /dev/sdc2
- Descargamos una versión estable de Clonezilla en formato zip, por ejemplo: clonezilla-live-1.2.5-17-i686.zip
- Montamos la partición /dev/sdc1 y sobre el directorio raíz de la partición sdc1 descomprimimos el archivo descargado en el paso anterior.
- Supongamos que la partición /dev/sdc1 está montada sobre /media/clonezilla, si hacemos un «ls -al /media/clonezilla» deberá aparecer algo parecido a lo siguiente:
total 48 drwx------ 8 alberto staff 272 5 jul 16:57 . drwxrwxrwx+ 37 alberto staff 1258 5 jul 16:57 .. -rw-r--r-- 1 alberto staff 17982 8 ene 09:35 COPYING -rw-r--r-- 1 alberto staff 115 16 ene 10:10 Clonezilla-Live-Version drwxr-xr-x 3 alberto staff 102 16 ene 10:10 home dr-xr-xr-x 11 alberto staff 374 16 ene 10:10 live drwxr-xr-x 9 alberto staff 306 16 ene 10:10 syslinux drwxr-xr-x 7 alberto staff 238 5 jul 17:29 utils
- Ejecutamos como root el script: /media/clonezilla/utils/linux/makeboot.sh /dev/sdc1 y respondemos afirmativamente a las 3 preguntas. De esta manera convertimos el disco USB en arrancable.
- Es hora de probar si todo funciona correctamente. Para ello desmontamos la unidad e intentamos arrancar cualquier ordenador (configurando para ello la BIOS) y vemos el resultado.
- Si algo no funciona, puede deberse a multitud de motivos, por ejemplo algunas BIOS no aceptan arrancar desde ciertos dispositivos USB -me he encontrado con un portátil COMPAQ que se quedaba colgado mostrando sólo el símbolo del sistema-, revisa los pasos o prueba en otros ordenadores para comprobar si arranca en alguno (ajustando de nuevo los parámetros de la BIOS, claro).
- Una vez que todo vaya bien, le vamos a dar el toque «profesional». Volvemos a conectar el disco USB a Linux y ejecutamos fdisk. La partición sdc1 la cambiamos del tipo 6 al tipo 16 (ambos valores son hexadecimales). De esta forma la partición sdc1 queda oculta y ningún sistema operativo la montará por defecto. El usuario por tanto ya no borrará accidentalmente datos importantes de sdc1. El sistema de particiones queda entonces así:
Disco /dev/sdc: 500.1 GB, 500107862016 bytes 255 cabezas, 63 sectores/pista, 60801 cilindros Unidades = cilindros de 16065 * 512 = 8225280 bytes Identificador de disco: 0xdfd3bd69 Disposit. Inicio Comienzo Fin Bloques Id Sistema /dev/sdc1 * 1 17 131072 16 FAT16 oculta /dev/sdc2 17 60802 488252416 7 HPFS/NTFS
Espero que os sirva de ayuda.
Linux Mint 9 liberado
El esperado Linux Mint 9 ha sido liberado hace unos días.
Tengo instalado Linux Mint 8 en dos portátiles y va estupendamente bien, reconociendo todo el hardware y con excelente rendimiento. Personalmente me gusta más que Ubuntu. En cuanto pueda, lo probaré.
Compresor que genera ficheros autoextraíbles
Es una idea que siempre me ha rondado por la cabeza, hasta que he decidido desarrollarla. Quería tener un fichero comprimido con las instrucciones en su interior para descomprimirse a sí mismo.
Los ficheros generados por esta utilidad contienen un shell script en su cabecera que contiene las instrucciones para descomprimirse. La sobrecarga que produce es de poco más de medio Kbyte, por lo que no supone ningún inconveniente. Se ha probado en Mac OS X, Linux y CygWin, por lo que seguramente funcione en el resto de sabores UNIX (o lo que es lo mismo: en cualquier sistema operativo distinto de Windows). Para que funcione en Windows es necesario instalar CygWin.
Se necesitará tener instalados los siguientes ejecutables en el sistema: bash, tar, gzip, bzip2, cat, wc, tail, chmod, rm, mv. md5 y mkdir. Esto normalmente no supone ningun problema, debido a que son comandos estándar en cualquier distribución.
La sintáxis es la siguiente:
comprime nombre_de_archivo [formato_de_compresión]
- nombre_de_archivo: es el nombre de archivo a generar junto con su ruta
- formato_de_compresión: puede ser b (bzip2) o g (gzip)
Por ejemplo:
cd /home/user/documents comprime ~/fichero g
Crea el archivo ejecutable ~/fichero.tgz.sfx que contiene el directorio /home/user/documents comprimido mediante gzip
A la hora de descomprimir el fichero generado, se ha incluido código hash md5, para saber si ha sido alterado el fichero comprimido.
El código es el siguiente:
#!/bin/bash if [ "$2" = "g" ]; then compresor="z" extension="tgz" else if [ "$2" = "b" ]; then compresor="j" extension="tbz" else if [ "$2" = "" ]; then compresor="j" extension="tbz" else echo "ERROR: \"$2\" is an invalid format, choose g (gzip) or b (bzip2)." exit -1 fi fi fi if [ $1 ] ; then tar cvf$compresor /tmp/compressed . SIZE=$(cat /tmp/compressed | wc -c) SALIDA="$1.$extension.sfx" echo "#!/bin/bash" >/tmp/comp.sfx echo "">>/tmp/comp.sfx echo "SIZE=\"$SIZE\"">>/tmp/comp.sfx echo "compresor=\"$compresor\"">>/tmp/comp.sfx echo "extension=\"$extension\"">>/tmp/comp.sfx echo "fecha=\"$(date)\"">>/tmp/comp.sfx echo "mdf=\"$(cat /tmp/compressed | md5)\"">>/tmp/comp.sfx cat "$0" | tail -35 >>/tmp/comp.sfx cat /tmp/compressed >>/tmp/comp.sfx chmod 755 /tmp/comp.sfx rm /tmp/compressed mv /tmp/comp.sfx "$SALIDA" echo echo The file $SALIDA has been created. exit 0 fi echo echo SYNTAX: $(basename $0) filename [format] echo echo WHERE: echo " filename --> The desired name and path" echo " format --> g (gzip) or b (bzip2)" echo echo $(basename $0) compresses the current directory as a self-extracting file. echo echo exit 1 # -------------------------------------------------------- if [ -f "$0" ] ; then DIRECTORIO=$(basename $(basename "$0" .sfx) .$extension) if [ -d "$DIRECTORIO" ] ; then echo echo "ERROR: The directory named \"./$DIRECTORIO\" exists" exit -1 else echo "This file was packed on $fecha." echo while true do echo -n "Do you want to unpack the file named \"$0\" in the folder \"$DIRECTORIO\"? " read CONFIRM case $CONFIRM in y|Y|yes|yeS|yEs|yES|Yes|YeS|YEs|YES) break ;; n|N|no|NO|No|nO) exit ;; *) echo -n "(yes or no) " esac done mkdir "$DIRECTORIO" mdfc=\"$(tail -c $SIZE "$0" | md5)\" echo echo "MD5 Stored: \"$mdf\"" echo "MD5 Calculated: $mdfc" tail -c $SIZE "$0" | tar -x$compresor -C echo echo "File \"$0\" unpacked." exit 0 fi fi echo ERROR! exit -1
Puede ser descargado desde Sourceforge.
Emulando el comando deltree de DOS
Aunque emular el comportamiento se puede hacer en un simple alias, dado el peligro potencial que puede suponer su uso, se ha escrito un pequeño script llamado deltree
:
#!/bin/bash remdir() { find "$1" -delete } if [ -d "$1" ] ; then while true do echo -n "Delete the whole tree named \"$1\" and its contents? " read CONFIRM case $CONFIRM in y|Y|yes|yeS|yEs|yES|Yes|YeS|YEs|YES|s|S|SI|si|Si|sI) break ;; n|N|no|NO|No|nO) exit ;; *) echo -n "(yes or no) " esac done remdir "$1" else echo $0: $1: No such directory fi
Espero que os sea de utilidad.
Curiosa forma de anunciar una impresora
Esta publicidad me ha llegado a mi correo y no puedo salir de mi asombro que inciten a tal acto delictivo (y más con la crisis galopante que tenemos):
Vivir para creer.
-
Recientes
- Los números de 2011
- Un nuevo hogar
- Cómo crear un disco de arranque Linux con una memoria flash
- Compresión y encriptación asimétrica mediante GPG: sfxcompress
- Plop, un gestor de arranque
- Utilizar un disco USB externo arrancable como copia de seguridad con Clonezilla
- Linux Mint 9 liberado
- Compresor que genera ficheros autoextraíbles
- Emulando el comando deltree de DOS
- Curiosa forma de anunciar una impresora
- Muere Michael Jackson
- Nuevo intento de timo
-
Enlaces
-
Archivos
- enero 2012 (1)
- abril 2011 (1)
- noviembre 2010 (2)
- julio 2010 (2)
- May 2010 (2)
- marzo 2010 (1)
- noviembre 2009 (1)
- junio 2009 (3)
- abril 2009 (1)
- marzo 2009 (3)
- febrero 2009 (10)
- enero 2009 (6)
-
Categorías
- A la española
- Análisis
- Cultura
- Curiosidades
- Efemérides
- Entretenimiento
- Frases célebres
- Frases patéticas
- Historia
- in-kultura
- Informática e Internet
- Investigación
- Libre pensamiento
- Música
- Noticias
- Noticias académicas
- Noticias y política
- Personal
- programación
- Reflexiones
- Script bash
- Sin categoría
- Telefonía
- Uncategorized
-
RSS
Entries RSS
Comments RSS