Archive for the ‘ Bash ’ Category

Preparar un entorno de trabajo con wmctrl

wmctrl es un programa que nos va a ayudar a generar un entorno de trabajo en el que usamos una serie de aplicaciones de forma habitual con un layout concreto.

El ejemplo siguiente funciona sobre Gnome 3 que genera de forma dinámica los escritorios virtuales (workspaces) por lo que habrá que jugar también con el comando sleep para darle tiempo a crear nuevos workspaces.

En el ejemplo se creará un entorno con una terminal, el IDE de programación Pida, un navegador, dos ventanas y Rhythmbox para escuchar música.

#!/bin/bash
# primer escritorio
wmctrl -s 0
pida &
iceweasel &
terminator --working-directory=/home/javi/Escritorio/PFC -l pfc &
sleep 5s
wmctrl -x -F -r "terminator.Terminator" -e 0,842,0,1078,1080
wmctrl -x -F -r "pida.Pida" -e 0,0,0,840,1047
wmctrl -x -F -r "Navigator.Iceweasel" -e 0,1920,369,1280,742
wmctrl -r "Iceweasel" -t 0

#segundo escritorio
nautilus /home/javi/Escritorio/PFC &
sleep 2s; 
wmctrl -F -r "PFC" -e 0,2150,330,871,638 
wmctrl -F -r "PFC" -t 1

#tercer escritorio
nautilus /home/javi/Escritorio/PFC/Documentación &
sleep 2s; 
wmctrl -r "Documentación" -e 0,2150,330,871,638 
wmctrl -r "Documentación" -t 2

#cuarto escritorio
rhythmbox &
sleep 3s; 
wmctrl -xF -r "rhythmbox.Rhythmbox" -e 0,1920,369,1280,742
wmctrl -xF -r "rhythmbox.Rhythmbox" -t 3
exit 0

Como se puede ver hay que dejar tiempos de espera con sleep para que haya tiempo para lanzarse la aplicación o crearse el workspace virtual por parte de Gnome 3.
En algunos casos se ha usado el parámetro -x la ventana usando la clase del programa cuando el programa sustituye su nombre en el título de la ventana por otro texto (caso Pida). En otros se ha usado -r que busca dicha cadena en el título de la ventana.
El parametro -F obliga a buscar estrictamente la cadena (case sensitive)

Por último, este script se puede guardar en un directorio del path como ~/bin para poder ejecutarlo fácilmente usando Alt+F2 en Gnome.

Anuncios

Convertir comics en formato pdf a formato cbz

Para una visión más cómoda. Con este sencillo script que requiere poppler-utils

# pdf2cbz: Conversor de formato para comics por ratoncio
#!/bin/bash
for i in *.pdf;do
echo "************";
echo "$i";
echo "************";
mkdir "${i%.pdf}";
pdfimages -j "$i" "${i%.pdf}"/0;
zip -r "${i%.pdf}".cbz "${i%.pdf}";
rm -rf "${i%.pdf}";
done

El siguiente para convertir de cbr a cbz

# cbr2cbz: Conversor de formato para comics por ratoncio
#!/bin/bash
for i in *.cbr;do
echo "************";
echo "$i";
echo "************";
mkdir "${i%.cbr}";
unrar e "$i" "${i%.cbr}";
zip -r "${i%.cbr}".cbz "${i%.cbr}";
rm -rf "${i%.cbr}";
done

Enviar Pop-ups informativos a XBMC

Esto nos permitirá sacar Pop-ups en la interfaz de XBMC. Realmente sencillo usando la interfaz que nos proporciona XBMC (JSON-RPC API). Lo colocaremos en /usr/local/bin para acceso general.

Vamos con el script en cuestión: msgtoxbmc

# msgtoxbmc: script para enviar pop ups a XBMC por ratoncio
#!/bin/bash
# procesado del pipe
case "$#" in
0)
        mensaje=`cat`
;;
*)
        mensaje="$@"
;;
esac;
# codigo envio
mensajeenviar=`echo $mensaje|sed 's/\ /\%20/g'`
titulo="Informacion%20de%20Ratoncio"
wget -qO- "http://192.168.1.124:8080/jsonrpc?request={%22jsonrpc%22:%222.0%22,%22method%22:%22GUI.ShowNotification%22,%22params%22:{%22title%22:%22$titulo%22,%22message%22:%22$mensajeenviar%22},%22id%22:1}" &> /dev/null
#habla "`echo $mensaje|sed 's/\%20/\\ /g'`"
exit 0;

