Tienes múltiples opciones de configuración, pero explicaré dos formas de usarla, la rápida, cómoda e instantánea (¡como el colacao!) y otra donde vas más paso a paso (es decir, que en vez de un comando, ejecutas dos, joooplis).

Forma 1: Directamente se descargará el código y generará un .deb listo para ser instalado.

Digamos que quieres instalarte el módulo Hola::Que::Tal, pues ejecutas:

$ dh-make-perl --build --cpan Hola::Que::Tal

Con eso estaremos descargando el código del paquete (si en cpan existe claro) y generando un .deb de forma automática. Si existen dependencias se te indicará qué módulos se requieren, en cuyo caso sería recomendable que mirases si los tienes en tus repositorios antes de generar un .deb para ellos también.

Por poner un ejemplo real:

 
$ dh-make-perl --build --cpan Gtk2::Sexy
(...)
$ ls
Gtk2-Sexy-0.05                     libgtk2-sexy-perl_0.05.orig.tar.gz
libgtk2-sexy-perl_0.05-1_i386.deb
$ sudo dpkg -i libgtk2-sexy-perl_0.05-1_i386.deb

Forma 2: Tenemos un .tar.gz descomprimido descargado de cpan, generaremos la estructura de ficheros necesaria para generar un .deb con las herramientas típicas de debian (con debuild, $ sudo aptitude install devscripts).

Por seguir el ejemplo anterior, si quisiéramos instalar el módulo Hola::Que::Tal versión 1.0, nos descargamos de cpan su tar.gz y lo descomprimimos, por lo que tendríamos un directorio con el nombre Hola-Que-Tal-1.0. Con dh-make-perl generaremos los ficheros necesarios para poder generar un paquete deb (es decir, se creará un directorio debian/ con ficheros varios, los cuales, si sabes para qué sirven y quieres complicarte la vida, puedes modificarlos a mano para personalizar el .deb generado). Después simplemente entramos en el directorio y generamos el .deb ejecutando debuild.

 
$ ls
Hola-Que-Tal-1.0.tar.gz
$ tar xfz Hola-Que-Tal-1.0.tar.gz
$ dh-make-perl Hola-Que-Tal-1.0/
(...)
$ cd Hola-Que-Tal-1.0
$ debuild
(...)
$ ls .. | grep .deb
libhola-que-tal-perl_1.0-1_i386.deb

• out.txt: con los blogs buenos.
• out.txt.malos: con los blogs malos.
• errores.txt: con blogs que no ha podido analizar, debido a errores diversos, desde URL inexistentes (404) a falta de permisos debido a la configuración del servidor (403), etc, etc...

Una vez terminada la ejecución (unos 20min le ha costado), he comprobado los blogs malos que da como resultado (unos cuantos solo, si comprobase todos no tendría sentido el script xD) y creo que esta vez no hay fallos. Los que salen como errores son debido a su mayoría a páginas no encontradas (error 404) o timeouts del servidor (error 500), aunque había algún otro error misterioso (415 por ejemplo) que lo he pasado a blogs buenos y ya está. En resumen, resultados:

En total de 399 blogs. Hay 153 MALOS, 212 BUENOS y 34 que han fallado!

Es decir, 38% son malos! WTF?. Acabo de editarlo en el wiki de microsiervos, pero si alguien se aburre mucho, mucho y encuentra fallos en la lista (o en el código del script), que no dude en cagarse en mis muertos y mencionarlo para corregirlo cuanto antes. Ahora tendremos 216 blogs en ad-free .
 
No voy a pegar todo el código pues es similar al anterior, he aquí un tar.gz con el código y ficheros resultado.

En total de 393 blogs. Hay 143 MALOS y 213 BUENOS

Eso hace un 36,4% de blogs malos y 9,4% erroneos (URL incorrecta)! Una cifra bastante considerable. El script es este:

