Up to [Platon] / web-apps / fastcgi-gallery

Removed module CGI::Lite, because it is buggy. Replaced with CGI module.

#!/usr/bin/perl -w

#
# index.fcgi - main script of fastcgi-gallery
#
# Developed by Lubomir Host 'rajo' <rajo AT platon.sk>
# Copyright (c) 2004-2006 Platon Group, http://platon.sk/
# Licensed under terms of GNU General Public License.
# All rights reserved.
#
# Homepage:          http://fastcgi-gallery.platon.sk/
# CVS web interface: http://platon.sk/cvs/cvs.php/web-apps/fastcgi-gallery/
# Development page:  http://platon.sk/projects/main_page.php?project_id=13
#
# Changelog:
# 2004-04-17 - created
#

# $Id: index.fcgi,v 1.9 2006/03/24 17:34:16 rajo Exp $

use strict;
use FindBin;
use lib "$FindBin::Bin/_modules";
use vars qw ( $VERSION $DEBUG ) ;

$VERSION    = sprintf("%d", q$Revision: 1.9 $ =~ /(\d+)/);
$DEBUG        = 0 unless defined $DEBUG;

umask 022;

use FCGI;
use CGI qw(-compile param cookie url_encode);
use Template;
use Time::HiRes qw(gettimeofday tv_interval); 
use POSIX qw(strftime);
use English;
use Env;
use Data::Dumper;
use CGI::Carp qw(fatalsToBrowser);

use Platon::FastCGI::Restart;
use Platon::File::Spec::Unix;
use config;
use templates;
use gallery;

use vars qw (
    $req $config $restart $template $db @languages
    $gallery $gallery_config $gallery_data $gallery_cache_time $gallery_cache
    @messages
    $lang_hash
    $in_reply
    $admin_mode
    @http_cookie

    $start_time

);

#
# Functions declaration
#
sub MyPage($$;);
sub send_content($;);
sub cur_date();

$req = FCGI::Request();
$config  = config->new();
$restart = Platon::FastCGI::Restart->new({
        restart_func            => sub { $req->LastCall(); exit 0; },
        use_lock                => 'true',
        lock_dir                => '/var/tmp',
        max_restart_interval    => 10,
        CHECK_USER_MODULES        => 'true',
        CHECK_SYSTEM_MODULES    => 'false',
    });
@languages    = (
    { 'abbrev' => 'en',    'language' => 'English' },
    { 'abbrev' => 'sk',    'language' => 'Slovak' },
);
$gallery_config = { # {{{
        GalleryRootText        => '[lang:en]Gallery[/lang:en][lang:sk]Galéria[/lang:sk]',
        GalleryRootURI        => '',
        GalleryIconsURI        => 'images/icons/gallery',
        GalleryRootPath        => "$FindBin::Bin/gallery/",
        GalleryDocLocation    => '/gallery',
        GalleryCacheDir        => "$FindBin::Bin/cache/",
+         GalleryDirectCacheAccess    => '/cache',
        GallerySizes        => [ qw(320 640 800) ],
        GallerySlideshowIntervals    => [ qw(2 3 5 10 30) ],
        GalleryThumbnailSize    => '140x105',
        #GalleryMaxThumbnailsPerPage    => 2,
        #GalleryDocFile            => '',
        #GalleryImgFile            => '',
        #GalleryQuality            => 95,
        GalleryAllowOriginal    => 1,
        GalleryThumbnailSizeLS    => 1,
        GalleryMemoize    => 0,
        GalleryInfo        =>
            'Camera                 => Make,
            Model                    => Model,
            Date                    => DateTimeOriginal,
            Shutter speed            => ExposureTime,
            Aperture                => FNumber,
            ISO sensitivity            => ISOSpeedRatings,
            Focal length            => FocalLength,
            Flash                    => Flash,
            Digital zoom            => Tag-0xa404,
            Exposure mode            => Tag-0xa402,
            Subject distance range    => Tag-0xa40c,
        ',

}; # }}}
$gallery    = gallery->new($gallery_config);

foreach my $lang (@languages) {
    $lang_hash->{$lang->{abbrev}}    = $lang->{language};
    $template->{$lang->{abbrev}}    = templates->new($config, $lang->{abbrev});
}

#$gallery_cache_time = 3600; # seconds
#$gallery_cache_time = 600; # seconds
$gallery_cache_time = 1; # seconds
$gallery_cache = { };

#
# MAIN:
#
$restart->add_loaded_modules();
$restart->add_files(
    '_modules/Platon/Template/Plugin/Interval.pm',
    '_modules/obfuscator.pm');
