File Coverage

blib/lib/Mail/IspMailGate/Filter/VirScan.pm

Criterion	Covered	Total	%
statement	100	121	82.6
branch	19	34	55.8
condition	3	3	100.0
subroutine	14	15	93.3
pod	7	9	77.7
total	143	182	78.5

# -*- perl -*-
#


use strict;
require 5.005;

use File::Copy ();
use File::Basename ();
use Symbol ();
use Mail::IspMailGate::Filter ();
use File::Spec ();


package Mail::IspMailGate::Filter::VirScan;

@Mail::IspMailGate::Filter::VirScan::ISA = qw(Mail::IspMailGate::Filter);

sub getSign { "X-ispMailGate-VirScan" }

#####################################################################
#
#   Name:     mustFilter
#
#   Purpose:   determines wether this message must be filtered and
#             allowed to modify $self the message and so on
#
#   Inputs:   $self   - This class
#             $entity - the whole message
#
#
#   Returns:  1 if it must be, else 0
#
#####################################################################

sub mustFilter ($$) {
    # Always true (consider faked headers!)
    1;
}


#####################################################################
#
#   Name:     hookFilter
#
#   Purpose:  a function which is called after the filtering process
#
#   Inputs:   $self   - This class
#             $entity - the whole message
#
#
#   Returns:  errormessage if any
#
#####################################################################

sub hookFilter ($$) {
    my($self, $entity) = @_;
    my($head) = $entity->head;
    $head->set($self->getSign(), 'scanned');
    '';
}



#####################################################################
#
#   Name:     createDir
#
#   Purpse:   creates a new directory, under the given
#
#   Inputs:   $self   - This class
#             $attr   - Attributes
#
#   Returns:  the name of the new dir
#
#####################################################################

sub createDir ($$) {
    my ($self, $attr) = @_;

    my($baseDir) = $attr->{'parser'}->output_dir();
    my($i) = 0;
    my($dir);

    while (-e ($dir = "$baseDir/dir$i")) {
	++$i;
    }
    if (!mkdir $dir, 0700) {
	die "Cannot create directory $dir ($!)";
    }
    $dir;
}


#####################################################################
#
#   Name:     checkDirFiles
#
#   Purpse:   creates a list of files from a certain directory,
#             including subdirectories
#
#   Inputs:   $self   - This instance
#             $dir    - Directory name
#
#   Returns:  File list; dies in case of trouble
#
#####################################################################

sub checkDirFiles ($$) {
    my($self, $dir) = @_;
    my(@files);

    #
    # Recursively scan directory $dir for files
    #
    my($dirHandle) = Symbol::gensym();
    if (!opendir($dirHandle, $dir)) {
	die "Cannot read directory $dir ($!)";
    }
    my($file);
    while (defined($file = readdir($dirHandle))) {
	if ($file eq '.'  ||  $file eq '..') {
	    next;
	}
	$file = "$dir/$file";
	if (-d $file) {
	    push(@files, $self->checkDirFiles($file));
	} elsif (-f _) {
	    push(@files, $file);
	}
    }
    closedir($dirHandle);

    @files;
}


#####################################################################
#
#   Name:     checkArchive
#
#   Purpse:   creates a new temporary directory and extracts an
#             archive into it; returns a list of files that have
#             been created by calling checkDirFiles
#
#   Inputs:   $self     - This instance
#             $attr     - The $attr argument of filterList
#             $ipath    - The archive path
#             $deflater - An element from the deflater list that
#                         matches $ipath.
#
#   Returns:  File list; dies in case of trouble
#
#####################################################################

sub checkArchive ($$$$) {
    my($self, $attr, $ipath, $deflater) = @_;
    my $cfg = $Mail::IspMailGate::Config::config;

    # Create a new directory for extracting the files into it.
    my %patterns = ('ipath' => $ipath,
		    'idir'  => File::Basename::dirname($ipath),
		    'ifile' => File::Basename::basename($ipath),
		    'odir'  => $self->createDir($attr));
    $patterns{'ofile'} = $patterns{'ifile'};
    if ($deflater->{'extension'}) {
	$patterns{'ofile'} =~ s/$deflater->{'extension'}$//;
    }
    $patterns{'opath'} = File::Spec->catfile($patterns{'odir'},
					     $patterns{'ofile'});
    my $cmd = $deflater->{'cmd'};
    $cmd =~ s/\$(\w+)/exists($patterns{$1}) ? quotemeta($patterns{$1}) :
                      exists $cfg->{$1} ? $cfg->{$1} : ''/esg;
    $attr->{'main'}->Debug("Running command: $cmd");
    system $cmd;

    $self->checkDirFiles($patterns{'odir'});
}