#!/usr/bin/perl -w
################################################################################
# adFreeClean v0.1 (menos da una piedra | A stone give you less) lol           #
#                                                                              #
# Author: Blaxter (blaxter at gmail dot com)                                   #
# Date: 03/sept/2006                                                           #
# Requiere:                                                                    #
#     apt-get install libterm-progressbar-perl                                 #
# Description:                                                                 #
#     Mayormente pilla el archivo que se le indique, esperando que sea con el  #
# formato wiki de http://wiki.microsiervos.com/Ad-Free_Blogs, y para cada url  #
# de blog que encuentra, lo descarga y mira si tiene enlace a la página del    #
# wiki o a la página adfreeblog.org                                            #
#                                                                              #
################################################################################
#                                                                              #
#                                GNU GPL license                               #
#                                                                              #
################################################################################
require LWP::UserAgent;
use Term::ProgressBar;
$| = 1;
################################################################################
my $FICHERO = 'content.txt'; # You should modify this
my $FICHERO_OUT = 'out.txt'; # You should modify this
################################################################################
################################################################################
sub getURL
# Descarga una página
# @param $1 la URL a bajar
{
	my $ua = LWP::UserAgent->new;
	$ua->timeout(5);
	$ua->env_proxy;	
 
	my $response = $ua->get(shift);
 
	return $response->content if ($response->is_success);
	'';
}
###########################################
sub checkadfree
# comprueba si una página tiene referencia a adfree
# @param $1 Código Html de la página
{
	my $pagina = shift;
	@expresiones = (
		"adfreeblog\.org",
		"wiki\.microsiervos\.com\/Ad\-Free_Blogs"
	);
 
	foreach (@expresiones)
	{
		return 1 if ($pagina =~ /$_/);
	}
	return 0;
}
################################################################################
################################################################################
my @data; # donde se guardarán los blogs
my $total_n = 0; # numero total de blogs
# abrir fichero del wiki...
open IN, "<$FICHERO" or die "Andandara el fichero!";
# leemos todas las url's de paginas apuntadas
while(<IN>)
{
	if(/^\*[^\[]*\[[^\]]*\]$/io)
	{
		# guardamos url, web(no usada, pero para otras versiones...), y linea
		# entera para sacarla en el fichero resultado si es blog bueno
		$data[$total_n]{'linea'} =
		$data[$total_n]{'url'} =
		$data[$total_n]{'web'} =
		$_;
		$data[$total_n]{'url'} =~ s/^\*[^\[]*\[([^\] ]*)[^\]]*\]$/$1/io;
		$data[$total_n]{'web'} =~ s/^\*[^\[]*\[[^\] ]*\s([^\]]*)\]$/$1/io;
		$total_n++;
	}
}
close IN; # done
# Creamos barra guays
my $next_update = 0;
my $n = 0;
my $progress = Term::ProgressBar->new(
	{
		name => 'AdFree',
		count => $total_n,
		ETA => 'linear'
	}
);
$progress->minor(0);
$progress->max_update_rate(1);
 
# y ahora a comprobar cuales tienen add-free
foreach (@data)
{
	$next_update = $progress->update($n)if $n >= $next_update; # actuliza barra!
 
	$url = $_->{'url'}; # pilla url!
	# bajamos la pagina
	$pagina = &getURL($url);
	if($pagina ne '')
	{
		$_->{'adfree'} = checkadfree($pagina);
	}
	else
	{
		$_->{'adfree'} = -1;
	}
	$n++; # para la barra!
}
# Completamos barra, pa por si aca...
$progress->update($total_n);
 
open OUT, ">$FICHERO_OUT";
open OUT_MALOS, ">$FICHERO_OUT.malos";
$malos = $buenos = $notfound = 0;
foreach (@data)
{
	if($_->{'adfree'} eq 0)
	{
		$malos++;
		print OUT_MALOS $_->{'url'};
	}
	elsif($_->{'adfree'} eq 1)
	{
		$buenos++;
		print OUT $_->{'linea'};
	}
	elsif($_->{'adfree'} eq -1)
	{
		$notfound++;
	}
}
close OUT;
close OUT_MALOS;
print "En total de $n blogs. Hay $malos MALOS y $buenos BUENOS\n";

Puedes descargarlo aquí, incluye el script (adfreeclean.pl), la página del wiki de microsiervos (content.txt) y los resultados despues de la ejecución (out.txt y out.txt.malos).