while ( $config->run() && ($req->Accept() >= 0) ) {

    my %cookie;
    my %query;
    
    @messages = ();
    $in_reply    = 0;
    $admin_mode    = 0;
    $start_time = Time::HiRes::gettimeofday;
    my $cache_time = int($start_time / $gallery_cache_time);

    #
    # Parse query and cookies
    # {{{
    CGI::_reset_globals;
    my $cgi = CGI->new();

    foreach my $key ($cgi->param()) {
        my @val = $cgi->param($key);
        #$query{$key} = scalar(@val) > 1 ? \@val : $val[0];
        $query{$key} = $val[0];
    }

    foreach my $key ($cgi->cookie()) {
        my @val = $cgi->cookie($key);
        $cookie{$key} = $val[0];
    }
    #warn Dumper(\%query, \%cookie);
    # }}}

    if (!defined($query{page}) or $query{page} !~ m/^\d{1,4}$/) {
        $query{page} = 0;
    }

    if ( !defined($query{lang})
            or $query{lang} eq ''
            or !defined($lang_hash->{$query{lang}})
            or $lang_hash->{$query{lang}} eq '') {
        $query{lang} = 'en'
    }

    if (!defined($query{gallery}) or $query{gallery} eq '') {
        $query{gallery} = '/';
    }

    if (exists $query{gallery}) { # {{{

        my $filename = $query{gallery} || '/';
        $filename    = Platon::File::Spec::Unix->canonpath("/$filename");
        $filename    =~ s|^(\.\./)+||g; # ignore leading ../
        $filename    =~ s|^\.$|/|g;    # .  -->  /
        $filename    =~ s|^\./$|/|g;    # ./ -->  /
        $query{gallery} = $filename;
        my $topdir = ($gallery_config->{GalleryRootPath} or '.');
        my $abs_filename = Platon::File::Spec::Unix->canonpath("$topdir/$filename");
        if (-d $abs_filename) {
            $query{gallery} = "$query{gallery}/";
            $query{gallery} =~ s#/*$#/#;
        }

        # ignore cached files handled by gallery
        if ((defined($query{gallery}) and $query{gallery} =~ m/^\.cache\//)
                or (defined($query{GalleryShowOriginal}) and $query{GalleryShowOriginal} eq '1')) {
            $gallery_data        = $gallery->handler(\%query, \%cookie);
        }
        else {
            my $merge;
            while (my ($key, $val) = each %cookie) {
                $merge->{$key} = $val;
            }
            while (my ($key, $val) = each %query) {
                $merge->{$key} = $val;
            }
            foreach my $key (qw'lang page template') {
                delete $merge->{$key};
            }
            my $cache_key = '';
            foreach my $key (sort keys %$merge) {
                $cache_key .= "&$key=" . url_encode($merge->{$key});
            }

            if (exists $gallery_cache->{$cache_time}
                    and exists $gallery_cache->{$cache_time}->{$cache_key}) {
                #print STDERR "POUZIVAM CACHE\n";
                $gallery_data = $gallery_cache->{$cache_time}->{$cache_key};
            }
            else { # cache not found
                $gallery_data        = $gallery->handler(\%query, \%cookie);
                if (defined($gallery_data)
                        and ref($gallery_data) eq 'HASH'
                        and !exists($gallery_data->{error})
                        and $gallery_data->{use_cache} == 1
                ) {
                    $gallery_cache->{$cache_time}->{$cache_key} = $gallery_data;
                }
                elsif (exists($gallery_data->{error})) {
                    warn "NOT using cache, error is: " . Dumper($gallery_data);
                }
            }

        }

        if (defined($gallery_data)
                and ref($gallery_data) eq 'HASH') {

            if (defined $gallery_data->{cookie}) {
                while (my ($key, $value) = each %{$gallery_data->{cookie}}) {
                    push @http_cookie, CGI::cookie('-name' => $key, '-value' => $value);
                }
            }

            if (defined $gallery_data->{content}) {
                send_content($gallery_data->{content});
            }
            else {
                MyPage(\%query, \%cookie);
            }
        }
    } # }}}

         
    $restart->restart($ENV{SCRIPT_FILENAME});
    $req->Finish();

    # cache cleanup
    foreach my $key (keys %$gallery_cache) {
        delete $gallery_cache->{$key} if ($key != $cache_time);
    }
    #warn Dumper([keys %{$gallery_cache->{$cache_time}}]);

    my $curr_time = Time::HiRes::gettimeofday;
    #print STDERR cur_date(), " PAGE GENERATED IN: ", sprintf('%4g', $curr_time - $start_time), "\t$ENV{REMOTE_ADDR}\thttp://$ENV{SERVER_NAME}$ENV{REQUEST_URI}\t$ENV{HTTP_USER_AGENT}\n";

    undef $gallery_data;
    undef @http_cookie;
    undef %cookie;
    undef %query;

}


exit 0;

sub MyPage($$;)
{ # {{{
    my ($ref_query, $ref_cookie, $err_array) = @_;

    #push @http_cookie, CGI::cookie('-name' => 'menu', '-value' => $menu_cookie);

    my    $template_data = {
        query            => $ref_query,
        cookie            => $ref_cookie,
        messages        => \@messages,
        admin_mode        => $admin_mode,
        start_time        => $start_time,
        languages        => \@languages,
        gallery            => $gallery_data,
        http_cookie        => \@http_cookie,
    };

    # slideshow handling
    if (defined $gallery_data->{refresh} and ref($gallery_data->{refresh}) eq 'HASH') {
        $template_data->{refresh} = $gallery_data->{refresh};
    }
            

    $in_reply = 1;
    $template->{$ref_query->{lang}}->process('index.tt2', $template_data) or die $template->{$ref_query->{lang}}->error(), "\n";

} # }}}

sub send_content($;)
{ # {{{
    my ($data) = @_;
    $in_reply = 1;

    print "Pragma: No-cache\n";        
    print "Cache-Control: private\n"; 
    print "Accept-Ranges: bytes\n";
    print "Content-Length: " . length($data->{data}) . "\n";
    print "Content-Location: $data->{location}\n" if (defined $data->{location});
#    print "Content-Location: $filename\n";
    print "Content-type: $data->{mime_type}\r\n\r\n";
    print $data->{data};
} # }}}

sub cur_date()
{ # {{{
    my $time_string = strftime "%Y-%m-%d %X", localtime;

    return $time_string;
} # }}}

# vim: ft=perl
# vim600: fdm=marker fdl=0 fdc=3