BEGIN {
    our %ENGINES;
}
use strict;
each %ENGINES;
__END__
Global symbol "%ENGINES" requires explicit package name at - line 5.
Execution of - aborted due to compilation errors.
[download]

You are calling list_engines(), which uses each on %ENGINES from set_engine while iterating over %ENGINES with each. Very bad idea, because the hash iterator is bound to each hash, not to the scope each occurs in.

my %hash;

@hash{a..f} = 10..15;

sub a {
    my $a_count;
    while( my ($k,$v) = each %hash) {
        print "$k => $v\n";
        $a_count++;
    }
    $a_count++;
}
sub b {
    my $b_count;
    while( my ($k,$v) = each %hash) {
        $b_count++;
        print "$k => $v ($b_count out of ", a(), ")\n";
    }
}
b()
__END__
c => 12
a => 10
b => 11
d => 13
f => 15
e => 14 (1 out of 5)
c => 12
a => 10
b => 11
d => 13
f => 15
e => 14 (2 out of 5)
c => 12
a => 10
b => 11
d => 13
f => 15
e => 14 (3 out of 5)
...
[download]

This code runs until it hits an integer overflow on $b_count in sub b { }, because the each in sub a { } goes on iterating the same hash from where the pointer was set in sub b(), and thus $a_count is set to 5, not to 6. The hash iteration is through at the end of that while loop, so the iterator is reset. Then the print in sub b() happens, and the iteration starts over after the iterator has been reset.

You get a similar effect resetting the hash iterator with keys or values

my %hash;

@hash{a..f} = 10..15;
my $count;
while(my ($k,$v) = each %hash) {
    $count++;
    print "$k => $v ($count of ", scalar(keys %hash),")\n";
}
__END__
e => 14 (1 of 6)
e => 14 (2 of 6)
e => 14 (3 of 6)
e => 14 (4 of 6)
e => 14 (5 of 6)
e => 14 (6 of 6)
e => 14 (7 of 6)
...
(runs forever)
[download]

so don't do that.

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

I can't trace your problem in detail right now, but I'd try saying

use vars '%ENGINES';
[download]

I remain uncertain about what our accomplishes, but I'm pretty sure that putting it in a BEGIN block restricts its scope.

Global variables ain't fashionable, but they have their uses in perl for class data and such.

Your use of strict and our is broken, however. Because they are both in a BEGIN block the scope of both is confined to just that block, making them essentially useless.

It's best to have use strict (and probably a use warnings) at the top of your code, outside of any block. The declaration for %ENGINES could be at the top, if you like, but I prefer to have the 'our' declaration near where I actually use the variable. If you intend to initialize %ENGINES at module startup then putting the declaration in a block can be a good idea.

package Data::CryptRecord;

use warnings;
use strict;

{
    our %ENGINES = (...);
}


sub set_engine {
    my($self, $name) = @_;
    our %ENGINES;
    ...
}
[download]

This provides some self-documentation; it's clear that %ENGINES is global. You can also initialize %ENGINES outside a block, and not have to declare it in your subroutines.

It might just be a personal problem, but most times I use each it ends up biting me. I've just settled into using a for loop, and it never caused me any problems related to resetting.

So instead of

while( my ($k, $v) = each(%ENGINES)){
    push @eng, $v->{'name'};
}
[download]

... I would probably end up doing this:

for my $k (keys %ENGINES) {
    my $v = $ENGINES{$k};
    push @eng, $v->{'name'};
}
[download]

This is a personal preference, and I'll admit that it does result in a little more code. I'm okay with that. I'd probably use map if I was concerned about brevity. The important thing is that I don't have to worry about resetting anything.