path: root/rspamc.pl.in

#!/usr/bin/perl -w

# Simple script that read message from STDIN and test it on rspamd server
# using specified command.
#
# Usage: rspamc.pl [-c conf_file] [command] [-s statfile]
#
# By default rspamc.pl would read ./rspamd.conf and default command is SYMBOLS

use Socket qw(:DEFAULT :crlf);
use Getopt::Std;

my %cfg = (
    'conf_file' => '@CMAKE_INSTALL_PREFIX@/etc/rspamd.conf',
    'command'   => 'SYMBOLS',
    'host'      => 'localhost',
    'port'      => '11333',
    'is_unix'   =>  0,
	'require_input'	=> 0,
    'password'  =>  '',
    'control'   =>  0,
    'statfile'  =>  '',
	'deliver_to'=>  '',
);

$main::VERSION = '@RSPAMD_VERSION@';

sub HELP_MESSAGE {
    print <<EOD;
Usage: rspamc.pl [-h host] [-p port] [-P password] [-c conf_file] [-s statfile] [-d user\@domain] [command] [path]
-h         host to connect or unix socket path
-p         port to connect (not used with unix sockets)
-P         define control password
-c         config file to parse
-s         statfile to use for learn commands
-d         define deliver-to header
imap format: imap:user:<username>:password:<password>:host:<hostname>:mbox:<mboxname>
Version:   @RSPAMD_VERSION@
EOD
};

# Load rspamd config params
sub parse_config {
    my ($is_ctrl) = @_;

    open CONF, "< $cfg{'conf_file'}" or die "config file $cfg{'conf_file'} cannot be opened";

    my $ctrl = 0, $skip = 0;
    while (<CONF>) {
        if ($_ =~ /^.*type.*=.*controller.*$/i) {
            $ctrl = 1;
        }
        if ($ctrl && $_ =~ /}/) {
            $ctrl = 0;
        }
        if ($_ =~ /^.*type.*=.*(?:lmtp|delivery|fuzzy).*$/i) {
            $skip = 1;
        }
        if ($skip && $_ =~ /}/) {
            $skip = 0;
        }
        if (!$skip && ((!$is_ctrl && !$ctrl) || ($ctrl && $is_ctrl))
                && $_ =~ /^\s*bind_socket\s*=\s*((([^:]+):(\d+))|(\/\S*))/i) {
            if ($3 && $4) {
                $cfg{'host'} = $3;
                $cfg{'port'} = $4;
                $cfg{'is_unix'} = 0;
            }
            else {
                $cfg{'host'} = $5;
                $cfg{'is_unix'} = 1;
            }
        }
        if ($ctrl && $is_ctrl && $_ =~ /^\s*password\s*=\s*"(\S+)"/) {
            $cfg{'password'} = $1;
        }
    }

    close CONF;

}

sub make_tcp_socket {
	my ($host, $port) = @_; 
	my $proto = getprotobyname('tcp');
	my $sin;

	socket ($sock, PF_INET, SOCK_STREAM, $proto) or die "cannot create tcp socket";
	if ($host eq '*') {
		$host = '127.0.0.1';
	}
	if (inet_aton ($host)) {
		$sin = sockaddr_in ($port, inet_aton($host));
	}
	else {
		my $addr = gethostbyname($host);
		if (!$addr) {
			die "cannot resolve $host";
		}
		$sin = sockaddr_in ($port, $addr);
	}
	
	connect ($sock, $sin) or die "cannot connect to socket $host:$port";

	return $sock;
}

sub make_ssl_socket {
	my ($host, $port) = @_; 
	
	eval {
		use IO::Socket::SSL;
	} or die 'cannot connect to imap without IO::Socket::SSL';

	return IO::Socket::SSL->new("$host:$port");
}

sub connect_socket {
    my $sock;

    if ($cfg{'is_unix'}) {
        socket ($sock, PF_UNIX, SOCK_STREAM, 0) or die "cannot create unix socket";
        my $sun = sockaddr_un($cfg{'host'});
        connect ($sock, $sun) or die "cannot connect to socket $cfg{'host'}";
    }
    else {
		$sock = make_tcp_socket ($cfg{'host'}, $cfg{'port'});
    }
    return $sock;
}

