Linfox

He publicado una nueva versión de PyDownTV que ahora permite descargar vídeos de Play Cuatro.

Además la nueva versión soporta:

- Soporte para vídeos Comunes de Cuatro (no Play Cuatro)

- Soporte para Extremadura Televisión

- Soporte para EITB

- Soporte para TV Autonómica de Murcia (A la carta)

- Soporte para Giralda TV

- Soporte para Tele Vigo

- Soporte para Intereconomía

- Soporte para Canal Rías Baixas

- Pequeños bugs arreglados

VÍDEO EXPLICACIÓN: DESCARGAR VÍDEOS DE PLAY CUATRO

Enlace | Más Info

Enlace | Página del proyecto en Google Code

Enlace | Código que procesa la descarga desde Play Cuatro

GNU/Linux, Internet, Mac, Microsoft, Multimedia, Software Libre, Trucos, Unix, códigos, software, ubuntu, windows

He subido una nueva versión de PyDownTv (no es la única actualización desde la primera versión, pero si resuelve problemas importantes en la versión de Windows, por eso lo reseño aquí).

Para más info ver: http://linfox.es/2011/04/19/pydowntv-script-para-descargar-videos-de-las-webs-de-tv/

GNU/Linux, Google, Internet, Multimedia, Software Libre, Unix, códigos, software, windows

El primero se lanza:

$ generar_claves_jazztel_wlan_xxxx <EDDIS> <BSSID>

El segundo captura el BSSID solo y se lanza:

$ generar_claves_jazztel_wlan_xxxx_sin_bssid <ESSID>

Dejo el código de los dos:

* generar_claves_jazztel_wlan_xxxx:

#!/bin/bash

## Generador de claves JAZZTEL_XXXX y WLAN_XXXX
## aabilio@gmail.com
## License: http://en.wikipedia.org/wiki/WTFPL

function sumar_error ()
{
echo $1
let ERRNO=$ERRNO+1
}

function comprobar_errores()
{
if [ $ERRNO -gt 0 ]
then
echo
echo "Usage: $0 <ESSID> <BSSID>"
echo "    Example: $0 WLAN_XXXX XX:XX:XX:XX:XX:XX"
exit 1
fi
}

