Apache2-SSI
view release on metacpan or search on metacpan
lib/Apache2/SSI.pm view on Meta::CPAN
# $r->sendfile( $r->filename );
# return( Apache2::Const::OK );
my $params =
{
apache_filter => $r->output_filters,
apache_request => $r,
debug => 3,
};
my $val;
my $map =
{
DEBUG => 'debug',
Echomsg => 'echomsg',
Errmsg => 'errmsg',
Sizefmt => 'sizefmt',
Timefmt => 'timefmt',
};
foreach my $key ( keys( %$map ) )
{
if( length( $val = $r->dir_config( "Apache2_SSI_${key}" ) ) )
{
$params->{ $map->{ $key } } = $val;
}
}
if( $r->dir_config( 'Apache2_SSI_Expression' ) eq 'legacy' )
{
$params->{legacy} = 1;
}
elsif( $r->dir_config( 'Apache2_SSI_Expression' ) eq 'trunk' )
{
$params->{trunk} = 1;
}
# new(9 will automatically set the value for uri() based on the Apache2::RequestRec->unparsed_uri
my $self = $class->new( $params ) || do
{
$r->log->error( "Error instantiating ${class}: ", $class->error );
return( &Apache2::Const::DECLINED );
};
my $u = $self->uri || do
{
$r->log->error( "No URI set. This should not happen." );
$r->status( &Apache2::Const::HTTP_INTERNAL_SERVER_ERROR );
return( &Apache2::Const::OK );
};
unless( $u->code == &Apache2::Const::HTTP_OK )
{
$r->log->error( "Cannot server uri \"$u\". http code is \"", $u->code, "\"." );
$r->status( $u->code );
return( &Apache2::Const::DECLINED );
}
my $file = $u->filename;
my $max_length = int( $r->dir_config( 'Apache2_SSI_Max_Length' ) ) || 0;
if( -s( $file ) >= $max_length )
{
$r->log->error( "HTML data exceeds our size threshold of $max_length. Rejecting the request." );
$r->status( &Apache2::Const::HTTP_REQUEST_ENTITY_TOO_LARGE );
return( &Apache2::Const::OK );
}
my $html = $u->slurp_utf8;
if( !length( $html ) )
{
$r->status( &Apache2::Const::HTTP_NO_CONTENT );
return( &Apache2::Const::OK );
}
# my $addr = $r->useragent_addr;
my $res = $self->parse( $html );
if( !defined( $res ) )
{
$r->log->error( "${class} is unable to process data: ", $self->error );
return( &Apache2::Const::DECLINED );
}
else
{
local $@;
# try-catch
$res = eval
{
Encode::encode( 'utf8', $res, Encode::FB_CROAK );
};
if( $@ )
{
$r->log->error( "${class} encountered an error while trying to encode data into utf8: $@" );
return( &Apache2::Const::DECLINED );
}
my $len = length( $res );
# try-catch
eval
{
$r->headers_out->set( 'Content-Length' => $len );
my $sent = $r->print( $res );
};
if( $@ )
{
$r->log->error( "${class} encountered an error while sending resulting data via Apache2::Filter->print: $@" );
}
return( &Apache2::Const::OK );
}
}
# https://perl.apache.org/docs/2.0/user/handlers/filters.html#C_PerlOutputFilterHandler_
# sub handler : FilterRequestHandler
# sub handler : method
sub apache_filter_handler
{
# my( $class, $f, $brigade, $mode, $type, $len ) = @_;
my( $class, $f, $bb ) = @_;
my $r = $f->r;
# my $class = __PACKAGE__;
my $main = $r->is_initial_req ? $r : $r->main;
return( &Apache2::Const::DECLINED ) unless( $r->is_initial_req && $main->content_type eq 'text/html' );
my $debug = int( $r->dir_config( 'Apache2_SSI_DEBUG' ) );
$main->no_cache(1) if( ( $r->dir_config( 'Apache2_SSI_NO_CACHE' ) ) eq 'on' );
$r->log->debug( "${class} [PerlOutputFilterHandler]: Received request for uri '", $r->uri, "' with path info '", $r->path_info, "'." ) if( $debug > 0 );
my $ctx = $f->ctx;
unless( $ctx->{invoked} )
{
$r->log->debug( "${class} [PerlOutputFilterHandler]: First time invoked, removing Content-Length header currently set to '", $r->headers_out->get( 'Content-Length' ), "'." ) if( $debug > 0 );
$r->headers_out->unset( 'Content-Length' );
}
# Then, we might get called multiple time, since there may be multiple brigade buckets
# Here, we retrieve the last buffer we put in $f->ctx->{data} if any
my $html = exists( $ctx->{data} ) ? $ctx->{data} : '';
$r->log->debug( "${class} [PerlOutputFilterHandler]: HTML data buffer set to '$html'." ) if( $debug > 0 );
$ctx->{invoked}++;
my $seen_eos = 0;
my $max_length = int( $r->dir_config( 'Apache2_SSI_Max_Length' ) ) || 0;
$r->log->debug( "${class} [PerlOutputFilterHandler]: Maximum length set to '$max_length'." ) if( $debug > 0 );
# Get all the brigade buckets data
for( my $b = $bb->first; $b; $b = $bb->next( $b ) )
{
$seen_eos++, last if( $b->is_eos );
$b->read( my $bdata );
$html .= $bdata;
return( &Apache2::Const::DECLINED ) if( $max_length && length( $html ) >= $max_length );
}
# If we have not reached the special End-of-String bucket, we store our buffer in $f->ctx->{data} and return OK
if( !$seen_eos )
{
# store context for all but the last invocation
$r->log->debug( "${class} [PerlOutputFilterHandler]: Not reached the EOS bucket. Storing html to data buffer." ) if( $debug > 0 );
$ctx->{data} = $html;
$f->ctx( $ctx );
return( &Apache2::Const::OK );
}
# Let's behave well as per the doc
if( $f->c->keepalive == &Apache2::Const::CONN_KEEPALIVE )
{
$r->log->debug( "${class} [PerlOutputFilterHandler]: KeepAlive count (", $f->c->keepalive, ") reached the threshold of '", &Apache2::Const::CONN_KEEPALIVE, "'." ) if( $debug > 0 );
$ctx->{data} = '';
$f->ctx( $ctx );
}
my $size = length( $html );
$ctx->{data} = '';
$ctx->{invoked} = 0;
$f->ctx( $ctx );
if( $size == 0 )
{
$r->log->debug( "${class} [PerlOutputFilterHandler]: Data received is empty. Nothing to do." );
return( &Apache2::Const::OK );
}
local $@;
# try-catch
$html = eval
{
Encode::decode( 'utf8', $html, Encode::FB_CROAK );
};
if( $@ )
{
$r->log->error( "${class} [PerlOutputFilterHandler]: Failed to decode data from utf8: $@" );
return( &Apache2::Const::DECLINED );
}
#W We just add that the charset is utf-8
$main->content_type( 'text/html; charset=utf-8' ) unless( $main->content_type =~ /\bcharset\n/i );
my $params =
{
apache_filter => $f,
apache_request => $r,
debug => 3,
};
my $val;
my $map =
{
DEBUG => 'debug',
Echomsg => 'echomsg',
Errmsg => 'errmsg',
Sizefmt => 'sizefmt',
Timefmt => 'timefmt',
};
foreach my $key ( keys( %$map ) )
{
if( length( $val = $r->dir_config( "Apache2_SSI_${key}" ) ) )
{
$params->{ $map->{ $key } } = $val;
}
}
if( $r->dir_config( 'Apache2_SSI_Expression' ) eq 'legacy' )
{
$params->{legacy} = 1;
}
elsif( $r->dir_config( 'Apache2_SSI_Expression' ) eq 'trunk' )
{
$params->{trunk} = 1;
}
$r->log->debug( "${class} [PerlOutputFilterHandler]: Creating a ${class} object." ) if( $debug > 0 );
my $self = $class->new( $params ) || do
{
$r->log->error( "Error instantiating ${class}: ", $class->error );
return( &Apache2::Const::DECLINED );
};
# my $addr = $r->useragent_addr;
my $res = $self->parse( $html );
if( !defined( $res ) )
{
$r->log->error( "${class} [PerlOutputFilterHandler]: is unable to process data: ", $self->error );
return( &Apache2::Const::DECLINED );
}
else
{
# try-catch
$res = eval
{
Encode::encode( 'utf8', $res, Encode::FB_CROAK );
};
if( $@ )
{
$r->log->error( "${class} [PerlOutputFilterHandler]: encountered an error while trying to encode data into utf8: $@" );
return( &Apache2::Const::DECLINED );
}
# $r->headers_out->unset( 'Content-Length' );
my $len = length( $res );
# try-catch
eval
{
$r->headers_out->set( 'Content-Length' => $len );
my $sent = $f->print( "$res" );
$r->log->debug( "${class} [PerlOutputFilterHandler]: ${sent} bytes sent out." ) if( $debug > 0 );
};
if( $@ )
{
$r->log->error( "${class} encountered an error while sending resulting data via Apache2::Filter->print: $@" );
}
# This will cause a segfault
# $r->rflush;
return( &Apache2::Const::OK );
}
}
sub init
{
my $self = shift( @_ );
my $class = ref( $self );
my $args = {};
if( scalar( @_ ) )
{
no warnings 'uninitialized';
$args = Scalar::Util::reftype( $_[0] ) eq 'HASH'
? shift( @_ )
: !( scalar( @_ ) % 2 )
? { @_ }
: {};
}
my $uri = delete( $args->{document_uri} ) // '';
$self->{html} = '';
$self->{apache_filter} = '';
$self->{apache_request} = '';
$self->{document_root} = '';
# e.g.: [Value Undefined]
$self->{echomsg} = '';
$self->{errmsg} = '[an error occurred while processing this directive]';
$self->{filename} = '';
$self->{legacy} = 0;
$self->{trunk} = 0;
$self->{remote_ip} = '';
$self->{sizefmt} = 'abbrev';
$self->{timefmt} = undef;
$self->{_init_strict_use_sub} = 1;
$self->{_init_params_order} = [qw( apache_filter apache_request document_root document_uri )];
$self->SUPER::init( %$args ) || return;
$self->{_env} = '';
$self->{_path_info_processed} = 0;
# Used to hold regular expression matches during eval in _eval_vars()
# and make them available for the next evaluation
$self->{_regexp_capture}= [];
$self->{_uri_reset} = 0;
# A stack reflecting the current state of if/else parser.
lib/Apache2/SSI.pm view on Meta::CPAN
if( length( "$p->{document_uri}" ) && length( "$p->{document_root}" ) )
{
my $u = Apache2::SSI::URI->new( $p ) ||
return( $self->error( "Unable to instantiate an Apache2::SSI::URI object with document uri \"$p->{document_uri}\" and document root \"$p->{document_root}\": ", Apache2::SSI::URI->error ) );
$self->{uri} = $u;
}
elsif( !length( "$p->{document_root}" ) )
{
return( $self->error( "No document root ($p->{document_root}) value was provided." ) );
}
elsif( !length( "$p->{document_uri}" ) )
{
return( $self->error( "No document uri ($p->{document_uri}) value was provided." ) );
}
else
{
return( $self->error( "No document uri ($p->{document_uri}) nor document root ($p->{document_root}) value were provided." ) );
}
my $notes;
$notes = Apache2::SSI::Notes->new( debug => $self->{debug} ) if( Apache2::SSI::Notes->supported );
$self->{notes} = $notes;
return( $self );
}
sub apache_filter { return( shift->_set_get_object_without_init( 'apache_filter', 'Apache2::Filter', @_ ) ); }
sub apache_request { return( shift->_set_get_object_without_init( 'apache_request', 'Apache2::RequestRec', @_ ) ); }
sub clone
{
my $self = shift( @_ );
my $class = ref( $self ) || $self;
my @copy = qw( debug echomsg errmsg remote_ip sizefmt timefmt );
my $params = {};
@$params{ @copy } = @$self{ @copy };
$params->{apache_filter} = $self->apache_filter if( $self->apache_filter );
$params->{apache_request} = $self->apache_request if( $self->apache_request );
$params->{document_uri} = $self->uri->document_uri;
$params->{document_root} = $self->document_root;
my $new = $class->new( %$params ) || return( $self->error( "Unable to create a clone of our object: ", $class->error ) );
return( $new );
}
sub decode_base64
{
my $self = shift( @_ );
local $@;
# try-catch
my $rv = eval
{
my $v = join( '', @_ );
if( $self->mod_perl )
{
$v = APR::Base64::decode( $v );
}
else
{
require MIME::Base64;
$v = MIME::Base64::decode( $v );
}
$v = Encode::decode( 'utf8', $v ) if( $self->_has_utf8( $v ) );
return( $v );
};
if( $@ )
{
return( $self->error( "Error while decoding base64 data: $@" ) );
}
return( $rv );
}
sub decode_entities
{
my $self = shift( @_ );
local $@;
# try-catch
my $rv = eval
{
return( HTML::Entities::decode_entities( @_ ) );
};
if( $@ )
{
return( $self->error( "Error while decoding html entities data: $@" ) );
}
return( $rv );
}
sub decode_uri
{
my $self = shift( @_ );
local $@;
# try-catch
my $rv = eval
{
require URI::Escape::XS;
return( URI::Escape::XS::uri_unescape( @_ ) );
};
if( $@ )
{
return( $self->error( "Error while decoding uri: $@" ) );
}
return( $rv );
}
sub decode_url
{
my $self = shift( @_ );
local $@;
# try-catch
my $rv = eval
{
if( $self->mod_perl )
{
return( Encode::decode( 'utf8', APR::Request::decode( @_ ), Encode::FB_CROAK ) );
}
else
{
# Will use XS version automatically
require URL::Encode;
return( URL::Encode::url_decode_utf8( @_ ) );
}
};
if( $@ )
{
return( $self->error( "Error while url decoding data: $@" ) );
}
return( $rv );
}
sub document_filename { return( shift->uri->filename( @_ ) ); }
sub document_path { return( shift->uri->document_path( @_ ) ); }
sub document_root
{
my $self = shift( @_ );
my $r = $self->apache_request;
if( $r )
{
$r->document_root( @_ ) if( @_ );
return( $r->document_root );
}
else
{
if( @_ )
{
$self->{document_root} = shift( @_ );
$self->_set_env( DOCUMENT_ROOT => $self->{document_root} );
}
return( $self->{document_root} || $self->env( 'DOCUMENT_ROOT' ) );
}
}
# A document uri is an absolute uri possibly with some path info and query string.
sub document_uri { return( shift->uri->document_uri( @_ ) ); }
sub echomsg { return( shift->_set_get_scalar( 'echomsg', @_ ) ); }
sub encode_base64
{
my $self = shift( @_ );
local $@;
# try-catch
my $rv = eval
{
my $v = join( '', @_ );
$v = Encode::encode( 'utf8', $v, Encode::FB_CROAK ) if( Encode::is_utf8( $v ) );
if( $self->mod_perl )
{
return( APR::Base64::encode( $v ) );
}
else
{
require MIME::Base64;
return( MIME::Base64::encode( $v, '' ) );
}
};
if( $@ )
{
return( $self->error( "Error while encoding data into base64: $@" ) );
}
return( $rv );
}
sub encode_entities
{
my $self = shift( @_ );
local $@;
# try-catch
my $rv = eval
{
return( HTML::Entities::encode_entities( join( '', @_ ) ) );
};
if( $@ )
{
return( $self->error( "Error while encoding data into html entities: $@" ) );
}
return( $rv );
}
sub encode_md5
{
my $self = shift( @_ );
local $@;
# try-catch
my $rv = eval
{
require Digest::MD5;
my $v = join( '', @_ );
$v = Encode::encode( 'utf8', $v, Encode::FB_CROAK ) if( Encode::is_utf8( $v ) );
return( Digest::MD5::md5_hex( $v ) );
};
if( $@ )
{
return( $self->error( "Error while encoding data into md5 hex: $@" ) );
}
return( $rv );
}
sub encode_uri
{
my $self = shift( @_ );
local $@;
# try-catch
my $rv = eval
{
require URI::Escape::XS;
# return( URI::Escape::uri_escape_utf8( join( '', @_ ) ) );
return( URI::Escape::XS::uri_escape( join( '', @_ ) ) );
};
if( $@ )
{
return( $self->error( "Error while encoding uri: $@" ) );
}
return( $rv );
}
sub encode_url
{
my $self = shift( @_ );
local $@;
# try-catch
my $rv = eval
{
if( $self->mod_perl )
{
my $v = Encode::encode( 'utf8', join( '', @_ ), Encode::FB_CROAK );
return( APR::Request::encode( $v ) );
}
else
{
# Will use XS version automatically
require URL::Encode;
return( URL::Encode::url_encode_utf8( join( '', @_ ) ) );
}
};
if( $@ )
{
return( $self->error( "Error while url encoding data: $@" ) );
}
return( $rv );
}
sub env
{
my $self = shift( @_ );
# The user wants the entire hash reference
unless( @_ )
{
my $r = $self->apache_request;
if( $r )
{
$r = $r->is_initial_req ? $r : $r->main ? $r->main : $r;
return( $r->subprocess_env )
}
else
{
unless( ref( $self->{_env} ) )
{
$self->{_env} = {%ENV};
}
return( $self->{_env} );
}
}
my $name = shift( @_ );
return( $self->error( "No environment variable name was provided." ) ) if( !length( $name ) );
my $opts = {};
if( scalar( @_ ) )
{
no warnings 'uninitialized';
$opts = pop( @_ ) if( defined( $_[-1] ) && Scalar::Util::reftype( $_[-1] ) eq 'HASH' );
}
# return( $self->error( "Environment variable value provided is a reference data (", overload::StrVal( $val ), ")." ) ) if( ref( $val ) && ( !overload::Overloaded( $val ) || ( overload::Overloaded( $val ) && !overload::Method( $val, '""' ) ) ) );
my $r = $opts->{apache_request} || $self->apache_request;
if( $r )
{
$r = $r->is_initial_req ? $r : $r->main ? $r->main : $r;
if( @_ )
{
my $val = shift( @_ );
$r->subprocess_env( $name => $val );
$ENV{ $name } = $val;
}
my $v = $r->subprocess_env( $name );
return( $v );
}
else
{
my $env = {};
unless( ref( $self->{_env} ) )
{
# Make a copy of the environment variables
$self->{_env} = {%ENV};
}
lib/Apache2/SSI.pm view on Meta::CPAN
return( $headers->{ $header_name } );
}
# No http header outside of Apache
else
{
return( '' );
}
}
sub parse_func_sha1
{
my $self = shift( @_ );
my $val = join( '', @_ );
require Digest::SHA;
return( Digest::SHA::sha1_hex( $val ) );
}
sub parse_func_tolower
{
my $self = shift( @_ );
return( lc( join( '', @_ ) ) );
}
sub parse_func_toupper
{
my $self = shift( @_ );
return( uc( join( '', @_ ) ) );
}
sub parse_func_unbase64 { return( shift->decode_base64( join( '', @_ ) ) ); }
sub parse_func_unescape { return( shift->decode_uri( join( '', @_ ) ) ); }
sub parse_if
{
my( $self, $args ) = @_;
unshift( @{$self->{if_state}}, 0 );
unshift( @{$self->{suspend}}, $self->{suspend}->[0] );
return( '' ) if( $self->{suspend}->[0] );
return( $self->_handle_ifs( $self->parse_eval_expr( $args->{expr} ) ) );
}
sub parse_include
{
my( $self, $args ) = @_;
unless( exists( $args->{file} ) or exists( $args->{virtual} ) )
{
return( $self->error( "No 'file' or 'virtual' attribute found in SSI 'include' tag" ) );
}
my $f = $self->find_file( $args );
unless( $f->code == 200 )
{
return( $self->errmsg );
}
my $filename = $f->filename;
if( !-e( "$filename" ) )
{
return( $self->errmsg );
}
# TODO This needs to be improved, as we should not assume the file encoding is utf8
# It could be binary or some other text encoding like iso-2022-jp
# So we should slurp it, parse the meta tags if this is an html and decode if the charset attribute is set or default to utf8
# But this complicates things quite a bit, so for now, it is just utf8 simply
my $html = $f->slurp_utf8;
if( !defined( $html ) )
{
$self->error( "Unable to get html data of included file \"", $f->filename, "\": ", $f->error );
return( $self->errmsg );
}
my $clone = $self->clone || do
{
warn( $self->error );
return( $self->errmsg );
};
# share our environment variables with our clone so we pass it to included files.
# If we are running under mod_perl, we'll use subprocess_env
my $env = $self->env;
$clone->{_env} = $env;
return( $clone->parse( $html ) );
}
# NOTE: Legacy
# http://perl.apache.org/docs/1.0/guide/snippets.html#Passing_Arguments_to_a_SSI_script
sub parse_perl
{
my( $self, $args, $margs ) = @_;
my $r = $self->apache_request;
my( $pass_r, @arg1, @arg2, $sub ) = (1);
{
my @a;
while( @a = splice( @$margs, 0, 2 ) )
{
$a[1] =~ s/\\(.)/$1/gs;
if( lc( $a[0] ) eq 'sub' )
{
$sub = $a[1];
}
elsif( lc( $a[0] ) eq 'arg' )
{
push( @arg1, $a[1] );
}
elsif( lc( $a[0] ) eq 'args' )
{
push( @arg1, split( /,/, $a[1] ) );
}
elsif( lc( $a[0] ) eq 'pass_request' )
{
$pass_r = 0 if( lc( $a[1] ) eq 'no' );
}
elsif( $a[0] =~ s/^-// )
{
push( @arg2, @a );
}
# Any unknown get passed as key-value pairs
else
{
push( @arg2, @a );
}
}
}
my $subref;
# for <!--#perl sub="sub {print ++$Access::Cnt }" -->
lib/Apache2/SSI.pm view on Meta::CPAN
require DateTime::Format::Strptime;
my $tz;
# DateTime::TimeZone::Local will die ungracefully if the local timezeon is not set with the error:
# "Cannot determine local time zone"
local $@;
# try-catch
eval
{
require DateTime::TimeZone;
$tz = DateTime::TimeZone->new( name => 'local' );
};
if( $@ )
{
$tz = DateTime::TimeZone->new( name => 'UTC' );
warn( "Your system is missing key timezone components. Reverting to UTC instead of local time zone.\n" );
}
# try-catch
my $rv = eval
{
my $dt = DateTime->from_epoch( %$params );
if( length( $format ) )
{
my $fmt = DateTime::Format::Strptime->new(
pattern => $format,
time_zone => ( $params->{time_zone} || $tz ),
locale => $dt->locale->code,
);
$dt->set_formatter( $fmt );
return( $dt );
}
else
{
return( $dt->format_cldr( $dt->locale->date_format_full ) );
}
};
if( $@ )
{
$self->error( "An error occurred getting a DateTime object for time \"$time\" with format \"$format\": $@" );
return( $self->errmsg );
}
return( $rv );
}
sub _handle_ifs
{
my $self = shift( @_ );
my $cond = shift( @_ );
if( $self->{if_state}->[0] )
{
$self->{suspend}->[0] = 1;
}
else
{
$self->{suspend}->[0] = !( $self->{if_state}->[0] = !!$cond );
}
return( '' );
}
sub _has_utf8
{
my $self = shift( @_ );
return( $_[0] =~ /$IS_UTF8/ );
}
sub _interp_vars
{
# Find all $var and ${var} expressions in the string and fill them in.
my $self = shift( @_ );
# Because ssi_echo may change $1, $2, ...
my( $a, $b, $c );
$_[0] =~ s{ (^|[^\\]) (\\\\)* \$(\{)?(\w+)(\})? }
{ ($a,$b,$c) = ($1,$2,$4);
$a . ( length( $b ) ? substr( $b, length( $b ) / 2 ) : '' ) . $self->parse_echo({ var => $c }) }exg;
}
sub _ipmatch
{
my $self = shift( @_ );
my $subnet = shift( @_ ) || return( $self->error( "No subnet provided" ) );
my $ip = shift( @_ ) || $self->remote_ip;
local $@;
# try-catch
my $rv = eval
{
local $SIG{__WARN__} = sub{};
require Net::Subnet;
my $net = Net::Subnet::subnet_matcher( $subnet );
my $res = $net->( $ip );
return( $res ? 1 : 0 );
};
if( $@ )
{
$self->error( "Error while calling Net::Subnet: $@" );
return(0);
}
return( $rv );
}
sub _is_ip
{
my $self = shift( @_ );
my $ip = shift( @_ );
return( 0 ) if( !length( $ip ) );
# We need to return either 1 or 0. By default, perl return undef for false
return( $ip =~ /^(?:$RE{net}{IPv4}|$RE{net}{IPv6})$/ ? 1 : 0 );
}
sub _is_number
{
my $self = shift( @_ );
my $word = shift( @_ );
return( 0 ) if( !length( $word ) );
return( $word =~ /^(?:$RE{num}{int}|$RE{num}{real})$/ ? 1 : 0 );
}
sub _is_perl_script
{
my $self = shift( @_ );
my $file = shift( @_ );
lib/Apache2/SSI.pm view on Meta::CPAN
{
my( %hout );
$hout{STATUS} = $subr->status;
$hout{STATUSLINE} = $subr->status_line;
$subr->headers_out->do(sub
{
$hout{ lc( $_[0] ) } = $_[1];
1;
});
return( ( join( '', @$output ), \%hout ) );
}
else
{
return( join( '', @$output ) );
}
}
if( wantarray )
{
my( %hout );
$hout{STATUS} = $subr->status;
$hout{STATUS} = &Apache2::Const::HTTP_NOT_FOUND
if( $hout{STATUS} == &Apache2::Const::HTTP_OK );
$subr->headers_out->do(sub
{
$hout{ lc( $_[0] ) } = $_[1];
1;
});
return( ( undef, \%hout ) );
}
else
{
return;
}
return;
}
}
1;
# NOTE: POD
__END__
=encoding utf-8
=head1 NAME
Apache2::SSI - Apache2 Server Side Include
=head1 SYNOPSIS
Outside of Apache:
use Apache2::SSI;
my $ssi = Apache2::SSI->new(
# If running outside of Apache
document_root => '/path/to/base/directory'
# Default error message to display when ssi failed to parse
# Default to [an error occurred while processing this directive]
errmsg => '[Oops]'
);
my $fh = IO::File->new( "</some/file.html" ) || die( "$!\n" );
$fh->binmode( ':utf8' );
my $size = -s( $fh );
my $html;
$fh->read( $html, $size );
$fh->close;
if( !defined( my $result = $ssi->parse( $html ) ) )
{
$ssi->throw;
};
print( $result );
Inside Apache, in the VirtualHost configuration, for example:
PerlModule Apache2::SSI
PerlOptions +GlobalRequest
PerlSetupEnv On
<Directory "/home/joe/www">
Options All +Includes +ExecCGI -Indexes -MultiViews
AllowOverride All
SetHandler modperl
# You can choose to set this as a response handler or a output filter, whichever works.
# PerlResponseHandler Apache2::SSI
PerlOutputFilterHandler Apache2::SSI
# If you do not set this to On, path info will not work, example:
# /path/to/file.html/path/info
# See: <https://httpd.apache.org/docs/current/en/mod/core.html#acceptpathinfo>
AcceptPathInfo On
# To enable no-caching (see no_cache() in Apache2::RequestUtil:
PerlSetVar Apache2_SSI_NO_CACHE On
# This is required for exec cgi to work:
# <https://httpd.apache.org/docs/current/en/mod/mod_include.html#element.exec>
<Files ~ "\.pl$">
SetHandler perl-script
AcceptPathInfo On
PerlResponseHandler ModPerl::PerlRun
# Even better for stable cgi scripts:
# PerlResponseHandler ModPerl::Registry
# Change this in mod_perl1 PerlSendHeader On to the following:
# <https://perl.apache.org/docs/2.0/user/porting/compat.html#C_PerlSendHeader_>
PerlOptions +ParseHeaders
</Files>
<Files ~ "\.cgi$">
SetHandler cgi-script
AcceptPathInfo On
</Files>
# To enable debugging output in the Apache error log
# PerlSetVar Apache2_SSI_DEBUG 3
# To set the default echo message
# PerlSetVar Apache2_SSI_Echomsg
# To Set the default error message
# PerlSetVar Apache2_SSI_Errmsg "Oops, something went wrong"
# To Set the default size format: bytes or abbrev
# PerlSetVar Apache2_SSI_Sizefmt "bytes"
# To Set the default date time format
# PerlSetVar Apache2_SSI_Timefmt ""
# To enable legacy mode:
# PerlSetVar Apache2_SSI_Expression "legacy"
# To enable trunk mode:
# PerlSetVar Apache2_SSI_Expression "trunk"
</Directory>
lib/Apache2/SSI.pm view on Meta::CPAN
See L<Apache2 documentation|https://httpd.apache.org/docs/current/en/howto/ssi.html> for more information on this.
=item C<trunk>
This takes a boolean value such as C<0> or C<1> and when enabled this allows the support for Apache2 experimental expressions.
See L<Regexp::Common::Apache2> for more information.
Also, see the property C<legacy> to enable legacy Apache2 expressions.
=back
=head2 handler
This is a key method expected by mod_perl. Depending on how this module is used, it will redirect either to L</apache_filter_handler> or to L</apache_response_handler>
=head2 ap2perl_expr
This method is used to convert Apache2 expressions into perl equivalents to be then eval'ed.
It takes an hash reference provided by L<Apache2::Expression/parse>, an array reference to store the output recursively and an optional hash reference of parameters.
It parse recursively the structure provided in the hash reference to provide the perl equivalent for each Apache2 expression component.
It returns the array reference provided as the content buffer. This array is used by L</parse_expr> and then joined using a single space to form a string of perl expression to be eval'ed.
=head2 apache_filter
Set or get the L<Apache2::Filter> object.
When running under Apache mod_perl this is set automatically from the special L</handler> method.
=head2 apache_filter_handler
This method is called from L</handler> to handle the Apache response when this module L<Apache2::SSI> is used as a filter handler.
See also L</apache_response_handler>
=head2 apache_request
Sets or gets the L<Apache2::RequestRec> object. As explained in the L</new> method, you can get this Apache object by requiring the package L<Apache2::RequestUtil> and calling L<Apache2::RequestUtil/request> such as C<Apache2::RequestUtil->request> a...
When running under Apache mod_perl this is set automatically from the special L</handler> method, such as:
my $r = $f->r; # $f is the Apache2::Filter object provided by Apache
=head2 apache_response_handler
This method is called from L</handler> to handle the Apache response when this module L<Apache2::SSI> is used as a response handler.
See also L</apache_filter_handler>
=head2 clone
Create a clone of the object and return it.
=head2 decode_base64
Decode base64 data provided. When running under Apache mod_perl, this uses L<APR::Base64/decode> module, otherwise it uses L<MIME::Base64/decode>
If the decoded data contain utf8 data, this will decode the utf8 data using L<Encode/decode>
If an error occurred during decoding, it will return undef and set an L</error> object accordingly.
=head2 decode_entities
Decode html data containing entities. This uses L<HTML::Entities/decode_entities>
If an error occurred during decoding, it will return undef and set an L</error> object accordingly.
Example:
$ssi->decode_entities( 'Tous les êtres humains naissent libres et égaux en dignité et en droits.' );
# Tous les êtres humains naissent libres et égaux en dignité et en droits.
=head2 decode_uri
Decode uri encoded data. This uses L<URI::Escape/uri_unescape>.
Not to be confused with x-www-form-urlencoded data. For that see L</decode_url>
If an error occurred during decoding, it will return undef and set an L</error> object accordingly.
Example:
$ssi->decode_uri( 'https%3A%2F%2Fwww.example.com%2F' );
# https://www.example.com/
=head2 decode_url
Decode x-www-form-urlencoded encoded data. When using Apache mod_perl, this uses L<APR::Request/decode> and L<Encode/decode>, otherwise it uses L<URL::Encode/url_decode_utf8> (its XS version) to achieve the same result.
If an error occurred during decoding, it will return undef and set an L</error> object accordingly.
Example:
$ssi->decode_url( 'Tous+les+%C3%83%C2%AAtres+humains+naissent+libres+et+%C3%83%C2%A9gaux+en+dignit%C3%83%C2%A9+et+en+droits.' );
# Tous les êtres humains naissent libres et égaux en dignité et en droits.
=head2 document_filename
This is an alias for L<Apache2::SSI::URI/filename>
=head2 document_directory
Returns an L<Apache2::SSI::URI> object of the current directory of the L</document_uri> provided.
=head2 document_path
Sets or gets the uri path to the document. This is the same as L</document_uri>, except it is striped from L</query_string> and L</path_info>.
=head2 document_root
Sets or gets the document root.
Wen running under Apache mod_perl, this value will be available automatically, using L<Apache2::RequestRec/document_root> method.
If it runs outside of Apache, this will use the value provided upon instantiating the object and passing the C<document_root> parameter. If this is not set, it will return the value of the environment variable C<DOCUMENT_ROOT>.
=head2 document_uri
Sets or gets the document uri, which is the uri of the document being processed.
For example:
/index.html
Under Apache, this will get the environment variable C<DOCUMENT_URI> or calls the L<Apache2::RequestRec/uri> method.
Outside of Apache, this will rely on a value being provided upon instantiating an object, or the environment variable C<DOCUMENT_URI> be present.
The value should be an absolute uri.
=head2 echomsg
The default message to be returned for the C<echo> command when the variable called is not defined.
Example:
$ssi->echomsg( '[Value Undefined]' );
# or in the document itself
<!--#config echomsg="[Value Undefined]" -->
<!--#echo var="NON_EXISTING" encoding="none" -->
would produce:
[Value Undefined]
=head2 encode_base64
Encode data provided into base64. When running under Apache mod_perl, this uses L<APR::Base64/encode> module, otherwise it uses L<MIME::Base64/encode>
If the data have the perl internal utf8 flag on as checked with L<Encode/is_utf8>, this will encode the data into utf8 using L<Encode/encode> before encoding it into base64.
Please note that the base64 encoded resulting data is all on one line, similar to what Apache would do. The data is B<NOT> broken into lines of 76 characters.
If an error occurred during encoding, it will return undef and set an L</error> object accordingly.
=head2 encode_entities
Encode data into html entities. This uses L<HTML::Entities/encode_entities>
If an error occurred during encoding, it will return undef and set an L</error> object accordingly.
Example:
$ssi->encode_entities( 'Tous les êtres humains naissent libres et égaux en dignité et en droits.' );
# Tous les êtres humains naissent libres et égaux en dignité et en droits.
=head2 encode_md5
Encode data provided into md5. This uses L<Digest::MD5> which it will attempt to load.
=head2 encode_uri
Encode uri data. This uses L<URI::Escape::XS/uri_escape>.
Not to be confused with x-www-form-urlencoded data. For that see L</encode_url>
If an error occurred during encoding, it will return undef and set an L</error> object accordingly.
Example:
$ssi->encode_uri( 'https://www.example.com/' );
# https%3A%2F%2Fwww.example.com%2F
=head2 encode_url
Encode data provided into an x-www-form-urlencoded string. When using Apache mod_perl, this uses L<APR::Request/encode>, otherwise it uses L<URL::Encode/url_encode_utf8> (its XS version)
If an error occurred during decoding, it will return undef and set an L</error> object accordingly.
Example:
$ssi->encode_url( 'Tous les êtres humains naissent libres et égaux en dignité et en droits.' );
# Tous+les+%C3%83%C2%AAtres+humains+naissent+libres+et+%C3%83%C2%A9gaux+en+dignit%C3%83%C2%A9+et+en+droits.
=head2 env
Sets or gets the value for an environment variable. Or, if no environment variable name is provided, it returns the entire hash reference. This method is intended to be used by users of this module, not by developers wanting to inherit from it.
Note that the environment variable hash is unique for each new object, so it works like L<Apache2::RequestRec/subprocess_env>, meaning each process has its set of environment variable.
When a value is set for an environment variable that has an equivalent name, it will call the method as well with the new value provided. This is done to ensure data consistency and also additional processing if necessary.
For example, let's assume you set the environment variable C<REQUEST_URI> or C<DOCUMENT_URI> like this:
$ssi->env( REQUEST_URI => '/some/path/to/file.html?q=something&l=ja_JP' );
This will, in turn, call L</request_uri>, which is an alias for L<document_uri> and this method will get the uri, path info and query string from the value provided and set those values accordingly, so they can be available when parsing.
=head2 errmsg
Sets or gets the error message to be displayed in lieu of a faulty ssi directive. This is the same behaviour as in Apache.
=head2 error
Retrieve the error object set. This is a L<Module::Generic::Error> object.
This module does not die nor "croak", but instead returns undef when an error occurs and set the error object.
It is up to you to check the return value of the method calls. If you do not, you will miss important information. If you really want your script to die, it is up to you to interrupt it:
if( !defined( $ssi->parse( $some_html_data ) ) )
{
die( $ssi->error );
}
or maybe more simply, when you are sure you will not get a false, but defined value:
$ssi->parse( $some_html_data ) || die( $ssi->error );
This example is dangerous, because L</parse> might return an empty string which will be construed as a false value and will trigger the die statement, even though no error had occurred.
=head2 filename
This is an alias for L<Apache2::SSI::URI/filename>
=head2 find_file
Provided with a file path, and this will resolve any variable used and attempt to look it up as a file if the argument C<file> is provided with a file path as a value, or as a URI if the argument C<virtual> is provided as an argument.
This will call L</lookup_file> or L</lookup_uri> depending on whether it is dealing with a file or an uri.
It returns a L<Apache2::SSI::URI> object which is stringifyable and contain the file path.
=head2 finfo
Returns a L<Apache2::SSI::Finfo> object. This provides access to L<perlfunc/stat> information as method, taking advantage of L<APR::Finfo> when running under Apache, and L<File::stat>-like interface otherwise. See L<Apache2::SSI::Finfo> for more info...
lib/Apache2/SSI.pm view on Meta::CPAN
Parse the C<elif> condition.
Example:
<!--#if expr=1 -->
Hi, should print
<!--#elif expr=1 -->
Shouldn't print
<!--#else -->
Shouldn't print
<!--#endif -->
=head2 parse_else
Parse the C<else> condition.
See L</parse_elif> above for example.
=head2 parse_endif
Parse the C<endif> condition.
See L</parse_elif> above for example.
=head2 parse_flastmod
Process the ssi directive C<flastmod>
Provided with an hash reference of parameters and this will return the formatted date time of the file last modification time.
=head2 parse_fsize
Provided with an hash reference of parameters and this will return the formatted file size.
The output is affected by the value of L</sizefmt>. If its value is C<bytes>, it will return the raw size in bytes, and if its value is C<abbrev>, it will return its value formated in kilo, mega or giga units.
Example
<!--#config sizefmt="abbrev" -->
This file size is <!--#fsize file="/some/filesystem/path/to/archive.tar.gz" -->
would return:
This file size is 12.7M
Or:
<!--#config sizefmt="bytes" -->
This file size is <!--#fsize virtual="/some/filesystem/path/to/archive.tar.gz" -->
would return:
This file size is 13,316,917 bytes
The size value before formatting is a L<Module::Generic::Number> and the output is formatted using L<Number::Format> by calling L<Module::Generic::Number/format>
=head2 parse_func_base64
Returns the arguments provided into a base64 string.
If the arguments are utf8 data with perl internal flag on, as checked with L<Encode/is_utf8>, this will encode the data into utf8 with L<Encode/encode> before encoding it into base64.
Example:
<!--#set var="payload" value='{"sub":"1234567890","name":"John Doe","iat":1609047546}' encoding="base64" -->
<!--#if expr="$payload == 'eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNjA5MDQ3NTQ2fQo='" -->
Payload matches
<!--#else -->
Sorry, this failed
<!--#endif -->
=head2 parse_func_env
Return first match of L<note>, L<reqenv>, and L<osenv>
Example:
<!--#if expr="env( $QUERY_STRING ) == /\bl=ja_JP/" -->
Showing Japanese data
<!--#else -->
Defaulting to English
<!--#endif -->
=head2 parse_func_escape
Escape special characters in %hex encoding.
Example:
<!--#set var="website" value="https://www.example.com/" -->
Please go to <a href="<!--#echo var='website' encoding='escape' -->"><!--#echo var="website" --></a>
=head2 parse_func_http
Get HTTP request header; header names may be added to the Vary header.
Example:
<!--#if expr="http('X-API-ID') == 1234567" -->
You're good to go.
<!--#endif -->
However, outside of an Apache environment this will return the value of the environment variable in the following order:
=over 4
=item X-API-ID (i.e. the name as-is)
=item HTTP_X_API_ID (i.e. adding C<HTTP_> and replace C<-> for C<_>)
=item X_API_ID (i.e. same as above, but without the C<HTTP_> prefix)
=back
If none is found, it returns an empty string.
For an equivalent function for response headers, see L</parse_func_resp>
=head2 parse_func_ldap
Escape characters as required by LDAP distinguished name escaping (RFC4514) and LDAP filter escaping (RFC4515).
See L<Apache documentation|https://httpd.apache.org/docs/trunk/en/expr.html#page-header> for more information
Example:
<!--#set var="phrase" value="%{ldap:'Tous les êtres humains naissent libres (et égaux) en dignité et\ en\ droits.\n'}" -->
# Tous les êtres humains naissent libres \28et égaux\29 en dignité et\5c en\5c droits.\5cn
=head2 parse_func_md5
Hash the string using MD5, then encode the hash with hexadecimal encoding.
If the arguments are utf8 data with perl internal flag on, as checked with L<Encode/is_utf8>, this will encode the data into utf8 with L<Encode/encode> before encoding it with md5.
Example:
<!--#if expr="md5( $hash_data ) == '2f50e645b6ef04b5cfb76aed6de343eb'" -->
You're good to go.
<!--#endif -->
=head2 parse_func_note
Lookup request note
<!--#set var="CUSTOMER_ID" value="1234567" -->
<!--#if expr="note('CUSTOMER_ID') == 1234567" -->
Showing special message
<!--#endif -->
This uses L<Apache2::SSI::Notes> to enable notes to be shared on and off Apache2/mod_perl2 environment. Thus, you could set a note from a command-line perl script, and then access it under Apache2/mod_perl2 or just your regular script running under a...
For example:
In your perl script outside of Apache:
# Basic parameters to make Apache2::SSI happy
my $ssi = Apache2::SSI->new( document_root => '/home/john/www', document_uri => '/' ) ||
die( Apache2::SSI->error );
$ssi->notes( API_VERSION => 2 );
Then, in your perl script running under the web server, be it Apache2/mod_perl2 or not:
my $ssi = Apache2::SSI->new || die( Apache2::SSI->error );
my $api_version = $ssi->notes( 'API_VERSION' );
To enable shareability of notes on and off Apache, this makes uses of shared memory segments. See L<Apache2::SSI::Notes> for more information on the notes api and L<perlipc> for more information on shared memory segments.
Just keep in mind that the notes are B<never> removed even when Apache shuts down, so it is your responsibility to remove them if you do not want them anymore. For example:
use Apache2::SSI::Notes;
my $notes = Apache2::SSI::Notes->new;
$notes->remove;
be aware that shared notes might note be available for your platform. Check L<Apache2::SSI::Notes> for more information and also L<perlport> on shared memory segments.
=head2 parse_func_osenv
Lookup operating system environment variable
<!--#if expr="env('LANG') =~ /en(_(GB|US))/" -->
Showing English language
<!--#endif -->
=head2 parse_func_replace
replace(string, "from", "to") replaces all occurrences of "from" in the string with "to".
Example:
<!--#if expr="replace( 'John is in Tokyo', 'John', 'Jack' ) == 'Jack is in Tokyo'" -->
This worked!
<!--#else -->
Nope, it failed.
lib/Apache2/SSI.pm view on Meta::CPAN
Convert string to lower case.
Example:
<!--#if expr="tolower('Tous les êtres humains naissent libres et égaux en dignité et en droits.') == 'tous les êtres humains naissent libres et égaux en dignité et en droits.'" -->
This worked!
<!--#else -->
Nope, it failed.
<!--#endif -->
=head2 parse_func_toupper
Convert string to upper case.
Example:
<!--#if expr="toupper('Tous les êtres humains naissent libres et égaux en dignité et en droits.') == 'TOUS LES ÊTRES HUMAINS NAISSENT LIBRES ET ÉGAUX EN DIGNITÉ ET EN DROITS.'" -->
This worked!
<!--#else -->
Nope, it failed.
<!--#endif -->
=head2 parse_func_unbase64
Decode base64 encoded string, return truncated string if 0x00 is found.
Example:
<!--#if expr="unbase64('VG91cyBsZXMgw6p0cmVzIGh1bWFpbnMgbmFpc3NlbnQgbGlicmVzIGV0IMOpZ2F1eCBlbiBkaWduaXTDqSBldCBlbiBkcm9pdHMu') == 'Tous les êtres humains naissent libres et égaux en dignité et en droits.'" -->
This worked!
<!--#else -->
Nope, it failed.
<!--#endif -->
=head2 parse_func_unescape
Unescape %hex encoded string, leaving encoded slashes alone; return empty string if %00 is found.
Example:
<!--#if expr="unescape('https%3A%2F%2Fwww.example.com%2F') == 'https://www.example.com/'" -->
This worked!
<!--#else -->
Nope, it failed.
<!--#endif -->
=head2 parse_if
Parse the C<if> condition.
See L</parse_elif> above for example.
=head2 parse_include
Provided with an hash reference of parameters and this process the ssi directive C<include>, which is arguably the most used.
It will try to resolve the file to include by calling L</find_file> with the same arguments this is called with.
Under Apache, if the previous look up succeeded, it calls L<Apache2::SubRequest/run>
Outside of Apache, it reads the entire file, utf8 decode it and return it.
=head2 parse_perl
Provided with an hash reference of parameters and this parse some perl command and returns the output as a string.
Example:
<!--#perl sub="sub{ print 'Hello!' }" -->
or
<!--#perl sub="package::subroutine" -->
=head2 parse_printenv
This returns a list of environment variables sorted and their values.
=head2 parse_set
Provided with an hash reference of parameters and this process the ssi directive C<set>.
Possible parameters are:
=over 4
=item C<decoding>
The decoding of the variable before it is set. This can be C<none>, C<url>, C<urlencoded>, C<base64> or C<entity>
=item C<encoding>
This instruct to encode the variable value before display. It can the same possible value as for decoding.
=item C<value>
The string value for the variable to be set.
=item C<var>
The variable name
=back
Example:
<!--#set var="debug" value="2" -->
<!--#set decoding="entity" var="HUMAN_RIGHT" value="Tous les êtres humains naissent libres et égaux en dignité et en droits." encoding="urlencoded" -->
See the L<Apache SSI documentation|https://httpd.apache.org/docs/current/en/mod/mod_include.html> for more information.
=head2 parse_ssi
Provided with the html data as a string and this will parse its embedded ssi directives and return its output as a string.
If it fails, it sets an L</error> and returns an empty string.
=head2 path_info
Sets or gets the path info for the current uri.
lib/Apache2/SSI.pm view on Meta::CPAN
$ssi->query_string( $uri->query );
The query string value is set automatically when you provide an L<document_uri> upon instantiation or after:
$ssi->document_uri( '/some/path/to/file.html?q=something&l=ja_JP' );
This will also set automatically the C<QUERY_STRING> environment variable.
=head2 remote_ip
Sets or gets the remote ip address of the visitor.
Under Apache mod_perl, this will call L<Apache2::Connection/remote_ip> for version 2.2 or lower and will call L<Apache2::Connection/useragent_ip> for version above 2.2, and otherwise this will get the value from the environment variable C<REMOTE_ADDR...
This value can also be overriden by being provided during object instantiation.
# Pretend the ssi directives are accessed from this ip
$ssi->remote_ip( '192.168.2.20' );
This is useful when one wants to check how the rendering will be when accessed from certain ip addresses.
This is used primarily when there is an expression such as
<!--#if expr="-R '192.168.1.0/24' -->
Visitor is part of my private network
<!--#endif -->
or
<!--#if expr="v('REMOTE_ADDR') -R '192.168.1.0/24' -->
<!--#include file="/home/john/special_hidden_login_feature.html" -->
<!--#endif -->
L<Apache2::Connection> also has a L<Apache2::Connection/remote_addr> method, but this returns a L<APR::SockAddr> object that is used to get the binary version of the ip. However you can also get the string version like this:
use APR::SockAddr ();
my $ip = $r->connection->remote_addr->ip_get();
Versions above 2.2 make a distinction between ip from direct connection, or the real ip behind a proxy, i.e. L<Apache2::Connection/useragent_ip>
=head2 request_uri
This is an alias for L</document_uri>
=head2 server_version
Returns the server version as a L<version> object can caches that value.
Under mod_perl2, it uses L<Apache2::ServerUtil/get_server_description> and outside of mod_perl, it tries to find C<apxs> using L<File::Which> and in last resort, tries to find the C<apache2> or C<httpd> binary to get its version information.
=head2 sizefmt
Sets or gets the formatting for file sizes. Value can be either C<bytes> or C<abbrev>
=head2 timefmt
Sets or gets the formatting for date and time values. The format takes the same values as L<POSIX/strftime>
=head1 Encoding
At present time, the html data are treated as utf8 data and decoded and encoded back as such.
If there is a need to broaden support for other charsets, let me know.
=head1 SSI Directives
This is taken from Apache documentation and summarised here for convenience and clarity to the perl community.
=head2 config
<!--#config errmsg="Error occurred" sizefmt="abbrev" timefmt="%B %Y" -->
<!--#config errmsg="Oopsie" -->
<!--#config sizefmt="bytes" -->
# Thursday 24 December 2020
<!--#config timefmt="%A $d %B %Y" -->
=head2 echo
<!--#set var="HTMl_TITLE" value="Un sujet intéressant" -->
<!--#echo var="HTMl_TITLE" encoding="entity" -->
Encoding can be either C<entity>, C<url> or C<none>
=head2 exec
# pwd is "print working directory" in shell
<!--#exec cmd="pwd" -->
<!--#exec cgi="/uri/path/to/prog.cgi" -->
=head2 include
# Filesystem file path
<!--#include file="/home/john/var/quote_of_the_day.txt" -->
# Relative to the document root
<!--#include virtual="/footer.html" -->
=head2 flastmod
<!--#flastmod file="/home/john/var/quote_of_the_day.txt" -->
<!--#flastmod virtual="/copyright.html" -->
=head2 fsize
<!--#fsize file="/download/software-v1.2.tgz" -->
<!--#fsize virtual="/images/logo.jpg" -->
=head2 printenv
<!--#printenv -->
=head2 set
<!--#set var="debug" value="2" -->
=head2 if, elif, endif and else
<!--#if expr="$debug > 1" -->
I will print a lot of debugging
<!--#else -->
Debugging output will be reasonable
<!--#endif -->
( run in 1.234 second using v1.01-cache-2.11-cpan-39bf76dae61 )