[pmg-api.git] / PMG / CLI / pmgqm.pm

package PMG::CLI::pmgqm;

use strict;
use Data::Dumper;
use Template;
use MIME::Entity;
use HTML::Entities;
use Time::Local;
use Clone 'clone';
use Mail::Header;
use POSIX qw(strftime);
use File::Find;
use File::stat;
use URI::Escape;

use PVE::SafeSyslog;
use PVE::Tools;
use PVE::INotify;
use PVE::CLIHandler;

use PMG::RESTEnvironment;
use PMG::Utils;
use PMG::Ticket;
use PMG::DBTools;
use PMG::RuleDB;
use PMG::Config;
use PMG::ClusterConfig;
use PMG::API2::Quarantine;

use base qw(PVE::CLIHandler);

sub setup_environment {
    PMG::RESTEnvironment->setup_default_cli_env();
}

sub domain_regex {
    my ($domains) = @_;

    my @ra;
    foreach my $d (@$domains) {
	# skip domains with non-DNS name characters
	next if $d =~ m/[^A-Za-z0-9\-\.]/;
	if ($d =~ m/^\.(.*)$/) {
	    my $dom = $1;
	    $dom =~ s/\./\\\./g;
	    push @ra, $dom;
	    push @ra, "\.\*\\.$dom";
	} else {
	    $d =~ s/\./\\\./g;
	    push @ra, $d;
	}
    }

    my $re = join ('|', @ra);

    my $regex = qr/\@($re)$/i;

    return $regex;
}

sub get_item_data {
    my ($data, $ref) = @_;

    my @lines = split ('\n', $ref->{header});
    my $head = new Mail::Header(\@lines);

    my $item = {};

    $item->{id} = sprintf("C%dR%d", $ref->{cid}, $ref->{rid});

    $item->{subject} = PMG::Utils::rfc1522_to_html(
	PVE::Tools::trim($head->get('subject')) || 'No Subject');

    my @fromarray = split('\s*,\s*', $head->get('from') || $ref->{sender});
    my $from = PMG::Utils::rfc1522_to_html(PVE::Tools::trim($fromarray[0]));
    my $sender = PMG::Utils::rfc1522_to_html(PVE::Tools::trim($head->get('sender')));

    if ($sender) {
	$item->{sender} = $sender;
	$item->{from} = sprintf ("%s on behalf of %s", $sender, $from);
    } else {
	$item->{from} = $from;
    }

    $item->{pmail} = $ref->{pmail};
    $item->{receiver} = $ref->{receiver} || $ref->{pmail};

    $item->{date} = strftime("%F", localtime($ref->{time}));
    $item->{time} = strftime("%H:%M:%S", localtime($ref->{time}));

    $item->{bytes} = $ref->{bytes};
    $item->{spamlevel} = $ref->{spamlevel};
    $item->{spaminfo} = $ref->{info};

    my $title = "Received: $item->{date} $item->{time}\n";
    $title .= "From: $ref->{sender}\n";
    $title .= "To: $ref->{receiver}\n" if $ref->{receiver};
    $title .= sprintf("Size: %d KB\n", int (($ref->{bytes} + 1023) / 1024 ));
    $title .= sprintf("Spam level: %d\n", $ref->{spamlevel}) if $ref->{qtype} eq 'S';
    $title .= sprintf("Virus info: %s\n", encode_entities ($ref->{info})) if $ref->{qtype} eq 'V';
    $title .= sprintf("File: %s", encode_entities($ref->{file}));

    $item->{title} = $title;

    my $basehref = "https://$data->{fqdn}:$data->{port}/quarantine";
    my $ticket = uri_escape($data->{ticket});
    $item->{wlhref} = "$basehref?ticket=$ticket&cselect=$item->{id}&action=whitelist";
    $item->{blhref} = "$basehref?ticket=$ticket&cselect=$item->{id}&action=blacklist";
    $item->{deliverhref} = "$basehref?ticket=$ticket&cselect=$item->{id}&action=deliver";
    $item->{deletehref} = "$basehref?ticket=$ticket&cselect=$item->{id}&action=delete";

    return $item;
}