function sacar_claves ()
{
#Pasar a mayúsculas el wlan_xxxx y coger solo los "xxxx"
ESSId=$(echo -n "$1" | tr 'a-z' 'A-Z' | cut -d_ -f2)
#Pasar a mayúsculas el XX:XX:XX:XX:XX y quitar los dos puntos ":"
BSSId=$(echo -n "$2" | tr 'a-z' 'A-Z' | tr -d 
#Cogemos del BSSId solo los 8 primeros caracteres:
BSSId8=$(echo -n "$BSSId" | cut -c-8)
#Hacemos la suma md5 de bcgbghgg$BSSId8$ESSId$BSSId (20 primeros caracteres):
#Cambiar "md5" por "md5sum" para GNU/Linux
CLAVE=$(echo -n bcgbghgg$BSSId8$ESSId$BSSId | md5 | cut -c-20)
}

function mostrar_claves ()
{
echo "ESSID: "$1
echo "BSSID: "$2
echo "CLAVE: "$3
}

################################ MAIN ##################################
ERRNO=0
#Comprobamos errores de lanzamiento:
# - Argumentos distinto de dos:
if [ $# -ne 2 ]
then
sumar_error "ERROR EN EL NÚMERO DE PARÁMETROS"
fi

compEssid=0
cEssid=$(echo $1 | tr 'a-z' 'A-Z')
cBssid=$(echo $2 | tr 'a-z' 'A-Z')
#Comprobar primer parámetro en escritura y largura:
echo $1 | tr 'a-z' 'A-Z' | grep ^WLAN_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
echo $1 | tr 'a-z' 'A-Z' | grep ^JAZZTEL_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
if [ $compEssid -eq 2 ]; then sumar_error "ESSID INVÁLIDO"; fi

#Comprobar segundo parámetro en escritura y largura:
echo $2 | tr 'a-z' 'A-Z' | grep ^[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]
then
sumar_error "BSSID INVÁLIDO"
fi

comprobar_errores
sacar_claves $1 $2
mostrar_claves $cEssid $cBssid $CLAVE

* generar_claves_jazztel_wlan_xxxx_sin_bssid:

#!/bin/bash

## Generador de claves JAZZTEL_XXXX y WLAN_XXXX
## aabilio@gmail.com
## License: http://en.wikipedia.org/wiki/WTFPL

function sumar_error ()
{
echo $1
let ERRNO=$ERRNO+1
}

function comprobar_errores()
{
if [ $ERRNO -gt 0 ]
then
echo
echo "Usage: $0 <ESSID>"
echo "    Example: $0 WLAN_XXXX"
exit 1
fi
}

function sacar_claves ()
{
#Pasar a mayúsculas el wlan_xxxx y coger solo los "xxxx"
ESSId=$(echo -n "$1" | tr 'a-z' 'A-Z' | cut -d_ -f2)
#Pasar a mayúsculas el XX:XX:XX:XX:XX y quitar los dos puntos ":"
BSSId=$(echo -n "$2" | tr 'a-z' 'A-Z' | tr -d 
#Cogemos del BSSId solo los 8 primeros caracteres:
BSSId8=$(echo -n "$BSSId" | cut -c-8)
#Hacemos la suma md5 de bcgbghgg$BSSId8$ESSId$BSSId (20 primeros caracteres):
CLAVE=$(echo -n bcgbghgg$BSSId8$ESSId$BSSId | md5 | cut -c-20)
}

function mostrar_claves ()
{
echo "ESSID: "$1
echo "BSSID: "$2
echo "CLAVE: "$3
}

function obtener_bssid ()
{
echo "BUSCANDO BSSID"
essidToUpper=$(echo $1 | tr 'a-z' 'A-Z');
bssidd=$(/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -s | grep `echo $essidToUpper`)
if [ $? -ne 0 ]
then
echo "NO SE ENCUENTRA EL BSSID para "$essidToUpper
let ERRNO=$ERRNO+1
comprobar_errores
else
echo "BSSID encontrado"
bssid=$(echo $bssidd | awk '{print $2}')
fi
}

################################ MAIN ##################################
ERRNO=0
#Comprobamos errores de lanzamiento:
# - Argumentos distinto de dos:
if [ $# -ne 1 ]
then
sumar_error "ERROR EN EL NÚMERO DE PARÁMETROS"
fi

compEssid=0
cEssid=$(echo $1 | tr 'a-z' 'A-Z')
#Comprobar primer parámetro en escritura y largura:
echo $1 | tr 'a-z' 'A-Z' | grep ^WLAN_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
echo $1 | tr 'a-z' 'A-Z' | grep ^JAZZTEL_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
if [ $compEssid -eq 2 ]; then sumar_error "ESSID INVÁLIDO"; fi

#Obtenemos el bssid con airport
obtener_bssid $1
cBssid=$(echo $bssid | tr 'a-z' 'A-Z')
#Comprobar segundo parámetro en escritura y largura:
echo $bssid | tr 'a-z' 'A-Z' | grep ^[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]
then
sumar_error "BSSID INVÁLIDO"
fi

comprobar_errores
sacar_claves $1 $bssid
mostrar_claves $cEssid $cBssid $CLAVE

DESCARGA:

Enlace | generar_claves_jazztel_wlan_xxxx - Para Mac OS X y GNU/Linux (cambiando “md5″ por “md5sum” en la línea 33 del primer script)

Enlace | generar_claves_jazztel_wlan_xxxx_sin_bssid - Sólo para Mac OS X

Este último capta automáticamente el BSSID de la red que se le pasa como parámetro (ESSID) utilizando el comando para terminal de airport. Por ello es necesario que se este en el radio de acción de la red de la que se desea conocer la clave. Si por el contrario se quiere usar el primero, como segundo parámetro se le tendrá que pasar manualmente la red, que se puede obtener fácilmente con el comando airport -s (que está escondido en la ruta: /System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/) o utilizando apps de terceros como KisMAC. En GNU/Linux también se puede obtener fácilmente el BSSID de una red con el comando iwconfig con el flag de buscar scan (por ejemplo: $ sudo iwconfig wlan0 scan)

Apple, GNU/Linux, Internet, Mac, Software Libre, Unix, códigos, ubuntu, wifi, wireless

De vez en cuando se me da por comprar una de esas revistas que hablan de GNU/Linux, sobre todo cuando voy a coger un tren, para entretenerme durante el viaje, y como suelen venir con un CD de las últimas distros que van saliendo pues así de paso las pruebo.

El caso que este fin de semana me compré la “Todo Linux“. Me llamó la atención que en su sección de “Trucos Linux”, el destacado del mes trataba sobre la construcción de un pequeño y simplísimo script para gente nueva en el sistema. El Scritp no lo crearon ellos si no que era una pequeña modificación de un script colgado en TrucoLinux.com y que lo que hacía era mostrar una entrada del diccionario de la RAE en tu terminal.

Como en el artículo comentaban que el script no aceptaba las tildes (ni tampoco las ñ, ni las mayúsculas) pues me dispuse a retocar un poco el mismo para que si aceptara palabras con esos caracteres. Me aburro y lo cuelgo aquí.

El script acepta que le pases la palabra a buscar como parámetro, o se la introduzcas después.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#!/bin/bash 
 
## Funciones:
 
function buscar_palabra {
    echo "Se está buscando la palabra \"$aux\" en la RAE, esto"
    echo "puede tardar dependiendo de la velocidad de su conexión"
    echo ''
    #Aquí puedes utilizar lynx o links2 en lugar de links, y si quieres
    #quitarle el "-dump" para visualizar directamente el navegador
    links2 -dump "http://buscon.rae.es/draeI/SrvltGUIBusUsual?LEMA=$palabra&origen=RAE"
    echo ''
}
 
function adaptar_palabra {
    #Pasar a minúsculas
    palabra=$(echo $palabra | awk '{print tolower($0)}')
    #Para poner la palabra por pantalla
    aux=$palabra
    #Cambiar caracteres especiales
    palabra=$(echo $palabra | sed 's/á/%C3%A1/')
    palabra=$(echo $palabra | sed 's/é/%C3%A9/')
    palabra=$(echo $palabra | sed 's/í/%C3%AD/')
    palabra=$(echo $palabra | sed 's/ó/%C3%B3/')
    palabra=$(echo $palabra | sed 's/ú/%C3%BA/')
    palabra=$(echo $palabra | sed 's/ñ/%C3%B1/')
}
 
## Parte principal:
 
if test -z $1
then
	clear
	echo "Diccionario de la RAE"
        echo "Introduce la palabra a buscar:"
	read palabra
	adaptar_palabra
	buscar_palabra
else
	clear
        palabra=$1
	adaptar_palabra
	buscar_palabra
fi

Argordmel propone en los comentarios que sería bueno que el script te diera la oportunidad de volver a buscar una palabra al final. Bien, pues esta podría ser una de las implementaciones ( es solo la parte principal del script):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

## Parte principal:
buscar="s"
count="0"
while [ $buscar = 's' ]
do
	if [ $count -eq "0" ]
	then
		if test -z $1
		then
			clear
			echo "Diccionario de la RAE"
		        echo -n "Introduce la palabra a buscar: "
			read palabra
			adaptar_palabra
			buscar_palabra
		else
			clear
		        palabra=$1
			adaptar_palabra
			buscar_palabra
		fi
	else
		echo -n "Otra palabra: "
		read palabra
		adaptar_palabra
		buscar_palabra
	fi
 
	count=$(($count+1))
 
	opc=b
	while [ $opc != 'n' ] && [ $opc != 's' ]
	do
		echo -n "¿Buscar otra? [s/n]: "
		read opc
		if [ "$opc" = 'n' ]; then
			exit
		elif [ "$opc" = '' ]; then
			opc='b'
		fi
	done
done

Como bien dice mch en lo comentarios, si modificamos en esta segunda parte principal con el siguiente recorte de código desde la línea 16 (”else”) hasta la 21 (”fi”), podremos pasar como parámetro más de una palabra:

16
17
18
19
20
21
22
23
24
25
26
27
28

else
	for pal in "$@"; do
		clear
		palabra=$1
		adaptar_palabra
		buscar_palabra
		if [ $# -gt 1 ]; then
			echo "Pulse una tecla para siguiente palabra "
			read -n1
		fi
		shift
	done
fi

GNU/Linux, Software Libre, Unix, buscadores, curioso, códigos, shell

Ya tengas linux, mac o cualquier sistema operativo basado en Unix, no es recomendable usar este comando ya que te borrará toda la información de la partición donde tengas instalado el SO. El comando en cuestión es

sudo rm -rf /


Su acción es similar a formatear el ordenador, pero con el sistema operativo funcionando. Tal y como lo explican en bitelia

rm es un comando que permite borrar ficheros o directorios. Los parámetros -rf son para borrar un directorio y su contenido recursivamente y forzar el borrado sin pedir confirmación. El sudo es para ejecutarlo con permisos de root.

Aquí os dejo con los vídeos del comando ejecutándose, tanto en linux como en mac:

GNU/Linux, Mac, Unix, comandos

Hoy le ha tocado el turno al comando “cat”.

Cat sirve para concatenar y visualizar ficheros. La sintaxis de cat es:

cat [usvte] [nombre_fichero ...]

Las opciones más importantes del comando cat son:

• -s: Suprime mensajes sobre archivos inexistentes
• -v: Presenta caracteres no imprimibles.

Para comprender mejor la utilidad de cat pondré algunos ejemplos.

¿Qué pasaría si ejecutáramos en una terminal el comando cat a secas?

Pues para enlazar con el anterior comando podemos ejecutar un “man cat” e ir a la parte de EXAMPLES y ver que nos dice lo siguiente: “cat Copy standard input to standard output”. ¿Qué quiere decir esto? Pues cuando ejecutas solo es comando cat a secas, se tomarán todos los caracteres que introduzcamos por la entrada estándar (el teclado) y lo pasará a la salida estándar (la pantalla). Pues como ves así en principio no se le ve ninguna utilidad.

Pero, ¿Qué pasaría si lo ejecutáramos así: cat > nombre_fichero?

Pues así, el comando cat redirigiría los caracteres que nosotros introdujéramos posteriormente de la salida estándar al fichero que en este ejemplo se llama “nombre_fichero”, y si este no existiera lo crearía. Ahora ¿ya le veis más sentido?

cat nombre_fichero

Muestra por pantalla el contenido del fichero* que se llama “nombre_fichero”

Diferencia entre “cat fichero” y “cat < fichero”

Los dos comandos hacen lo mismo, muestran por pantalla los caracteres del fichero “fichero” pero uno como opción del comando, “cat fichero”, y el otro por que se redirige la entrada estándar (STDIN) del teclado al fichero “fichero”, “cat < fichero”.

cat fichero otro_fichero

Este maravilloso comando muestra por pantalla el contenido de “fichero” y “otro_fichero” juntos, pero podemos hacerlo todavía mejor. “cat fichero otro_fichero > fichero_final”, así juntamos en “fichero_final” los contenidos de “fichero” y “otro_fichero”. Y esto funciona con otros archivos, archivos de música, vídeos. etc.

Es decir, si soléis bajaros películas por partes con este comando las podéis unir sin problemas (ejemplo: cat spiderman_part1.avi spiderman_part2.avi > spiderman.avi)

En conclusión, cat es un comando bastante útil para algunas situaciones, y combinado con alguna tubería (pipe) puede incluso hasta resultar indispensable. Si eres nuevo en GNU/Linux y no conocías este comando, anímate a cacharrear con el.

*(Enlace a la entrada de “fichero” en la Wikipedia)Hasta de las cosas más comunes se puede aprender algo (y eso que ahí viene poco, en mis apuntes de sistemas viene el doble de información sobre lo qué es un fichero).

Relacionado | Standard streams

GNU/Linux, Mac, Software Libre, Unix, comandos

Hoy estreno una nueva sección. En esta nueva sección iré comentando de vez en cuando algún comando de terminal Unix.

La mayoría de los comandos que vaya escribiendo en esta sección se pueden ejecutar en todas las plataformas UNIX (BSD y descendientes de este como Mac, Solaris, etc) aunque para algunas plataformas puede diferir un poco, sobre todo sus argumentos. En principio yo los utilizo bajo GNU/Linux.

Primero para que quede claro la sintaxis general de una orden es:

nombre_de_la_orden arg1 arg2 arg3 …argn

Me estaba preguntando por que orden podía empezar y tras pensarlo un minuto me he decidido por “man” por que para mi es la orden de las ordenes.

Al ejecutar el comando man en una terminal acompañado de otra orden, man te mostrará la página de manual de ese comando. Man siempre es útil, para cuando no sabemos que hace tal comando o no nos acordamos cuales eran los argumentos de aquella orden que hace tiempo que no utilizamos.

Para navegar por las páginas del manual se utilizan las teclas: “Return” (ENTER) para ir a la siguiente línea del manual, “Espacio” para sacar por pantalla la siguiente página y “Q” o “q” para salir de man y volver a la shell.

Las páginas de manual que devuelve man al ser ejecutado suelen estar compuestas de la siguiente forma.

Primero el apartado denominado NAME, en el que como su nombre indica, se especifica el nombre de la orden a la que pertenece el manual junto con una breve línea explicativa.

SYNOPSIS: aquí se presenta la sintaxis de la orden con todos sus argumentos opcionales.

DESCRIPTION: es donde ya se explica mejor qué es la orden, cómo funciona y se describe alguna característica más.

OPTIONS: describe uno a uno los argumentos que se pueden utilizar con la orden, con la información de lo que hace cada uno.

FILES: Muestra las rutas de algunos ficheros que te pueden interesar.

SEE ALSO: Muestra una lista de comandos que están relacionados los cuales te pueden interesar para entender aun mejor la orden que estás buscando.

BUGS: como su nombre indica muestra los bugs conocidos con su descripción.

AUTHOR: Quién escribió la página del manual.

Si bien estas son las partes más comunes, pueden existir más partes en la página de un manual como puede ser EXAMPLES (que muestra algún ejemplo de ejecución de la orden con algún argumento y su acción), HISTORY (muestra la historia de la orden, un pequeño comentario, tampoco nada extenso), o por ejemplo COPYRIGHT (que muestra el copyright del manual, valga la redundancia)

Podría decir bastantes cosas más sobre este maravilloso comando pero tampoco tengo pensado desmenuzar al tope todos las ordenes Unix. Además el que esté empezando por ejemplo en GNU/Linux puede ejecutar en su terminal la orden “man man” y así comprobar todos los argumentos de man.

Página del manual de la orden “man” sobre la shell bash de GNU/Linux

Más info: Wikepedia

GNU/Linux, Unix, comandos, shell