Actualización [4 sept @ 23.20]: El script falla para todas las webs que usan frames (es decir, todas con redirecciones...). Hay un modulo para perl que teoricamente lo resuelve, pero va dos veces, así que tendría que hacer la iteración y busqueda de los frames a pelo. Para otro día, que ahora no me apetece

#! /usr/bin/perl -w
use Socket;
use strict;
my( $host, $in_addr, $proto, $port, $addr, $file);
 
$host = "www.marca.es";
$file = "/"; # el index vamos...
$port = 80;
$proto = getprotobyname('tcp');
$in_addr = inet_aton($host);
$addr = sockaddr_in($port, $in_addr);
# creamos el socket y conectamos al servidor
socket(S, AF_INET, SOCK_STREAM, $proto) or die "socket: $!";
connect(S, $addr) or die "connect: $!";
# para flushear nada mas escribir en el socket
select(S); $| = 1; select(STDOUT);
 
# Una peticion normal GET
print S "GET $file HTTP/1.1\nHOST: $host\n\n";
 
while(<S>)
{
	print;
}
 

Que es un poco fea, bastante similar a C, y no muy limpia. Y la forma maja, usar los modulos de CPAN que hacen grande a Perl. Lo anterior queda simplificado a esto:

#! /usr/bin/perl -w
use IO::Socket;
use strict;
 
my $host = "www.marca.es";
my $file = "/"; # el index vamos...
my $port = 80;
my $S = IO::Socket::INET->new
(
	Proto    => "tcp",
	PeerAddr => "$host",
	PeerPort => "$port",
)  or die "cannot connect!";
# para flushear nada mas escribir en el socket
select($S); $| = 1; select(STDOUT);
 
print $S "GET $file HTTP/1.1\nHOST: $host\n\n";
while(<$S>){ print }

Más simple ya, imposible. Ahora ya solo queda variar las peticiones que se mandan. Un GET no tiene mucha complejidad, solo recordar que en HTTP 1.1 hay que indicar el host y al final hay dos saltos de linea:

$peticion = 'GET /fichero/que/quiero/lala.php HTTP 1.1
HOST: www.LAwebQUEsea.com'."\n\n";
 
print $S $peticion
 

Para una peticion POST, tenemos que indicar la longitud de los datos que se envían, podemos usar algo del estilo (es un ejemplo inventado de un supuesto formulario para votar):

$voto = 10;
$discoID = 28912;
 
$peticionPost='POST /discos/votar.asp HTTP/1.1
Host: www.paginaQUEsea.com
Content-Type: application/x-www-form-urlencoded
Content-Length: ';
 
$post = 'accion=votar&id='.$discoID.'&voto='.$voto
$peticion = $peticionPost.length($post)."\n\n".$post
 
print $S $peticion;
 