__PACKAGE__->register_method ({
    name => 'status',
    path => 'status',
    method => 'POST',
    description => "Print quarantine status (mails per user) for specified time span.",
    parameters => {
	additionalProperties => 0,
	properties => {
	    timespan => {
		description => "Select time span.",
		type => 'string',
		enum => ['today', 'yesterday', 'week'],
		default => 'today',
		optional => 1,
	    },
	},
    },
    returns => { type => 'null'},
    code => sub {
	my ($param) = @_;

	my $cinfo = PMG::ClusterConfig->new();
	my $role = $cinfo->{local}->{type} // '-';

	if (!(($role eq '-') || ($role eq 'master'))) {
	   die "local node is not mastern";
	}

	my $cfg = PMG::Config->new();

	my $timespan = $param->{timespan} // 'today';

	my ($start, $end) = PMG::Utils::lookup_timespan($timespan);

	my $hostname = PVE::INotify::nodename();

	my $fqdn = $cfg->get('spamquar', 'hostname') //
	    PVE::Tools::get_fqdn($hostname);


	my $dbh = PMG::DBTools::open_ruledb();

	my $domains = PVE::INotify::read_file('domains');
	my $domainregex = domain_regex([keys %$domains]);

	my $sth = $dbh->prepare(
	    "SELECT pmail, AVG(spamlevel) as spamlevel, count(*)  FROM CMailStore, CMSReceivers " .
	    "WHERE time >= $start AND time < $end AND " .
	    "QType = 'S' AND CID = CMailStore_CID AND RID = CMailStore_RID " .
	    "AND Status = 'N' " .
	    "GROUP BY pmail " .
	    "ORDER BY pmail");

	$sth->execute();

	print "Count  Spamlevel Mail\n";
	my $res = [];
	while (my $ref = $sth->fetchrow_hashref()) {
	    push @$res, $ref;
	    my $extern = ($domainregex && $ref->{pmail} !~ $domainregex);
	    my $hint = $extern ? " (external address)" : "";
	    printf ("%-5d %10.2f %s$hint\n", $ref->{count}, $ref->{spamlevel}, $ref->{pmail});
	}

	$sth->finish();

	return undef;
    }});