############################################################################
#
#   Name:    HasVirus
#
#   Purpose: Takes the virus scanners output and parses it for virus
#	     warnings.
#
#            This version is well suited for the AntiVir virus scanner.
#            You typically need to override it for other programs.
#
#   Input:   $self - Instance
#            $output - Message emitted by the virus scanner
#
#   Returns: TRUE if $output indicates a virus, FALSE otherwise
#
############################################################################

sub HasVirus {
    my $self = shift; my $str = shift;
    my $result = join('\n', grep { $_ =~ /\!Virus\!/ } split(/\n/, $str));
    $result ? "Alert: A Virus has been detected:\n\n$result\n" : '';
}


#####################################################################
#
#   Name:     checkFile
#
#   Purpse:   checks a file (recursively if archive) for virus
#
#   Inputs:   $self   - Instance
#             $attr   - Same as the $attr argument of filterFile
#             $ipath  - the file to check
#
#   Returns:  error message, if any
#
#####################################################################

sub checkFile ($$$) {
    my ($self, $attr, $ipath) = @_;
    my(@simpleFiles, @checkFiles);
    my($ret) = '';
    my $cfg = $Mail::IspMailGate::Config::config;

    @checkFiles = ($ipath);
    my($file);
    while (defined($file = shift @checkFiles)) {
	# Modify the name for use in a shell command
	if ($file =~ /[\000-\037]/) {
	    $ret .= "Suspect file names: $file";
	    next;
	}

	# Check whether file is an archive
	my($deflater);
	foreach $deflater (@{$cfg->{'virscan'}->{'deflater'}}) {
	    if ($file =~ /$deflater->{'pattern'}/) {
		push(@checkFiles,
		     $self->checkArchive($attr, $file, $deflater));
		undef $file;
		last;
	    }
	}

	# If it isn't, scan it
	if (defined($file)) {
	    push(@simpleFiles, $file);
	}
    }

    if (@simpleFiles) {
	my $cmd = $cfg->{'virscan'}->{'scanner'};
	$cmd =~ s/\$antivir_path/$cfg->{'antivir_path'}/g;
	my $output;
	if ($cmd =~ /\$ipaths/) {
	    # We may scan all files with a single command
	    my($ipaths) = '';
	    foreach $file (@simpleFiles) {
		$ipaths .= ' ' . quotemeta($file);
	    }
	    $cmd =~ s/\$ipaths/$ipaths/sg;
	    $cmd =~ s/\$(\w+)/exists $cfg->{$1} ? $cfg->{$1} : ''/seg;
	    $attr->{'main'}->Debug("Running command: $cmd");
	    $output = `$cmd`;
	    $ret .= $self->HasVirus($output);
        } else {
	    # We need to scan any file separately
	    foreach $file (@simpleFiles) {
		$ipath = quotemeta($file);
		$cmd =~ s/\$ipath/$ipath/sg;
		$cmd =~ s/\$(\w+)/exists $cfg->{$1} ? $cfg->{$1} : ''/seg;
		$attr->{'main'}->Debug("Running command: $cmd");
		$output = `$cmd`;
	        $ret .= $self->HasVirus($output);
	    }
        }
    }
    $ret;
}


#####################################################################
#
#   Name:     filterFile
#
#   Purpse:   do the filter process for one file
#
#   Inputs:   $self   - This class
#             $attr   - hash-ref to filter attribute
#                       1. 'body'
#                       2. 'parser'
#                       3. 'head'
#                       4. 'globHead'
#
#   Returns:  error message, if any
#
#####################################################################

sub filterFile ($$) {
    my ($self, $attr) = @_;
    my $cfg = $Mail::IspMailGate::Config::config;

    my ($body) = $attr->{'body'};
    my ($globHead) = $attr->{'globHead'};
    my ($ifile) = $body->path();
    $attr->{'main'}->Debug("Scanning file $ifile for viruses");
    my ($ret) = 0;
    if($ret = $self->SUPER::filterFile($attr)) {
	$attr->{'main'}->Debug("Returning immediately, result $ret");
	return $ret;
    }

    $ret = $self->checkFile($attr, $ifile);
    $attr->{'main'}->Debug("Returning, result $ret");
    $ret;
}


1;

__END__