Además de esto podemos enviar muchas más cabeceras (Cookies con sesiones php u otras cosas, Referer's, User-Agents, etc, etc...). Luego ya, según el escenario, después de obtener el resultado del servidor, se podría tratar y buscar patrones o lo que nos interesase, las combinaciones y posibilidades son infinitas.

Mirar cada disco uno a uno, no es una solución, pues me pegaría toda la tarde. Así que, como me aburro mucho estos días, esta mañana me he puesto ha hacer un script para que me diga que directorios tienen mp3's con bitrate mayor a uno que le indico. Además como me gustan mucho las estadisticas, he hecho que salgan también unas estadisticas globales de los bitrates.

El uso del script es:

bitrateFind [-r|--round] Directorio_base

El parametro round significa si las estadisticas finales se darán redondeadas o no (se refiere a los bitrates, pues los mp3s con VBR al leerlos dan como valor de su bitrate la media, entonces si no se redondea, quedan muy feas las estadisticas xD).

Un ejemplo de ejecución sería este:

[blaxter@helicon]:~/C/BlaxMusic/Trapt$ bitrateFind --round .
*Analizando los mp3's del directorio /media/C/BlaxMusic/Trapt
Analisis: 100% [============================]D 0h00m00s

Dirs with mp3's with bitrate > 128
./Trapt
./Someone In Control

Con bitrate 128: 1 (4.3 %) ===>
Con bitrate 192: 11 (47.8 %) =============================>
Con bitrate 256: 11 (47.8 %) =============================>
-Un total de 23 mp3s analizados

Y otra ejecución podría ser esta :

[blaxter@helicon]:~/C/BlaxMusic$ bitrateFind --round .
*Analizando los mp3's del directorio /media/C/BlaxMusic
Analisis: 100% [============================]D 0h02m18s

Dirs with mp3's with bitrate > 128
./Second - Invisible
./Evanescence/Fallen (Brazil Edition)/cd2
./Evanescence/Performance Live/Live on DC101 24-02-03
(...aqui van muchos directorios mas...)
./Foo Fighters/Foo Fighters/(2003) One By One (Limited Edition)
./Foo Fighters/Foo Fighters/(2003) One By One (Limited Edition)/Bonus CD

Con bitrate < 112: 28 (0.6 %) ->
Con bitrate 112: 28 (0.6 %) ->
Con bitrate 128: 2810 (64.9 %) =======================================>
Con bitrate 160: 89 (2.1 %) =->
Con bitrate 192: 1022 (23.6 %) ==============->
Con bitrate 256: 294 (6.8 %) ====->
Con bitrate > 256: 56 (1.3 %) =>
-Un total de 4327 mp3s analizados

Parece que voy a tener que usar el otro script un poco xD. Pero al menos ahora ya se que tengo que convertir .

Aquí para descargarlo

Mi caso II: pillo una canción con bastantes bajos, agudos y muy variada vamos, ... , la oigo a 320, 192, 128....no consigo adivinar cual es cual, OK, soy sordo, gran ventaja! .

Herramientas a usar: lame. Me leo el man, aja, veo que puedo convertir fácilmente, pero hay un gran problema, llamado Id3, los cuales los quiero mantener, son la base de cualquier biblioteca musical decente. OK, me haré un script para leerlos y pasárselo como parámetros al lame, el cual me convertirá las canciones (e insertará la información del id3 que le paso).

No problem, perl al poder, script pequeño pero útil. En definitiva es un simple script para recomprimir mp3 sin perder los id3 de éstos, aqui esta.

• BUG_1: Algunos nombres de ficheros con caracteres que podríamos denominar como raros falla, mayormente porque en el script se "escapan" dichos caracteres, y posiblemente alguno me habré dejado. Una solución para esto es simplemente renombrar los ficheros problemáticos.
• BUG_2: cuando el id3 del genero no está conforme al estandar Id3V1 (es decir una lista determinada de generos, lame --genre-list para verlos), peta también, mejor porque así he detectado incoherencias en los id3 y los he arreglado.

Por lo demás va a la perfección . 50gb de musica convertida en 20 . Y desde entonces toda la música que me estoy bajando la convierto con este script .

En ambos casos, estos "bugs" (o features?), por supuesto, no hacen que se borren los mp3's ni nada. Simplemente saldrá un lista de los comandos que han fallado (y posiblemente verás en dicho comando un parámetro del estilo --tg "__un_género__" el cual no es un género válido id3 o algún símbolo raro en el nombre del fichero, puedes copypastear dicho comando y sabrás exactamente el porqué falla).

Las instrucciones para usarlo son simples. Hay que tener en cuenta que el script trabajará con los mp3 únicamente del directorio actual. Esto lo he hecho así porque suelo tener los mp3 divididos por discos (como es lo normal creo yo) y gracias a otro script primero detecto qué discos tienen bitrate mayor que 128, y luego voy carpeta por carpeta usando este. Proceso que se podría automatizar, cierto; pero me gusta así.

$ wget http://www.bicosyes.com/code/recompress.txt
$ chmod +x recompress.txt
$ sudo mv recompress.txt /usr/bin/recompress # o a algún sitio en tu path
$ sudo aptitude install lame libterm-progressbar-perl libmp3-info-perl
$ cd MUSICA/directorio_con_mp3
$ recompress