__PACKAGE__->register_method ({
    name => 'send',
    path => 'send',
    method => 'POST',
    description => "Generate and send spam report emails.",
    parameters => {
	additionalProperties => 0,
	properties => {
	    receiver => {
		description => "Generate report for a single email address. If not specified, generate reports for all users.",
		type => 'string', format => 'email',
		optional => 1,
	    },
	    timespan => {
		description => "Select time span.",
		type => 'string',
		enum => ['today', 'yesterday', 'week'],
		default => 'today',
		optional => 1,
	    },
	    style => {
		description => "Spam report style. Default value is read from spam quarantine configuration.",
		type => 'string',
		enum => ['short', 'verbose', 'custom'],
		optional => 1,
	    },
	    redirect => {
		description => "Redirect spam report email to this address.",
		type => 'string', format => 'email',
		optional => 1,
	    },
	    debug => {
		description => "Debug mode. Print raw email to stdout instead of sending them.",
		type => 'boolean',
		optional => 1,
		default => 0,
	    }
	},
    },
    returns => { type => 'null'},
    code => sub {
	my ($param) = @_;

	my $cinfo = PMG::ClusterConfig->new();
	my $role = $cinfo->{local}->{type} // '-';

	if (!(($role eq '-') || ($role eq 'master'))) {
	   die "local node is not master - not sending spam report\n";
	}

	my $cfg = PMG::Config->new();

	my $reportstyle = $param->{style} // $cfg->get('spamquar', 'reportstyle');

	return if $reportstyle eq 'none'; # do nothing

	my $timespan = $param->{timespan} // 'today';

	my ($start, $end) = PMG::Utils::lookup_timespan($timespan);

	my $hostname = PVE::INotify::nodename();

	my $fqdn = $cfg->get('spamquar', 'hostname') //
	    PVE::Tools::get_fqdn($hostname);

	my $port = 8006;

	my $global_data = {
	    protocol => 'https',
	    port => $port,
	    fqdn => $fqdn,
	    hostname => $hostname,
	    date => strftime("%F", localtime($end - 1)),
	    timespan => $timespan,
	    items => [],
	};

	my $mailfrom = $cfg->get ('spamquar', 'mailfrom') //
	    "Proxmox Mail Gateway <postmaster>";

	my $dbh = PMG::DBTools::open_ruledb();

	my $target = $param->{receiver};
	my $redirect = $param->{redirect};

	if (defined($redirect) && !defined($target)) {
	    die "can't redirect mails for all users\n";
	}

	my $domains = PVE::INotify::read_file('domains');
	my $domainregex = domain_regex([keys %$domains]);

	my $template = "spamreport-${reportstyle}.tt";
	my $found = 0;
	foreach my $path (@$PMG::Config::tt_include_path) {
	    if (-f "$path/$template") { $found = 1; last; }
	}
	if (!$found) {
	    warn "unable to find template '$template' - using default\n";
	    $template = "spamreport-verbose.tt";
	}

	my $sth = $dbh->prepare(
	    "SELECT * FROM CMailStore, CMSReceivers " .
	    "WHERE time >= $start AND time < $end AND " .
	    ($target ? "pmail = ? AND " : '') .
	    "QType = 'S' AND CID = CMailStore_CID AND RID = CMailStore_RID " .
	    "AND Status = 'N' " .
	    "ORDER BY pmail, time, receiver");

	if ($target) {
	    $sth->execute($target);
	} else {
	    $sth->execute();
	}

	my $lastref;
	my $mailcount = 0;
	my $creceiver = '';
	my $data;

	my $tt = PMG::Config::get_template_toolkit();

	my $finalize = sub {

	    my $extern = ($domainregex && $creceiver !~ $domainregex);
	    if (!$extern) {
		$data->{mailcount} = $mailcount;
		my $sendto = $redirect ? $redirect : $creceiver;
		PMG::Utils::finalize_report($tt, $template, $data, $mailfrom, $sendto, $param->{debug});
	    }
	};

	while (my $ref = $sth->fetchrow_hashref()) {
	    if ($creceiver ne $ref->{pmail}) {

		$finalize->() if $data;

		$data = clone($global_data);

		$creceiver = $ref->{pmail};
		$mailcount = 0;

		$data->{pmail} = $creceiver;
		$data->{ticket} = PMG::Ticket::assemble_quarantine_ticket($data->{pmail});
		my $esc_ticket = uri_escape($data->{ticket});
		$data->{managehref} = "https://$fqdn:$port/quarantine?ticket=${esc_ticket}";
	    }

	    push @{$data->{items}}, get_item_data($data, $ref);

	    $mailcount++;
	    $lastref = $ref;
	}

	$sth->finish();

	$finalize->() if $data;

	if (defined($target) && !$mailcount) {
	    print STDERR "no mails for '$target'\n";
	}

	return undef;
    }});

sub find_stale_files {
    my ($path, $lifetime, $purge) = @_;

    return if ! -d $path;

    my (undef, undef, undef, $mday, $mon, $year) = localtime(time());
    my $daystart = timelocal(0, 0, 0, $mday, $mon, $year);
    my $expire = $daystart - $lifetime*86400;

    my $wanted = sub {
	my $name = $File::Find::name;
	return if $name !~ m|^($path/.*)$|;
	$name = $1; # untaint
	my $stat = stat($name);
	return if ! -f _;
	return if $stat->mtime >= $expire;
	if ($purge) {
	    if (unlink($name)) {
		print "removed: $name\n";
	    }
	} else {
	    print "$name\n";
	}
    };

    find({ wanted => $wanted, no_chdir => 1 }, $path);
}

sub test_quarantine_files {
    my ($spamlifetime, $viruslifetime, $purge) = @_;

    print STDERR "searching for stale files\n" if !$purge;

    my $spooldir = $PMG::MailQueue::spooldir;

    find_stale_files ("$spooldir/spam", $spamlifetime, $purge);
    foreach my $dir (<"/var/spool/pmg/cluster/*/spam">) {
	next if $dir !~ m|^(/var/spool/pmg/cluster/\d+/spam)$|;
	$dir = $1; # untaint
	find_stale_files ($dir, $spamlifetime, $purge);
    }

    find_stale_files ("$spooldir/virus", $viruslifetime, $purge);
    foreach my $dir (<"/var/spool/pmg/cluster/*/virus">) {
	next if $dir !~ m|^(/var/spool/pmg/cluster/\d+/virus)$|;
	$dir = $1; # untaint
	find_stale_files ($dir, $viruslifetime, $purge);
    }
}

