#!/usr/local/bin/perl -w
use strict;
use Config::Simple;

my $config_file = shift;
        if (!$config_file) {
                $config_file = "etc/allweb-backup.conf";
        }

my $cfg = new Config::Simple($config_file);
my (%Config);
unless (%Config = $cfg->vars()) {
        die "CRITICAL: $config_file is not a valid INI file!\n";
}
[download]

Something went wrong. No supported configuration file syntax found at 
+/usr/local/lib/perl5/site_perl/5.8.2/Config/Simple.pm line 184, <FH> 
+line 16.
[download]

thats most likely because you cannot call $cfg->vars() if your Config::Simple object could not be created (although, the error message doesn't match to your example code).

You should check for and handle the error on the line you create the Config::Simple object (no later):

my $cfg = new Config::Simple($config_file) or die "aaarg $!";
[download]

I gave both of those a try, but didn't seem to have any luck

my $cfg = new Config::Simple($config_file) || die "ARGG!";
my %Config;
eval { %Config = $cfg->vars() };
if ($0) {
        die "CRITICAL: $config_file is not a valid INI file!\n";
}
[download]

... any other ideas? Thanks a bunch BTW :-)

You need eval:

eval { %Config = $cfg->vars() };
if($@) { die "CRITICAL: $config_file is not a valid INI file!\n" }
[download]

Unrelated to your scoping issue (once again it's been answered well by others before this) but there's a Perl idiom for this tidbit of code:

my $config_file = shift;
        if (!$config_file) {
                $config_file = "etc/allweb-backup.conf";
        }
[download]

which is a simple: my $config_file = shift || "etc/allweb-backup.conf"; Same results, cleaner code (IMHO).

I thought that I would no longer be able to call $cfg once inside the 'unless'

You seem to have figured this out, but I'd just like to reinforce the point. Scalar variables are accessible from inner scopes, but not from outer scopes. So if you scope a variable in the top-level of a subroutine, then any nested blocks (if statements, while loops, etc) will have access to the variable. But anything outside of the subroutine will not. Here's the obligatory code example:

    sub foo {
        my $foo = 1;
        if (1 == 1) { # just to demonstrate the point
            $foo++;   # inside foo, works fine
        }
        print $foo;
        bar();
    }

    sub bar {
        print $foo; # outside foo, blows up
    }

    foo();
[download]

Also keep in mind that the inner/outer determination is done "physically". That is, it's not based on the call stack. It's based on the location in the actual code. This is different from dynamic scoping (i.e. local in Perl), which is based on the execution path. For this reason, lexical scoping is much more predictable and understandable. Here's an example:

    sub foo {
        local $foo = 1;
        if (1 == 1) { # just to demonstrate the point
            $foo++;
        }
        print "From foo: $foo\n";
        bar();
    }

    sub bar {
        # this variable will be set to whatever it was 
        # before we got called
        print "From bar: $foo\n"; 
    }

    $foo = 5;
    foo();
    bar();
[download]