# Currently just read stdin for user's message and pass it to rspamd
sub do_rspamc_command {
    my ($sock, $input) = @_;

    print "Sending ". length ($input) ." bytes...\n";

    syswrite $sock, "$cfg{'command'} RSPAMC/1.1 $CRLF";
	if ($cfg{'deliver_to'}) {
		syswrite $sock, "Deliver-To: " . $cfg{'deliver_to'} . $CRLF;
	}
    syswrite $sock, "Content-Length: " . length ($input) . $CRLF . $CRLF;
    syswrite $sock, $input;
    syswrite $sock, $CRLF;
    while (defined (my $line = <$sock>)) {
        print $line;
    }
}

sub do_ctrl_auth {
    my ($sock) = @_;

    syswrite $sock, "password $cfg{'password'}" . $CRLF;
    if (defined (my $reply = <$sock>)) {
        my $end = <$sock>;
        if ($reply =~ /^password accepted/) {
            return 1;
        }
    }

    return 0;
}

sub do_control_command {
    my ($sock, $input) = @_;

    # Read greeting first
    if (defined (my $greeting = <$sock>)) {
        if ($greeting !~ /^Rspamd version/) {
            die "not rspamd greeting line $greeting";
        }
    }
    if ($cfg{'command'} =~ /^learn$/i) {
        die "statfile is not specified to learn command" if !$cfg{'statfile'};
        
        
        if (do_ctrl_auth ($sock)) {
            my $len = length ($input);
            print "Sending $len bytes...\n";
            syswrite $sock, "learn $cfg{'statfile'} $len" . $CRLF;
            syswrite $sock, $input . $CRLF;
            if (defined (my $reply = <$sock>)) {
                if ($reply =~ /^learn ok, sum weight: ([0-9.]+)/) {
                    print "Learn succeed. Sum weight: $1\n";
                }
                else {
                    print "Learn failed\n";
                }
            }
        }
        else {
            print "Authentication failed\n";
        }
    }
    elsif ($cfg{'command'} =~ /(reload|shutdown)/i) {
        if (do_ctrl_auth ($sock)) {
            syswrite $sock, $cfg{'command'} . $CRLF;
            while (defined (my $line = <$sock>)) {
                last if $line =~ /^END/;
                print $line;
            }
        }
        else {
            print "Authentication failed\n";
        }
    }
    elsif ($cfg{'command'} =~ /(fuzzy_add|fuzzy_del)/i) {
        if (do_ctrl_auth ($sock)) {
            my $len = length ($input);
            print "Sending $len bytes...\n";
            syswrite $sock, $cfg{'command'} . " $len" . $CRLF;
            syswrite $sock, $input . $CRLF;
            if (defined (my $reply = <$sock>)) {
                if ($reply =~ /^OK/) {
                    print $cfg{'command'} . " succeed\n";
                }
                else {
                    print $cfg{'command'} . " failed\n";
                }
            }
        }
        else {
            print "Authentication failed\n";
        }
    
    }
    else {
        syswrite $sock, $cfg{'command'} . $CRLF;
        while (defined (my $line = <$sock>)) {
            last if $line =~ /^END/;
            print $line;
        }
    }
}

sub process_file {
	my $file = shift;

	print "Process file: $file\n";
	open(FILE, "< $file") or return;
	
	my $input;
	while (defined (my $line = <FILE>)) {
		$input .= $line;
	}
	
	close FILE;
	do_cmd ($input);
}

sub process_directory {
	my $dir = shift;

	opendir (DIR, $dir) or return;

	while (defined (my $file = readdir (DIR))) {
		$file = "$dir/$file";
		if (-f $file) {
			process_file ($file);
		}	
	}
	closedir (DIR);
}

sub check_imap_reply {
	my $sock = shift;
	my $seq = shift;

	while (defined (<$sock>)) {
		chomp;
		next if ($_ =~ /^\*/);
		if ($_ =~ /^$seq OK/) {
			return 1;
		}
		return 0;
	}

	return 0;
}

sub parse_imap_sequences {
	my $sock = shift;
	my $seq = shift;
	my $input;
	my $got_body = 0;

	while (defined (<$sock>)) {
		if (!$got_body && $_ =~ /^\*/) {
			$got_body = 1;
			next;
		}
		if ($_ =~ /^$seq OK/) {
			return $input;
		}
		elsif ($got_body) {
			$input .= $_ . $CRLF;
		}

		return undef;
	}

	return undef;

}

sub process_imap_body {
	my $sock = shift;
	my $seq = shift;
	my $input;

	while (defined (<$sock>)) {
		chomp;
		if ($_ =~ /^\* SEARCH (.+)$/) {
			@res = split (/\s/, $1);
			next;
		}
		elsif ($_ =~ /^$seq OK/) {
			return \@res;
		}
		return undef;
	}

}