__PACKAGE__->register_method ({
    name => 'purge',
    path => 'purge',
    method => 'POST',
    description => "Cleanup Quarantine database. Remove entries older than configured quarantine lifetime.",
    parameters => {
	additionalProperties => 0,
	properties => {
	    check => {
		description => "Only search for quarantine files older than configured quarantine lifetime. Just print found files, but do not remove them.",
		type => 'boolean',
		optional => 1,
		default => 0,
	    }
	}
    },
    returns => { type => 'null'},
    code => sub {
	my ($param) = @_;

	my $cfg = PMG::Config->new();

	my $spamlifetime = $cfg->get('spamquar', 'lifetime');
	my $viruslifetime = $cfg->get ('virusquar', 'lifetime');

	my $purge = !$param->{check};

	if ($purge) {
	    print STDERR "purging database\n";

	    my $dbh = PMG::DBTools::open_ruledb();

	    if (my $count = PMG::DBTools::purge_quarantine_database($dbh, 'S', $spamlifetime)) {
		print STDERR "removed $count spam quarantine files\n";
	    }

	    if (my $count = PMG::DBTools::purge_quarantine_database($dbh, 'V', $viruslifetime)) {
		print STDERR "removed $count virus quarantine files\n";
	    }
	}

	test_quarantine_files($spamlifetime, $viruslifetime, $purge);

	return undef;
    }});


our $cmddef = {
    'purge' => [ __PACKAGE__, 'purge', []],
    'send' => [ __PACKAGE__, 'send', []],
    'status' => [ __PACKAGE__, 'status', []],
};

1;
Commit	Line	Data
fe6075cd	1	package PMG::CLI::pmgqm;
9a56f771 DM	2
	3	use strict;
	4	use Data::Dumper;
	5	use Template;
	6	use MIME::Entity;
	7	use HTML::Entities;
	8	use Time::Local;
	9	use Clone 'clone';
	10	use Mail::Header;
	11	use POSIX qw(strftime);
7205df3e	12	use File::Find;
04c66027	13	use File::stat;
d9750bee	14	use URI::Escape;
9a56f771 DM	15
	16	use PVE::SafeSyslog;
	17	use PVE::Tools;
	18	use PVE::INotify;
	19	use PVE::CLIHandler;
	20
	21	use PMG::RESTEnvironment;
	22	use PMG::Utils;
9a728eba	23	use PMG::Ticket;
9a56f771 DM	24	use PMG::DBTools;
	25	use PMG::RuleDB;
	26	use PMG::Config;
	27	use PMG::ClusterConfig;
