That offers no protection in a standard CGI environment. If you had multiple threads within this program it would be useful. In this case, there are multiple processes which could be accessing your file simultaneously. You'll need a filesystem-level mechanism to manage file locking. There are plenty of nodes that describe how to use flock appropriately.

I found an article on this at The Perl Journal. Here's my second version:

#!/usr/bin/perl
use strict;
use warnings;
use Sem;
use Storable qw/lock_store lock_retrieve/;
use CGI;

my $q = new CGI;
my $sem = Sem->new('semaphore.txt');
my $x = lock_retrieve('k.dat') or die "Can't open k.dat: $!";
$x->{counter}++;
lock_store($x, 'k.dat') or die "Can't save k.dat: $!";
$sem->unlock;
print $q->header;
[download]

And here's the Sem.pm code:

package Sem;

sub new {
    my $class = shift(@_);
    use Carp ();
    my $filespec = shift(@_) || Carp::croak("What filespec?");
    open my $fh, ">", $filespec or Carp::croak("Can't open semaphore f
+ile $filespec: $!");
    chmod 0666, $filespec; # assuming you want it a+rw
    use Fcntl 'LOCK_EX';
    flock $fh, LOCK_EX;
    return bless {'fh' => $fh}, ref($class) || $class;
}

sub unlock {
    close(delete $_[0]{'fh'} or return 0);
    return 1;
}

1;
[download]

Is there anyway to test this? Should I use the apache benchmark tool to send a bunch of concurrent requests to the cgi?

You could write your own test using fork, LWP::UserAgent and HTTP::Request::Common.
LWP::Parallel::UserAgent might be handy also.

-Lee

"To be civilized is to deny one's nature."

Hi, Thanks for your response. What happens when a user runs the cgi and the file is flocked? Does Apache queue them or does the script die?

It's up to you. You can have the program wait to retrieve a lock, or you can cause it to die.