La invocación, sencilla, por parámetros o usando pipe:

  • msgtoxbmc mensaje de prueba
  • echo mensaje de prueba|msgtoxbmc

Si en el script se descomenta la línea penúltima (habla) se oiría el mensaje por la TV (usando el script habla del post anterior)

Síntesis de voz en Raspberry Pi con RaspBMC

Algo muy sencillo de lograr y que nos permitirá jugar un poco.
Los pasos son los siguientes:
Instalar espeak y alsa utils

aptitude update
aptitude install espeak alsa-utils

La salida de audio por defecto con RaspBMC es por HDMI pero es necesario cargar el módulo snd_bcm2835. Lo añadimos al fichero /etc/modules

Ahora, en las opciones de salida de audio de XBMC hay que poner que el dispositivo de audio este activo siempre. Por defecto sólo está activo un minuto con lo que no nos funcionaría más que la primera vez.

Para facilitar las cosas hacemos un pequeño script en bash (habla)que pondremos en /usr/local/bin para acceso general con los permisos necesarios.

#!/bin/bash
# Script para sintesis voz por consola por ratoncio

case "$#" in
0)
        cat|espeak -ves > /dev/null 2>&1
;;
*)
        echo "$@"|espeak -ves > /dev/null 2>&1
;;
esac
exit 0;