b66faa68	28	use PMG::API2::Quarantine;
9a56f771 DM	29
	30	use base qw(PVE::CLIHandler);
	31
	32	sub setup_environment {
	33	PMG::RESTEnvironment->setup_default_cli_env();
	34	}
	35
	36	sub domain_regex {
	37	my ($domains) = @_;
	38
	39	my @ra;
	40	foreach my $d (@$domains) {
	41	# skip domains with non-DNS name characters
	42	next if $d =~ m/[^A-Za-z0-9\-\.]/;
	43	if ($d =~ m/^\.(.*)$/) {
	44	my $dom = $1;
	45	$dom =~ s/\./\\\./g;
	46	push @ra, $dom;
	47	push @ra, "\.\*\\.$dom";
	48	} else {
	49	$d =~ s/\./\\\./g;
	50	push @ra, $d;
	51	}
	52	}
	53
	54	my $re = join ('\|', @ra);
	55
	56	my $regex = qr/\@($re)$/i;
	57
	58	return $regex;
	59	}
	60
	61	sub get_item_data {
1d20daff	62	my ($data, $ref) = @_;
9a56f771 DM	63
	64	my @lines = split ('\n', $ref->{header});
	65	my $head = new Mail::Header(\@lines);
	66
1d20daff	67	my $item = {};
f46af1cf DM	68
f46af1cf DM	69	$item->{id} = sprintf("C%dR%d", $ref->{cid}, $ref->{rid});
252b770d	70
1d20daff	71	$item->{subject} = PMG::Utils::rfc1522_to_html(
9a56f771 DM	72	PVE::Tools::trim($head->get('subject')) \|\| 'No Subject');
	73
	74	my @fromarray = split('\s,\s', $head->get('from') \|\| $ref->{sender});
	75	my $from = PMG::Utils::rfc1522_to_html(PVE::Tools::trim($fromarray[0]));
	76	my $sender = PMG::Utils::rfc1522_to_html(PVE::Tools::trim($head->get('sender')));
	77
	78	if ($sender) {
1d20daff DM	79	$item->{sender} = $sender;
1d20daff DM	80	$item->{from} = sprintf ("%s on behalf of %s", $sender, $from);
9a56f771	81	} else {
1d20daff	82	$item->{from} = $from;
9a56f771 DM	83	}
9a56f771 DM	84
1d20daff DM	85	$item->{pmail} = $ref->{pmail};
1d20daff DM	86	$item->{receiver} = $ref->{receiver} \|\| $ref->{pmail};
9a56f771	87
1d20daff DM	88	$item->{date} = strftime("%F", localtime($ref->{time}));
1d20daff DM	89	$item->{time} = strftime("%H:%M:%S", localtime($ref->{time}));
252b770d	90
1d20daff DM	91	$item->{bytes} = $ref->{bytes};
	92	$item->{spamlevel} = $ref->{spamlevel};
	93	$item->{spaminfo} = $ref->{info};
252b770d	94
1d20daff	95	my $title = "Received: $item->{date} $item->{time}\n";
9a56f771 DM	96	$title .= "From: $ref->{sender}\n";
	97	$title .= "To: $ref->{receiver}\n" if $ref->{receiver};
	98	$title .= sprintf("Size: %d KB\n", int (($ref->{bytes} + 1023) / 1024 ));
	99	$title .= sprintf("Spam level: %d\n", $ref->{spamlevel}) if $ref->{qtype} eq 'S';
	100	$title .= sprintf("Virus info: %s\n", encode_entities ($ref->{info})) if $ref->{qtype} eq 'V';
	101	$title .= sprintf("File: %s", encode_entities($ref->{file}));
	102
1d20daff	103	$item->{title} = $title;
9b0428e2	104
7eebbc6b	105	my $basehref = "https://$data->{fqdn}:$data->{port}/quarantine";
d9750bee	106	my $ticket = uri_escape($data->{ticket});
e13942a1 DM	107	$item->{wlhref} = "$basehref?ticket=$ticket&cselect=$item->{id}&action=whitelist";
	108	$item->{blhref} = "$basehref?ticket=$ticket&cselect=$item->{id}&action=blacklist";
	109	$item->{deliverhref} = "$basehref?ticket=$ticket&cselect=$item->{id}&action=deliver";
	110	$item->{deletehref} = "$basehref?ticket=$ticket&cselect=$item->{id}&action=delete";
1d20daff DM	111
1d20daff DM	112	return $item;
9a56f771 DM	113	}
9a56f771 DM	114
252b770d DM	115	__PACKAGE__->register_method ({
	116	name => 'status',
	117	path => 'status',
	118	method => 'POST',
	119	description => "Print quarantine status (mails per user) for specified time span.",
	120	parameters => {
	121	additionalProperties => 0,
	122	properties => {
	123	timespan => {
	124	description => "Select time span.",
	125	type => 'string',
	126	enum => ['today', 'yesterday', 'week'],
	127	default => 'today',
	128	optional => 1,
	129	},
	130	},
	131	},
	132	returns => { type => 'null'},
	133	code => sub {
	134	my ($param) = @_;
	135
	136	my $cinfo = PMG::ClusterConfig->new();
	137	my $role = $cinfo->{local}->{type} // '-';
	138
	139	if (!(($role eq '-') \|\| ($role eq 'master'))) {
	140	die "local node is not mastern";
	141	}
	142
	143	my $cfg = PMG::Config->new();
	144
	145	my $timespan = $param->{timespan} // 'today';
	146
	147	my ($start, $end) = PMG::Utils::lookup_timespan($timespan);
	148
	149	my $hostname = PVE::INotify::nodename();
	150
	151	my $fqdn = $cfg->get('spamquar', 'hostname') //
	152	PVE::Tools::get_fqdn($hostname);
	153
	154
	155	my $dbh = PMG::DBTools::open_ruledb();
	156
	157	my $domains = PVE::INotify::read_file('domains');
	158	my $domainregex = domain_regex([keys %$domains]);
	159
	160	my $sth = $dbh->prepare(
	161	"SELECT pmail, AVG(spamlevel) as spamlevel, count(*) FROM CMailStore, CMSReceivers " .
	162	"WHERE time >= $start AND time < $end AND " .
	163	"QType = 'S' AND CID = CMailStore_CID AND RID = CMailStore_RID " .
	164	"AND Status = 'N' " .
	165	"GROUP BY pmail " .
	166	"ORDER BY pmail");
	167
	168	$sth->execute();
	169
	170	print "Count Spamlevel Mail\n";
	171	my $res = [];
	172	while (my $ref = $sth->fetchrow_hashref()) {
	173	push @$res, $ref;
	174	my $extern = ($domainregex && $ref->{pmail} !~ $domainregex);
	175	my $hint = $extern ? " (external address)" : "";
	176	printf ("%-5d %10.2f %s$hint\n", $ref->{count}, $ref->{spamlevel}, $ref->{pmail});
	177	}
	178
179	$sth->finish();
180
181	return undef;
182	}});
183
9a56f771 DM	184	__PACKAGE__->register_method ({
	185	name => 'send',
	186	path => 'send',
	187	method => 'POST',
	188	description => "Generate and send spam report emails.",
	189	parameters => {
	190	additionalProperties => 0,
	191	properties => {
	192	receiver => {
	193	description => "Generate report for a single email address. If not specified, generate reports for all users.",
	194	type => 'string', format => 'email',
252b770d	195	optional => 1,
9a56f771 DM	196	},
	197	timespan => {
	198	description => "Select time span.",
	199	type => 'string',
	200	enum => ['today', 'yesterday', 'week'],
	201	default => 'today',
	202	optional => 1,
	203	},
	204	style => {
252b770d	205	description => "Spam report style. Default value is read from spam quarantine configuration.",
9a56f771	206	type => 'string',
252b770d	207	enum => ['short', 'verbose', 'custom'],
9a56f771	208	optional => 1,
9a56f771 DM	209	},
	210	redirect => {
	211	description => "Redirect spam report email to this address.",
	212	type => 'string', format => 'email',
	213	optional => 1,
	214	},
f73a1872 DM	215	debug => {
	216	description => "Debug mode. Print raw email to stdout instead of sending them.",
	217	type => 'boolean',
	218	optional => 1,
	219	default => 0,
	220	}
9a56f771 DM	221	},
	222	},
	223	returns => { type => 'null'},
	224	code => sub {
	225	my ($param) = @_;
	226
	227	my $cinfo = PMG::ClusterConfig->new();
	228	my $role = $cinfo->{local}->{type} // '-';
	229
	230	if (!(($role eq '-') \|\| ($role eq 'master'))) {
	231	die "local node is not master - not sending spam report\n";
252b770d	232	}
9a56f771 DM	233
	234	my $cfg = PMG::Config->new();
	235
f73a1872	236	my $reportstyle = $param->{style} // $cfg->get('spamquar', 'reportstyle');
9a56f771	237
252b770d DM	238	return if $reportstyle eq 'none'; # do nothing
252b770d DM	239
9a56f771 DM	240	my $timespan = $param->{timespan} // 'today';
9a56f771 DM	241
2f7031b7	242	my ($start, $end) = PMG::Utils::lookup_timespan($timespan);
9a56f771 DM	243
9a56f771 DM	244	my $hostname = PVE::INotify::nodename();
252b770d DM	245
252b770d DM	246	my $fqdn = $cfg->get('spamquar', 'hostname') //
9a56f771	247	PVE::Tools::get_fqdn($hostname);
252b770d	248
9a56f771	249	my $port = 8006;
252b770d	250
9a56f771 DM	251	my $global_data = {
	252	protocol => 'https',
	253	port => $port,
	254	fqdn => $fqdn,
	255	hostname => $hostname,
9a56f771 DM	256	date => strftime("%F", localtime($end - 1)),
	257	timespan => $timespan,
	258	items => [],
	259	};
	260
252b770d	261	my $mailfrom = $cfg->get ('spamquar', 'mailfrom') //
9a56f771	262	"Proxmox Mail Gateway <postmaster>";
252b770d	263
9a56f771 DM	264	my $dbh = PMG::DBTools::open_ruledb();
	265
	266	my $target = $param->{receiver};
	267	my $redirect = $param->{redirect};
252b770d	268
1388c118	269	if (defined($redirect) && !defined($target)) {
9a56f771 DM	270	die "can't redirect mails for all users\n";
9a56f771 DM	271	}
252b770d	272
9a56f771 DM	273	my $domains = PVE::INotify::read_file('domains');
	274	my $domainregex = domain_regex([keys %$domains]);
	275
252b770d DM	276	my $template = "spamreport-${reportstyle}.tt";
	277	my $found = 0;
	278	foreach my $path (@$PMG::Config::tt_include_path) {
	279	if (-f "$path/$template") { $found = 1; last; }
	280	}
	281	if (!$found) {
	282	warn "unable to find template '$template' - using default\n";
	283	$template = "spamreport-verbose.tt";
9a56f771	284	}
78ee390d	285
9a56f771	286	my $sth = $dbh->prepare(
252b770d DM	287	"SELECT * FROM CMailStore, CMSReceivers " .
252b770d DM	288	"WHERE time >= $start AND time < $end AND " .
9a56f771 DM	289	($target ? "pmail = ? AND " : '') .
	290	"QType = 'S' AND CID = CMailStore_CID AND RID = CMailStore_RID " .
	291	"AND Status = 'N' " .
	292	"ORDER BY pmail, time, receiver");
252b770d	293
9a56f771 DM	294	if ($target) {
	295	$sth->execute($target);
	296	} else {
	297	$sth->execute();
	298	}
	299
	300	my $lastref;
	301	my $mailcount = 0;
	302	my $creceiver = '';
	303	my $data;
78ee390d	304
310daf18 DM	305	my $tt = PMG::Config::get_template_toolkit();
310daf18 DM	306
9a56f771	307	my $finalize = sub {
252b770d	308
9a56f771	309	my $extern = ($domainregex && $creceiver !~ $domainregex);
252b770d DM	310	if (!$extern) {
	311	$data->{mailcount} = $mailcount;
	312	my $sendto = $redirect ? $redirect : $creceiver;
	313	PMG::Utils::finalize_report($tt, $template, $data, $mailfrom, $sendto, $param->{debug});
9a56f771 DM	314	}
9a56f771 DM	315	};
252b770d	316
9a56f771 DM	317	while (my $ref = $sth->fetchrow_hashref()) {
	318	if ($creceiver ne $ref->{pmail}) {
	319
	320	$finalize->() if $data;
	321
	322	$data = clone($global_data);
252b770d	323
9a56f771 DM	324	$creceiver = $ref->{pmail};
	325	$mailcount = 0;
	326
	327	$data->{pmail} = $creceiver;
f46af1cf	328	$data->{ticket} = PMG::Ticket::assemble_quarantine_ticket($data->{pmail});
d9750bee DM	329	my $esc_ticket = uri_escape($data->{ticket});
d9750bee DM	330	$data->{managehref} = "https://$fqdn:$port/quarantine?ticket=${esc_ticket}";
9a56f771 DM	331	}
9a56f771 DM	332
252b770d DM	333	push @{$data->{items}}, get_item_data($data, $ref);
252b770d DM	334
9a56f771 DM	335	$mailcount++;
	336	$lastref = $ref;
	337	}
	338
	339	$sth->finish();
	340
	341	$finalize->() if $data;
	342
	343	if (defined($target) && !$mailcount) {
	344	print STDERR "no mails for '$target'\n";
	345	}
	346
	347	return undef;
	348	}});
	349
	350	sub find_stale_files {
	351	my ($path, $lifetime, $purge) = @_;
	352
7205df3e DM	353	return if ! -d $path;
7205df3e DM	354
27fbc388 DM	355	my (undef, undef, undef, $mday, $mon, $year) = localtime(time());
	356	my $daystart = timelocal(0, 0, 0, $mday, $mon, $year);
	357	my $expire = $daystart - $lifetime*86400;
	358
	359	my $wanted = sub {
	360	my $name = $File::Find::name;
	361	return if $name !~ m\|^($path/.*)$\|;
	362	$name = $1; # untaint
	363	my $stat = stat($name);
	364	return if ! -f _;
cd938884	365	return if $stat->mtime >= $expire;
27fbc388 DM	366	if ($purge) {
	367	if (unlink($name)) {
	368	print "removed: $name\n";
	369	}
	370	} else {
	371	print "$name\n";
	372	}
	373	};
9a56f771	374
27fbc388	375	find({ wanted => $wanted, no_chdir => 1 }, $path);
9a56f771 DM	376	}
	377
	378	sub test_quarantine_files {
	379	my ($spamlifetime, $viruslifetime, $purge) = @_;
252b770d DM	380
252b770d DM	381	print STDERR "searching for stale files\n" if !$purge;
9a56f771	382
7205df3e DM	383	my $spooldir = $PMG::MailQueue::spooldir;
	384
	385	find_stale_files ("$spooldir/spam", $spamlifetime, $purge);
	386	foreach my $dir (<"/var/spool/pmg/cluster/*/spam">) {
	387	next if $dir !~ m\|^(/var/spool/pmg/cluster/\d+/spam)$\|;
	388	$dir = $1; # untaint
	389	find_stale_files ($dir, $spamlifetime, $purge);
	390	}
9a56f771	391
7205df3e DM	392	find_stale_files ("$spooldir/virus", $viruslifetime, $purge);
	393	foreach my $dir (<"/var/spool/pmg/cluster/*/virus">) {
	394	next if $dir !~ m\|^(/var/spool/pmg/cluster/\d+/virus)$\|;
	395	$dir = $1; # untaint
	396	find_stale_files ($dir, $viruslifetime, $purge);
	397	}
9a56f771 DM	398	}
	399
	400	__PACKAGE__->register_method ({
	401	name => 'purge',
	402	path => 'purge',
	403	method => 'POST',
	404	description => "Cleanup Quarantine database. Remove entries older than configured quarantine lifetime.",
	405	parameters => {
	406	additionalProperties => 0,
27fbc388 DM	407	properties => {
27fbc388 DM	408	check => {
b66faa68	409	description => "Only search for quarantine files older than configured quarantine lifetime. Just print found files, but do not remove them.",
27fbc388 DM	410	type => 'boolean',
	411	optional => 1,
	412	default => 0,
	413	}
	414	}
9a56f771 DM	415	},
	416	returns => { type => 'null'},
	417	code => sub {
	418	my ($param) = @_;
	419
	420	my $cfg = PMG::Config->new();
	421
	422	my $spamlifetime = $cfg->get('spamquar', 'lifetime');
	423	my $viruslifetime = $cfg->get ('virusquar', 'lifetime');
	424
27fbc388	425	my $purge = !$param->{check};
9a56f771	426
27fbc388	427	if ($purge) {
252b770d	428	print STDERR "purging database\n";
9a56f771	429
27fbc388 DM	430	my $dbh = PMG::DBTools::open_ruledb();
	431
	432	if (my $count = PMG::DBTools::purge_quarantine_database($dbh, 'S', $spamlifetime)) {
252b770d	433	print STDERR "removed $count spam quarantine files\n";
27fbc388	434	}
9a56f771	435
27fbc388	436	if (my $count = PMG::DBTools::purge_quarantine_database($dbh, 'V', $viruslifetime)) {
252b770d	437	print STDERR "removed $count virus quarantine files\n";
27fbc388	438	}
9a56f771 DM	439	}
9a56f771 DM	440
27fbc388	441	test_quarantine_files($spamlifetime, $viruslifetime, $purge);
9a56f771 DM	442
	443	return undef;
	444	}});
	445
9a56f771 DM	446
9a56f771 DM	447	our $cmddef = {
9a56f771 DM	448	'purge' => [ __PACKAGE__, 'purge', []],
9a56f771 DM	449	'send' => [ __PACKAGE__, 'send', []],
252b770d	450	'status' => [ __PACKAGE__, 'status', []],
9a56f771 DM	451	};
	452
	453	1;