Net-IMP

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

lib/Net/IMP/Example/IRCShout.pm
Makefile.PL
MANIFEST			This list of files
COPYRIGHT
README
Changes
bin/README
bin/imp-pcap-filter.pl
bin/imp-relay.pl
t/01_load.t
t/02_imp-cascade-pattern.t
t/03_imp-cascade-pass-future.t
t/04_imp-cascade-bide.t
t/05_imp-protopin.t
t/06_cfg2str.t
t/07_pcap_relay.t
t/08_imp_data.t
t/09_pattern_stream_vs_packet.t
META.yml                                 Module YAML meta-data (added by MakeMaker)
META.json                                Module JSON meta-data (added by MakeMaker)

lib/Net/IMP/Cascade.pm  view on Meta::CPAN

    my @new_parts;
    for(my $i=0;$i<@$parts;$i++) {
	my $np = $parts->[$i]->set_interface(@if)
	    or return; # cannot use interface
	$np == $parts->[$i] and next; # no change of part
	$new_parts[$i] = $np; # got new factory for part
    }

    return $factory if ! @new_parts; # interface supported by original factory

    # some parts changed, create new factory for this cascade
    for(my $i=0;$i<@$parts;$i++) {
	$new_parts[$i] ||= $parts->[$i]; # copy parts which did not change
    }

    return ref($factory)->new_factory( parts => \@new_parts );
}

sub new_analyzer {
    my ($factory,%args) = @_;

lib/Net/IMP/Cascade.pm  view on Meta::CPAN

    weaken( my $wself = $self );

    my $new_buf = sub {
	lock_ref_keys( my $buf = {
	    start   => 0,  # start of buf relativ to part
	    end     => 0,  # end of buf relativ to part
	    data    => '', # data or undef for replace_later
	    dtype   => 0,  # data type
	    rtype   => IMP_PASS,  # IMP_PASS < IMP_PREPASS < IMP_REPLACE
	    gap     => 0,  # size of gap before buf?
	    gstart  => 0,  # start of buf relativ to cascade
	    gend    => 0,  # end of buf relativ to cascade
	    eof     => 0   # flag if last buf in this direction
	});
	%$buf = ( %$buf, @_ ) if @_;
	return $buf;
    };

    my $new_part = sub {
	lock_ref_keys( my $p = {
	    ibuf => [ &$new_buf ], # buffers, at least one
	    pass          => 0,    # can pass up to ..

lib/Net/IMP/Cascade.pm  view on Meta::CPAN

		if ( $np ) {
		    # feed into next part
		    my $nib = $np->{ibuf};
		    # adjust start,end based on end of npi and gap
		    $buf->{start} = $nib->[-1]{end} + $buf->{gap} + $adjust;
		    $buf->{end} = $buf->{start} + length($buf->{data});
		    $DEBUG && debug(
			"fwd_next[$dir][$pi>$npi] ".$dump_bufs->([$buf]));
		    $part_in->($npi,$dir,$buf);
		} else {
		    # output from cascade
		    my $cb = $fwd_up->($dir,$buf) or next;
		    $DEBUG && debug(
			"fwd_up[$dir][$pi>>] ".$dump_bufs->([$buf]));
		    $wself->run_callback($cb);
		}

	    # special - part is done with IMP_PASS IMP_MAXOFFSET
	    } else {
		# skip if we had a pass infinite already
		next if ! ref $parts[$dir][$pi];

lib/Net/IMP/Cascade.pm  view on Meta::CPAN

    $closef->() if $closef;
}


1;

__END__

=head1 NAME

Net::IMP::Cascade - manages cascade of IMP filters

=head1 SYNOPSIS

    use Net::IMP::Cascade;
    use Net::IMP::Pattern;
    use Net::IMP::SessionLog;
    ...
    my $imp = Net::IMP::Cascade->new_factory( parts => [
	Net::IMP::Pattern->new_factory..,
	Net::IMP::SessionLog->new_factory..,
    ]);

=head1 DESCRIPTION

C<Net::IMP::Cascade> puts multiple IMP analyzers into a cascade.
Data get analyzed starting with part#0, then part#1... etc for direction 0
(client to server), while for direction 1 (server to client) the data get
analyzed the opposite way, ending in part#0.

The only argument special to C<new_factory> is C<parts>, which is an array
reference of L<Net::IMP> factory objects.
When C<new_analyzer> gets called on the L<Net::IMP::Cascade>> factory,
C<new_analyzer> will be called on the factory objects of the parts too, keeping
all arguments, except C<parts>.

t/02_imp-cascade-pattern.t  view on Meta::CPAN

    my $in = $test{in};

    diag("===================== [Test#$i] ========================")
	if $DEBUG;

    eval {
	$filter->in(0,$_) for (ref($in) ? @$in:$in);
	$filter->in(0,'');
    };
    if ($@) {
	fail("cascade pattern test[$i] got exception");
	diag(Dumper({ err => $@, real_out => $out, %test }));
    } elsif ( $test{out} ne $out ) {
	fail("cascade pattern test[$i] output not expected");
	diag(Dumper({ real_out => $out, %test }));
    } else {
	pass("cascade pattern test[$i]");
    }
}



package myFilter;
use base 'Net::IMP::Filter';
sub out {
    my ($self,$dir,$data) = @_;
    $out .= $data;

t/03_imp-cascade-pass-future.t  view on Meta::CPAN

$analyzer->data(0,'FGH');
$analyzer->data(0,'');

my @expect = (
    [ 'replace', 0, 10, '' ],
    [ 'replace', 0, 15, '' ],
    [ 'pass', 0, IMP_MAXOFFSET ],
);

if ( Dumper(\@expect) ne Dumper(\@rv)) {
    fail("cascade: pass future");
    diag("expected ".Dumper(\@expect).
	"\ngot ".Dumper(\@rv));
} else {
    pass("cascade: pass future");
}


package RemoveHead;
use base 'Net::IMP::Base';
use fields qw(size pos);
use Net::IMP;

sub new_analyzer {
    my ($factory,%args) = @_;

t/04_imp-cascade-bide.t  view on Meta::CPAN

    [ 'replace', 1, 13, '' ],
    [ 'replace', 1, 13, 'ef' ],
    [ 'pass',    1, -1 ],
    [ 'prepass', 0, 9 ],
    [ 'replace', 0, 10, 'cdef' ],
    [ 'replace', 0, 13, '' ],
    [ 'pass',    0, -1 ],
);

if ( Dumper(\@expect) ne Dumper(\@rv)) {
    fail("cascade-bidi");
    diag("expected ".Dumper(\@expect)."\ngot ".Dumper(\@rv));
} else {
    pass("cascade-bidi");
}


package PrePass;
use base 'Net::IMP::Base';
use fields qw(window pos);
use Net::IMP;

sub new_analyzer {
    my ($factory,%args) = @_;