CyberAlberto

Mi rincón personal en internet

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.

Haz click para ver el reporte completo.

Anuncios

Domingo, 1 enero 2012 Posted by | Personal | Comentarios desactivados en Los números de 2011

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.

Martes, 19 abril 2011 Posted by | Informática e Internet | Comentarios desactivados en Un nuevo hogar

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:

  1. Entramos en la consola de Linux para realizar parte de las operaciones.
  2. Buscamos qué dispositivo tiene asociado la memoria flash, por ejemplo /dev/sdb (sin número), podemos averigüarlo con la orden dmesg | tail.
  3. 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.
  4. 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)
  5. 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
    
  6. Ahora formateamos las dos particiones con la orden mkfs:
    • mkfs.msdos /dev/sdc2 -n MINT8
    • mkfs.ntfs /dev/sdc1 -L "Memoria flash" -f
  7. Extraemos la unidad y la introducimos de nuevo para que las nuevas particiones que hemos creado se monten.
  8. 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.
  9. 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.

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.

Sábado, 20 noviembre 2010 Posted by | Informática e Internet, Investigación | Comentarios desactivados en Cómo crear un disco de arranque Linux con una memoria flash

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.

Viernes, 12 noviembre 2010 Posted by | Informática e Internet, Investigación, programación, Script bash | Comentarios desactivados en Compresión y encriptación asimétrica mediante GPG: sfxcompress

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:

Ventana principal del gestor de arranque Plop

Menú principal

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.

Martes, 6 julio 2010 Posted by | Informática e Internet | Comentarios desactivados en Plop, un gestor de arranque

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:

  1. 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
  2. Descargamos una versión estable de Clonezilla en formato zip, por ejemplo: clonezilla-live-1.2.5-17-i686.zip
  3. 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.
  4. 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
  5. 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.
  6. 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.
  7. 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).
  8. 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.

Lunes, 5 julio 2010 Posted by | Informática e Internet, Personal | 3 comentarios

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

Sábado, 8 mayo 2010 Posted by | Informática e Internet, Personal | Comentarios desactivados en Linux Mint 9 liberado

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.

Viernes, 7 mayo 2010 Posted by | Personal, Script bash | Comentarios desactivados en Compresor que genera ficheros autoextraíbles

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.

Martes, 16 marzo 2010 Posted by | Script bash | Comentarios desactivados en Emulando el comando deltree de DOS

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

Publicitad que incita a imprimir dinero

Vivir para creer.

Martes, 24 noviembre 2009 Posted by | Curiosidades, Informática e Internet | Comentarios desactivados en Curiosa forma de anunciar una impresora