File Coverage

blib/lib/Mail/IspMailGate/Filter.pm

Criterion	Covered	Total	%
statement	68	90	75.5
branch	20	38	52.6
condition	4	9	44.4
subroutine	8	13	61.5
pod	8	9	88.8
total	108	159	67.9

# -*- perl -*-
#

require 5.004;
use strict;


package Mail::IspMailGate::Filter;

$Mail::IspMailGate::Filter::VERSION = "1.000";

sub getSign { "X-ispMailGateFilter"; };

#####################################################################
#
#   Name:     new
#
#   Purpse:   Filter constructor
#
#   Inputs:   $class - This class
#             $attr  - hash ref to the attributes
#                      1) 'direction' : 'pos' for the positive direction
#                                       'neg' for the negative direction
#
#   Returns:  Object or error message
#
#####################################################################

sub new ($$$) {
    my ($class, $attr) = @_;
    my ($self) = {};
    if (ref($attr) ne 'HASH') {
	return "Attribute reference is not a hash ref, but: " . ref($attr);
    }
    my ($key);
    foreach $key (keys %$attr) {
	$self->{$key} = $attr->{$key};
    }

    bless($self, (ref($class) || $class));
    $self;
}

#####################################################################
#
#   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' the header of the whole Mail
#
#   Returns:  error message, if any
#
#####################################################################

sub filterFile ($$$) {
    my ($self, $attr) = @_;
    if (ref($attr) ne 'HASH') {
	die "No hash ref of attributes but: " . ref($attr);
    }
    my ($body) = $attr->{'body'};
    my ($ifile) = $body->path();
    if (!(-f $ifile)) {
	return "The file $ifile does not exist";
    }
    '';
}

#####################################################################
#
#   Name:     setEncoding
#
#   Purpse:   set a reasonable encoding type, for the filtered mail
#
#   Inputs:   $self   - This class
#             $entity - The entity
#
#   Returns:  error-message if any
#
#####################################################################

sub setEncoding ($$$) {
    my ($self, $entity) = @_;
    my ($head) = $entity->head();

    '';
}

#####################################################################
#
#   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 ($$) {
    my($self, $entity) = @_;
    return 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) = @_;
    '';
}


#####################################################################
#
#   Name:     doFilter
#
#   Purpose:   does the filtering process
#
#   Inputs:   $self   - This class
#             $attr   - a hash ref to the attributes
#                       Following things are needed !!!!
#                       1) 'entity': a ref to the Entity object
#                       2) 'parser': a ref to a Parser object
#
#   Returns:  error message, if any
#
#####################################################################

sub doFilter ($$) {
    my($self, $attr) = @_;
    my ($entity) = $attr->{'entity'};
    if(!$self->mustFilter($entity)) {
	'';
    } else {
	$self->recdoFilter($attr) . $self->hookFilter($entity);
    }
}


#####################################################################
#
#   Name:     recdoFilter
#
#   Purpse:   does the filtering process recursively by manipulating the
#             given entity
#
#   Inputs:   $self   - This class
#             $attr   - a hash ref to the attributes
#                       Following things are needed !!!!
#                       1) 'entity': a ref to the Entity object
#                       2) 'parser': a ref to a Parser object
#
#   Returns:  error message, if any
#
#####################################################################

sub recdoFilter ($$) {
    my ($self, $attr) = @_;
    if (ref($attr) ne 'HASH') {
	die "Attributes are not a hash ref, but: " . ref($attr);
    }
    my ($entity) = $attr->{'entity'};
    my ($parser) = $attr->{'parser'};

    my($globHead) = exists($attr->{'globHead'}) ? $attr->{'globHead'} : $entity->head();

    my ($mult) = $entity->is_multipart();
    if (!defined($mult)) {
	die "Could not determine if the Entity is multipart or not";
    } elsif ($mult) {
	my (@parts) = $entity->parts;
	my ($part);
	my ($retstr) = '';
	foreach $part (@parts) {
	    my($result) = $self->recdoFilter({ 'entity' => $part,
			      'parser' => $parser,
			      'globHead' => $globHead,
			      'main' => $attr->{'main'}});
	    if (defined($result)) {
		$retstr .= $result;
	    }
	}
	$entity->parts(\@parts);
	return ($retstr);
    }

    my ($head) = $entity->head();
    my ($sign) = $head->get($self->getSign());
    if (!defined($sign)) {
	$sign = '';
    }

    my ($bodyh) = $entity->bodyhandle;
    my ($ifile);
    if (!defined($ifile = $bodyh->path())) {
	die "message body is not stored in a file";
    }
    my ($fattr) = { 'head' => $head,
		    'body' => $bodyh,
		    'globHead' => $globHead,
		    'parser' => $parser,
		    'main' => $attr->{'main'}};
    my ($err) = $self->filterFile($fattr, $parser);
    if ($err) {
	return "Error filtering $ifile: $err";
    }
#    $self->setEncoding($entity);
#    $head->replace($self->getSign(), $self->{'direction'});

    '';
}


sub IsEq ($$) {
    my($self, $cmp) = @_;
    ref($self) eq ref($cmp);
}


package Mail::IspMailGate::Filter::InOut;

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


#####################################################################
#
#   Name:     mustFilter
#
#   Purpose:  Based on the filter configuration and the message
#             header, determine whether we are running in input
#             ('positive') or output ('negative') mode.
#
#   Inputs:   $self   - This class
#             $entity - the whole message
#
#   Returns:  TRUE is filtering must occurr, FALSE otherwise.
#             In the former case the attribute
#             $self->{'recDirection'} is set to either 'pos' or
#             'neg'.
#
#####################################################################

sub mustFilter ($$) {
    my($self, $entity) = @_;
    my($head) = $entity->head();
    my($sign) = $head->get($self->getSign());
    my($direction);
    if (!defined($sign)) {
	$sign = '';
    }
    if (defined($direction = $self->{'direction'})) {
	if (($self->{'direction'} eq $sign)  ||
	    ($self->{'direction'} eq 'neg'  &&  $sign eq '')) {
	    return 0;
	}
    } else {
	$direction = ($sign eq 'pos') ? 'neg' : 'pos';
    }
    $self->{'recDirection'} = $direction;
    1;
}


#####################################################################
#
#   Name:     hookFilter
#
#   Purpse:   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(), $self->{'recDirection'});
    delete $self->{'recDirection'};
    '';
}


sub IsEq ($$) {
    my($self, $cmp) = @_;
    if (ref($self) eq ref($cmp)) {
	if ($self->{'direction'}) {
	    if ($cmp->{'direction'}) {
		return $self->{'direction'} eq $cmp->{'direction'};
	    }
	} else {
	    return !$cmp->{'direction'};
	}
    }
    return 0;
}

1;


__END__