That error means something (such as an error message) was printed before the header was printed. In this case, an error is printed before compilation of the script is done, and the header is only outputed after the script is done compiling.

The content of eval BLOCK is compiled when the rest of the script is compiled, so the use in the eval BLOCK (and anything in the used file) will be executed before you send the header.

You could send the header sooner (using BEGIN), or you could use eval EXPR instead of eval BLOCK.

The following executes everything in the same order as if the error checking wasn't there (i.e. modules are loaded before CHECK is called), but dies gracefully if a module can't be loaded.

#!/usr/bin/perl

BEGIN {
   eval ("
      use LWP::UserAgent;
      use HTTP::Request::Common;
   ");

   if ($@) {
      print "500 Internal Server Error\n";
      print "Content-type: text/plain\n";
      print "\n";
      print $@

      die($@);  # For the log file.
   }
}

print "Content-type: text/html\n\n";

my $ua = LWP::UserAgent->new;
my %post = (...);
my $response = $ua->request(POST "http://www.example.com/", [ %post ])
+;
print $response->as_string;
[download]

By the way, it's $@, not @$.

Thanks very much... I appreciate your help. So the following would be a fine way to test if a module is available and either use it or not use it accordingly?

print "Content-type: text/html\n\n";
print "here we go again...";

&a;

sub a {
        BEGIN {
                eval ("use fakemodule;");
                if ($@) {
                        print "error happened $@";
                } else {
                        print "error didnt happen, do some stuff";
                }
        }
}
[download]

My solution already does exactly that. Just replace the body of if ($@) with whatever you want.

What you have there is the same as

eval ("use fakemodule;");
if ($@) {
   print "error happened $@";
} else {
   print "error didnt happen, do some stuff";
}

print "Content-type: text/html\n\n";
print "here we go again...";

&a;

sub a {}
[download]

# Option 1 - string eval, test $@
eval "use HTTP::Request::Common";
if ($@) {
    # Missing
}


# Option 2 - string eval with return value of 1

if (eval "use HTTP::Request::Common; 1;") {
    # Loaded, good
}
else {
    # Missing
}


# Option 3 - require and import

eval {
  require HTTP::Request::Common;
  HTTP::Request::Common->import;
};
if ($@) {
    # Not found
}
[download]

I just tried #2, or my interpretation of #2 and it didn't work... here is the code I used:

#!/usr/bin/perl

print "Content-type: text/html\n\n";
print "here we go again...";

        if (eval "require LWP::UserAgent; use HTTP::Request::Common; 1
+;") {
                my $ua = LWP::UserAgent->new;
                my %post;
                my $content = $ua->request(POST "http://www.cnn.com", 
+[%post])->as_string;
                print $content;
        } else {
                print "didnt work";
        }
[download]

And here is the error I got:

./networktest.pl
String found where operator expected at ./networktest.pl line 10, near
+ "POST "http://www.cnn.com""
        (Do you need to predeclare POST?)
syntax error at ./networktest.pl line 10, near "POST "http://www.cnn.c
+om""
Execution of ./networktest.pl aborted due to compilation errors.
[download]

You must use parens around the arguments of a function call when the call is compiled before the function being called has been loaded.

My solution doesn't suffer from that problem. It loads the function (i.e. the module) before the call to the function is compiled.

So either add parens around the arguments for POST (and suffer from the loss of prototypes on all imported functions), or use what I already posted.

thanks... what about this...

print "Content-type: text/html\n\n";
print "here we go again...";

&a;

sub a {
        BEGIN {
                eval ("use fakemodule;");
                if ($@) {
                        print "error happened $@";
                } else {
                        print "error didnt happen, do some stuff";
                }
        }
}
[download]

Considered by ikegami: Dup of Re^2: Why am I getting "premature end of script header"?
Unconsidered by Arunbear: reaping blocked by keep (and edit) votes; (Keep: 5, Edit: 3, Reap: 18)

This would be sufficient:

BEGIN {
    if( eval "use fakemodule; 1;") {
        print STDERR "Loaded fakemodule";
    }
    else {
        print STDERR "Couldn't load fakemodule.";
    }
}
[download]

Don't put BEGIN blocks inside a subroutine, they won't do what you want.

Don't print in the BEGIN block, it will come before the Content-type header

Calling a subroutine with the '&a' syntax has the following effects, from perlsub:

• &NAME(LIST); # Circumvent prototypes.
  
• &NAME; # Makes current @_ visible to called subroutine.
In your code you used the &a; form, which would make the current @_ visible to the called subroutine. For example:

first(1,2,3);

sub first {
  &second;
}

sub second {
    print for @_;
}

# Output is 123
[download]

Although it isn't relevant for this particular case it is still good to be aware of the prototype circumvention behaviour. Here is an example:

use strict;
use warnings;
use Data::Dumper;

sub pro(\@) {
    print Dumper \@_;
}

my @list = (1,2,3);
pro(@list);
&pro(@list);
[download]

Output:

$VAR1 = [
          [
            1,
            2,
            3
          ]
        ];
$VAR1 = [
          1,
          2,
          3
        ];
[download]

Showing the world your error messages is not the best idea, especially when the OP can see the messages just fine in his error log.

The problem is that the OP wants to load a module if it's present, and take some alternate action if it's not.

#!/usr/bin/perl  
print "Content-type: text/html\n\n";
print "here we go again...";

eval {
        require LWP::UserAgent;
        require HTTP::Request::Common;
        import  HTTP::Request::Common;
        my $ua = LWP::UserAgent->new;
        my %post;
        my $content = $ua->request(POST "http://www.cnn.com", [%post])
+->as_string;
        print $content;
};

if (@$) {
print "ERROR: @$";
}

print "more stuff would happen here";
[download]

That doesn't work. See Re^3: Why am I getting "premature end of script header"? - eval { use } for an explanation. What one could do is replace the aformentioned

BEGIN {
   eval("
      use LWP::UserAgent ();
      use HTTP::Request::Common;
   ");

   if ($@) {
      ...
   }
}

...
[download]

with

BEGIN {
   eval {
      require LWP::UserAgent;
      require HTTP::Request::Common;
      import HTTP::Request::Common;
   };

   if ($@) {
      ...
   }
}

...
[download]

The difference between the two is just a question of style.