Of course you can seldom "translate" a subroutine directly into a module as --almost by definition-- a module should be useful in more than one place and therefore you might have to include some extra parameters to customize the routine and make it more general.

On a totally different tack: why do you want to put a space character in the variables if there is nothing passed to the subroutine? Doesn't it make the $sth->finish() if $sth; $dbh->disconnect() if $dbh; superfluous as now you will always succeed in these tests (space is considered TRUE!)?

Another question (just being curious): why do you exit the subroutine always with a zero value (exit 0). The reason cannot be that you want to check the return value of the subroutine as it is always zero? Hence the question, why zero?

create a file with the .pm extenstion for example Error.pm
This goes inside:

package Error;

use Exporter;
@ISA = ('Exporter');
@EXPORT = ('handle_error');

sub handle_error{
    my $msg = shift ||' ';
    my $dbh = shift ||' ';
    my $sth = shift ||' ';

    #html::template - handle_error.tmpl
    my $tem = HTML::Template->new(filename => "handle_error.tmpl");
    $tem -> param(message => $msg);

    print $tem->output;

    #finish the state handle and disconnect, if necessary
    $sth->finish()     if $sth;
    $dbh->disconnect() if $dbh;
    exit 0;
}

1;
[download]

use lib ("/home/z/xxx/www/modules/");
use Error;
[download]

As a plus, whenever you feel like changing your code, you'll only have to do it *once*, in the module.

How to do it... well, there's a lot to be said on the subject (I wrote a full article on this, but it hasn't been published yet). Use Module::Starter to start a module easily, check out the files it creates and post your questions here as they arise.

It makes absolute sense to use it in a module. I'd also suggest changing the name, of the subroutine slightly, though. Perhaps call it handle_db_error. then you can have other routines such as handle_io_error, or somesuch.

Now read chapter 11 of the Bible. There are too many options to really specify how to do this in a single post. Are you going OO, for example? Do you want to have the routine available in all scripts, or should it be imported explicitly?

The following is wrong since ' ' is true:

    my $dbh = shift ||' ';
    my $sth = shift ||' ';

    ...

    $sth->finish()     if $sth;
    $dbh->disconnect() if $dbh;
[download]

The above is equivalent to:

    my $dbh = shift;
    my $sth = shift;

    ...

    if ($sth) {
       $sth->finish();
    } else {
       ' '->finish();  # RUNTIME ERROR
    }

    if ($sth) {
       $dbh->disconnect();
    } else {
       ' '->diconnect();  # RUNTIME ERROR
    }
[download]

Why not just do this:

    my $dbh = shift;
    my $sth = shift;

    ...

    $sth->finish()     if $sth;
    $dbh->disconnect() if $dbh;
[download]

When you convert it to a shared sub, you may want to consider using named parameters when you pass in variables. This makes it much easier to change things in the future without breaking a bunch of code that is relying on the position of passed in variables.

There is a good section on named parameters in Effective Perl Programming. Basically, you pass a hash into the sub rather than an array and pull the parameters off as a hash.

I would suggest that you don't want to tell the user too much about your error.

The ordinary user only cares whether you can answer his query or not, but the malicious user might use debugging info to find ways to break into your system.

What you DO need is to make sure messages get into the apache log.