sub process_imap {
	my ($ssl, $user, $password, $host, $mbox) = @_;
	my $seq = 1;
	my $sock;
	print "Process imap: host: $host, mbox: $mbox\n";

	# Stupid code that does not take care of timeouts etc, just trying to extract messages
	if ($ssl) {
		$sock = make_ssl_socket ($host, 'imaps');
	}
	else {
		$sock = make_tcp_socket ($host, 143);
	}
	syswrite $sock, "$seq LOGIN $user $password$CRLF";
	if (!check_imap_reply ($sock, $seq)) {
		return;
	}
	$seq ++;
	syswrite $sock, "$seq SELECT $mbox$CRLF";
	if (!check_imap_reply ($sock, $seq)) {
		return;
	}
	$seq ++;
	syswrite $sock, "$seq FIND ALL$CRLF";
	my $messages;
	if (!defined ($messages = parse_imap_sequences ($sock, $seq))) {
		return;
	}
	$seq ++;
	foreach my $message (@{ $messages }){
		syswrite $sock, "$seq FETCH $message body[]$CRLF";
		if (defined (my $input = parse_imap_body ($sock, $seq))) {
			do_cmd ($input);
		}
		$seq ++;
	} 
	syswrite $sock, "$seq LOGOUT$CRLF";
	close $sock;
}

# Single item
sub process_item {
	my $item = shift;
	
	print "Processing $item\n";
	if (defined ($item)) {
		if ($item =~ qr|^imap(s?):user:([^:]+):password:([^:]):host:([^:]):mbox:(.+)$|) {
			process_imap_folder ($1, $2, $3, $4, $5);
		}
		elsif (-f $item) {
			process_file ($item);
		}
		elsif (-d $item) {
			process_directory ($item);
		}
		else {
			warn "urecognized argument: $item";
		}
	}
}

# Do specified command for each file in path or 
sub process_path {
	foreach (@_) {
		process_item($_);
	}
}

# Do specified command for specified input
sub do_cmd {
	my $input = shift;

    my $sock = connect_socket ();

    if ($cfg{'control'}) {
        do_control_command ($sock, $input);
    }
    else {
        do_rspamc_command ($sock, $input);
    }

    close ($sock);
}

############################# Main part ###########################################
my %args;
getopt('c:h:p:P:s:d:', \%args);
my $cmd = shift;
my @path = shift;
my $do_parse_config = 1;

if (!defined ($cmd) || $cmd eq '') {
    $cmd = 'SYMBOLS';
}

if (defined ($args{c})) {
     if (-r $args{c}) {
            $cfg{'conf_file'} = $args{c};
            $do_parse_config = 1;
     }
     else {
        die "config file $args{c} is not readable";
     }

}
if (defined ($args{s})) {
    if ($args{s}) {
        $cfg{'statfile'} = $args{s};
    }
    else {
        main::HELP_MESSAGE();
        exit;
    }
}
if (defined ($args{h})) {
    $cfg{'host'} = $args{h};
    if ($args{h} =~ /^\/.*$/) {
        $cfg{'is_unix'} = 1;
    }
    $do_parse_config = 0;
}
if (defined ($args{p})) {
    $cfg{'port'} = $args{p};
}
if (defined ($args{P})) {
    $cfg{'password'} = $args{P};
}
if (defined ($args{d})) {
	$cfg{'deliver_to'} = $args{d};
}

if ($cmd =~ /(SYMBOLS|SCAN|PROCESS|CHECK|REPORT_IFSPAM|REPORT|URLS|EMAILS)/i) {
    $cfg{'command'} = $1;
    $cfg{'control'} = 0;
}
elsif ($cmd =~ /(STAT|LEARN|SHUTDOWN|RELOAD|UPTIME|COUNTERS|FUZZY_ADD|FUZZY_DEL)/i) {
    $cfg{'command'} = $1;
    $cfg{'control'} = 1;
}
else {
    die "unknown command $cmd";
}

if ($cmd =~ /SYMBOLS|SCAN|PROCESS|CHECK|REPORT_IFSPAM|REPORT|URLS|EMAILS|LEARN|FUZZY_ADD|FUZZY_DEL/i) {
	$cfg{'require_input'} = 1;
}

if ($do_parse_config != 0) {
    parse_config ($cfg{'control'});
}

if (!defined ($path[0]) || ! $cfg{'require_input'}) {
	my $input;
	if ($cfg{'require_input'}) {
		while (defined (my $line = <>)) {
			$input .= $line;
		}
	}
	do_cmd ($input);
}
else {
	process_path (@path);
}