[user@hostname ~]# sort -t: -k3 -n /etc/passwd

Este comando hace el sort por el campo 3 separado por : y saca este output.

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
lp:x:7:7:lp:/var/spool/lpd:/bin/sh
mail:x:8:8:mail:/var/mail:/bin/sh
news:x:9:9:news:/var/spool/news:/bin/sh
uucp:x:10:10:uucp:/var/spool/uucp:/bin/sh
proxy:x:13:13:proxy:/bin:/bin/sh

Buscando un rato me tope con este bug report en RedHat.
https://bugzilla.redhat.com/show_bug.cgi?id=529717

Parece ser que el problema es con el código de aceleración del mouse, pero el workaround funciona:


xset m 5 100


Esto es útil cuando tienes tu sistema de antispam y quieres poner una dirección como spam@dominio.com a donde tus usuarios pueden reportar su SPAM, así tu Spamassassin lo aprende como SPAM y tus filtros Bayesianos van madurando. Claro si usan IMAP este script es una tontería, pero a veces hay clientes que solo usan POP.

Este script esta pensado en que los correos los manden a spam@dominio.com haciendo un Forward as attachment sino no polucha.

#!/usr/bin/perl -w

## @class
# Esta clase implementa metodos para procesar el correo que llega
# al mbox spam. Este correo es lo que los usuarios reportan como
# Spam y el cual debe ser aprendido por spamassassin.

use strict;
use Mail::Mbox::MessageParser;
use MIME::Tools;
use MIME::Parser;
use Mail::SpamAssassin;

# Variables globales
my $CWD = '/usr/local/sbin/';
my $DEBUG = 1;
my $UNPACK_DIR = '/var/spool/amavis/mime';
my $LOG = $CWD . 'learn_mbox.log';
my $SPAM_FILE = $CWD . 'spam';
my $HAM_FILE = $CWD . 'ham';
my $SPAM_TYPE = 1;
my $HAM_TYPE = 2;
my $LEARN_TYPE = 0;

if ($DEBUG) {
	open(STDERR, ">$LOG");
}

## @method usage()
# Imprime la ayuda del comando
sub usage {
	print "$0 [--spam|--ham]\n";
}

## @method main
# La funcion de entrada al script
sub main {
	my $argc;
	$argc = @ARGV;

	if(@ARGV!=1) {
		usage();
		exit 1;
	}

	for($ARGV[0]) {
		if (/^--spam$/) { learn_mbox($SPAM_TYPE) }
		elsif (/^--ham$/) { learn_mbox($HAM_TYPE) }
		else  { usage(); exit 1; }
	}
}

## @method logger(string msg)
# Envia el mensage al archivo de logs
#
# @param msg El mensaje de error
sub logger {
	my $msg = shift;
	if ($DEBUG) {
		print STDERR "$msg\n";
	}
}

## @method learn_mbox
# Procesa el correo que esta en el mbox spam o ham, segun la opcion
# que especifique el usuario. Le pasa el correo a spamassassin
# para que lo aprenda como spam o ham.
sub learn_mbox {
	$LEARN_TYPE = shift;
	my $file_name = '';

	logger("learn_mbox ($LEARN_TYPE)");

	if ($DEBUG) {
		MIME::Tools->debugging(1);
	}

	if ($LEARN_TYPE == $SPAM_TYPE) {
		$file_name = $SPAM_FILE;
	}
	elsif ($LEARN_TYPE == $HAM_TYPE) {
		$file_name = $HAM_FILE;
	}
	else {
		logger("Error: No es Spam ni Ham. No se puede procesar.");
		exit 1;
	}

	# Set up cache. (Not necessary if enable_cache is false.)
	Mail::Mbox::MessageParser::SETUP_CACHE(
		{ 'file_name' => '/tmp/cache' } );

	my $file_handle = new FileHandle($file_name);
	my $folder_reader =
		new Mail::Mbox::MessageParser( {
			'file_name' => $file_name,
			'file_handle' => $file_handle,
			'enable_cache' => 1,
			'enable_grep' => 1,
		} );

	die $folder_reader unless ref $folder_reader;

	# Any newlines or such before the start of the first email
	my $prologue = $folder_reader->prologue;

	# This is the main loop. It's executed once for each email
	while(!$folder_reader->end_of_file())
	{
		my $email = $folder_reader->read_next_email();

		my $parser = new MIME::Parser;
		$parser->extract_nested_messages(0);
		$parser->output_under($UNPACK_DIR);
		my $entity;

		eval {
			$entity = $parser->parse_data($email);
		};

		if ($@) {
			die $@;
		} else {
			recurs($entity);
		}

		$parser->filer->purge;
		rmdir $parser->output_dir;
	}
}


sub recurs
{
	my $ent = shift;
	
	logger($ent->head->mime_type);
	if ($ent->head->mime_type eq 'message/rfc822') {

		#$ent->bodyhandle->print(\*OUT);
		my $mbody = $ent->bodyhandle->as_string;
		logger("--jargemails--");
		logger($mbody);
		logger("--jargemaile--");

		my $ma = Mail::SpamAssassin::Message->new(
			{message => $mbody, parse_now => 0});
		my $sa = Mail::SpamAssassin->new(
			{debug => 2, username => 'amavis'});

		if($LEARN_TYPE == $SPAM_TYPE) {
			$sa->report_as_spam($ma, 
				{dont_report_to_pyzor => 1, 
				dont_report_to_spamcop => 1});
		} elsif($LEARN_TYPE == $HAM_TYPE) {
			$sa->revoke_as_spam($ma);
		} else {
		}
	
		$ma->finish();
		$sa->finish();

		return;
	}

	my @parts = $ent->parts;

	if (@parts) {
		map { recurs($_) } @parts;
	}
}


main();
exit 0;

PD. Quisiera haber logrado que se viera mas bonito en mi blog, pero apenas estoy empezando a usar WordPress y no encontré si hay un plugin para colorear el código.

Tengo un servidor Samba con un recurso compartido. Cuando copiaba datos de el se tardaba mucho la transferencia, unos dos minutos una copia que debería tardarse segundos.

Después de moverle a varias cosas me di cuenta de que el problema era que deje los logs prendidos al máximo.

log level = 256

Los apague y mi transferencia de datos regreso a segundos.

log level = 0