El script se puede invocar con parámetros o pipe:

  • habla hola que tal
  • echo hola que tal | habla
  • Actualización: debido a un error en el paquete espeak se puede usar este script alternativo:

    #!/bin/bash
    # Script para sintesis voz por consola por ratoncio
    FILE="/tmp/habla-$RANDOM.wav"
    case "$#" in
        0)
            cat|espeak -ves -w $FILE 
            ;;
        *)
            echo "$@"|espeak -ves -w $FILE 
            ;;
    esac
    play -q "$FILE" >/dev/null 2>&1
    rm "$FILE";
    exit 0;
    

    Para que funcione es necesario instalar sox

    apt-get install sox
    

    Encriptado de partición home: cryptsetup y luks

    Lo he obtenido de http://disonanciamental.dyndns.org

    Si bien esto vale para cifrar la partición home, en mi caso he preferido cifrar únicamente un directorio “Documentos” de mi home que es donde guardo la información sensible.
    He usado una partición libre de 20GB /dev/sda2 donde se guardará la información cifrada.
    Se comienza por instalar cryptsetup y libpam-mount para montar las particiones.

    aptitude install cryptsetup libpam-mount
    

    Se cargan los modulos para no reiniciar

    modprobe -a aes dm_mod dm_crypt sha256
    

    Se actualiza pam para activar pam-mount:

    pam-auth-update
    

    Se crea la partición cifrada con la contraseña de nuestro usuario (para que el proceso de montaje sea transparente vía pam)

    cryptsetup luksFormat /dev/sda2
    

    Se le cambia el nombre a la partición. En mi caso “Documentos” para que después al montarse los enlaces de Gnome 3 sigan teniendo “Documentos” como nombre. Esto lo hice con el editor de particiones/discos de gnome.

    cryptsetup luksOpen /dev/sda2 crypt-home
    

    Se da formato a la partición.

    mkfs.ext4 /dev/mapper/crypt-home
    

    Se copian los datos a dicha partición

    mount /dev/mapper/crypt-home /mnt/
    rsync -tarv /home/user/ /mnt/
    

    Se indica a pam-mount el punto de montaje

    vi /etc/security/pam_mount.conf.xml
    

    Bajo “Volume definitions” se añade

    <volume user="ratoncio" fstyp="crypt" path="/dev/sda2" mountpoint="/home/ratoncio" />
    

    Al iniciar con el usuario se cargará automáticamente la partición cifrada de con los documentos.

    Por último, para cambiar la contraseña se haría lo siguiente:
    Se busca la clave que está en uso en los slots. Si nunca se ha hecho esto, lo más probable es que sea el slot 0

    cryptsetup luksDump /dev/sda2
    

    Se añade una nueva clave. Se pedirá una de las claves en uso, en este caso la única que existe, la del slot 0.

    cryptsetup luksAddKey /dev/sda2
    

    Se borra la clave anterior. Esto sólo funciona si al menos hay otra clave creada.

    cryptsetup luksKillSlot /dev/sda2 0 
    

    cURL – Obtener datos con formularios en https y procesarlos.

    Supongamos el siguiente escenario (real en mi caso):

    Tenemos que obtener diariamente datos de una página web. Dicha página usa SSL para su protección y se pasan los parámetros de una búsqueda en un formulario mediante POST. A partir de estos parámetros se obtiene unos resultados de dicha búsqueda que es lo que queremos procesar en un fichero de texto posteriormente.

    Realizar consultas con cURL a servicios que usan sistemas de autenticación es relativamente sencillo. Este proceso se complica si el sitio destino usa cookies para gestionar la seguridad.

    Para llegar a la resolución de este problema hay que realizar la operación en dos pasos: en uno se generarán y obtendrán las cookies de la sesión, en otro se usarán estas cookies para generar la consulta.

    1.- Obtener cookies.

    Empleando la extensión de firefox tamper data (extensión muy recomendable si no se conoce) se captura el post que se realiza para conocer los parámetros que envía el formulario. Aquí se ve que se piden tres parámetros para la autenticación: store, user, pwd.

    Con estos creamos el primer formulario que se enviará vía post al sitio. Los formularios post se codifican usando URL encoding y cada parámetro se separa con &. El fichero quedaría así:

    authform:

    store=tienda&user=miusuario&pwd=mipassword&Entrar=Aceptar
    

    Ahora habrá que lanzar cURL para generar el acceso y capturar las cookies que genere el sitio. Esto se realiza de la siguiente forma:

    curl -d @authform -H "Content-Type:application/x-www-form-urlencoded;charset=UTF-8" https://servidordestinoconSSL -c cookie.txt -vk1
    

    El parámetro -v simplemente da más información. El parametro -k sirve para evitar problemas con la verificación de certificados y el -1 es para forzar el uso de SSL (era necesario en mi caso). cURL usa por defecto SSL3 (al menos en mi caso y en este momento).

    Con esto hemos obtenido un fichero cookie.txt que contiene las cookies de sesión generadas y que nos servirán para las siguientes consultas.

    2.- Realización de la búsqueda.

    Volvemos a emplear tamper data para calcular los parámetros del formulario de búsqueda del servicio y replicamos el formulario como antes.

    searchform:

    FechaDesde=12%2F10%2F2012+00%3A00%3A00&Estado=0&Tipo=0&FechaHasta=13%2F10%2F2012+00%3A00%3A00&NumFilas=99&RefCompra=Pan=&CodAutorizacion=
    

    Nótese que los parámetros vacíos también están en dicho fichero.

    Ahora se manda dicho formulario con cURL enviando también las cookies de sesión:

    curl -d @searchform -H "Content-Type:application/x-www-form-urlencoded;charset=UTF-8" https://servidordestinoconSSL -vk1 -b cookie.txt  -o salida.html
    

    El parámetro -b es el fichero de cookies y el -o hace que la salida se guarde en un fichero para después realizar el parsing.

    3.- Parsing y formato de los datos:

    En mi caso, la salida es una tabla en formato HTML, así que este es el parsing particular que hice para obtener en un texto claro los datos de salida con una línea por fila de tabla. Se puede ver como se quitan los retornos de carro y las etiquetas de la tabla para dejar después las líneas separadas por un fin de línea.

    cat salida.html |grep -E "TD>|TR>" |tail -n +6 |head -n -2 |tr -d '\r\n'|sed 's/<TR>//g'|sed 's/<\/TR>/\n/g'|sed 's/<TD>//g'|sed 's/<\/TD>/\ /g'|sed 's/<B>//g'|sed 's/<\/B>//g' > salidaparseada
    

    wr – script para consultar términos en inglés en Wordreference

    
    #!/bin/sh
    # buscador múltiple de word reference
    # introducir wr seguido de los terminos a buscar en inglés
    
    echo RESULTADOS DE BUSQUEDA DE:
    echo $1
    vartratada=`echo $1|sed 's/\ /_/g'`
    echo  ++++++++++++++++++++++++++++++++++++++++++++
    echo  WORD REFERENCE: $1
    echo  ++++++++++++++++++++++++++++++++++++++++++++"\n"
    wget http://wordreference.com/es/translation.asp\?tranword=$1\&dict=enes\&B10=Search -U mozilla -q -O /tmp/wordref$vartratada
    html2text -utf8 -o /tmp/wordref$vartratada.txt /tmp/wordref$vartratada
    cat /tmp/wordref$vartratada.txt|tail -n +20|head -n 20
    rm /tmp/wordref$vartratada /tmp/wordref$vartratada.txt