Free cgi entertainment software for linux

CGI::WeT::Theme is a Perl module with theme loader for the CGI::WeT package.

SYNOPSIS

use CGI::WeT::Theme ();

This module provides a well-defined interface between the rendering engine and the theme definition loaders. It is designed to work with or without mod_perl. All theme loader classes must be defined in the CGI::WeT::Theme::Loader namespace during the construction of a CGI::WeT::Theme object.

This module is used by the rendering engine and should not be needed outside of that engine. This documentation is to aid those building a theme loader.

All theme loaders need the following method defined:

factory(theme)

This will produce a properly blessed object which represents the definition for theme. If such an object can not be produced (theme not defined by that particular loader), this will return undef.
The object returned by the factory method must provide the following methods:

page_type(list)

This function will return an object representing the information needed to layout a page of the type in list. Since this is a list, the first item is most desired while the last is least desired. It will return the information for the best desired match it can find. If none can be returned, it must return undef.

The object returned by this function must provide LAYOUT and may provide BODY, CSS, and JAVASCRIPT. LAYOUT provides an anonymous array describing the layout of the page. BODY returns a hash reference describing various body attributes. BODY is deprecated in favor of CSS which returns a reference to an array with the Cascading Style Sheet to use for this layout. JAVASCRIPT returns a reference to an array with any JavaScript required for this layout.

CGIFeed is a CGI program that reads news feeds (via XML/RDF/RSS) and prepares HTML pages for them.

You can enter new feeds through the Web page, and edit the name and update interval for each feed.

CGI::Portable is a framework for server-generic web apps.

SYNOPSIS

Content of thin shell "startup_cgi.pl" for CGI or Apache::Registry env:

#!/usr/bin/perl
use strict;
use warnings;

require CGI::Portable;
my $globals = CGI::Portable->new();

use Cwd;
$globals->file_path_root( cwd() ); # let us default to current working directory
$globals->file_path_delimiter( $^O=~/Mac/i ? ":" : $^O=~/Win/i ? "" : "/" );

$globals->set_prefs( config.pl );
$globals->current_user_path_level( 1 );

require CGI::Portable::AdapterCGI;
my $io = CGI::Portable::AdapterCGI->new();

$io->fetch_user_input( $globals );
$globals->call_component( DemoAardvark );
$io->send_user_output( $globals );

1;

Content of thin shell "startup_socket.pl" for IO::Socket::INET:

#!/usr/bin/perl
use strict;
use warnings;

print "[Server $0 starting up]n";

require CGI::Portable;
my $globals = CGI::Portable->new();

use Cwd;
$globals->file_path_root( cwd() ); # let us default to current working directory
$globals->file_path_delimiter( $^O=~/Mac/i ? ":" : $^O=~/Win/i ? "" : "/" );

$globals->set_prefs( config.pl );
$globals->current_user_path_level( 1 );

require CGI::Portable::AdapterSocket;
my $io = CGI::Portable::AdapterSocket->new();

use IO::Socket;
my $server = IO::Socket::INET->new(
Listen => SOMAXCONN,
LocalAddr => 127.0.0.1,
LocalPort => 1984,
Proto => tcp
);
die "[Error: cant setup server $0]" unless $server;

print "[Server $0 accepting clients]n";

while( my $client = $server->accept() ) {
printf "%s: [Connect from %s]n", scalar localtime, $client->peerhost;

my $content = $globals->make_new_context();

$io->fetch_user_input( $content, $client );
$content->call_component( DemoAardvark );
$io->send_user_output( $content, $client );

close $client;

printf "%s http://%s:%s%s %sn", $content->request_method,
$content->server_domain, $content->server_port,
$content->user_path_string, $content->http_status_code;
}

1;

^The CGI::Portable class is a framework intended to support complex web applications that are easily portable across servers because common environment-specific details are abstracted away, including the file system type, the web server type, and your projects location in the file system or uri hierarchy.

Also abstracted away are details related to how users of your applications arrange instance config/preferences data across single or multiple files, so they get more flexability in how to use your application without you writing the code to support it. So your apps are easier to make data-controlled.

Application cores would use CGI::Portable as an interface to the server they are running under, where they receive user input through it and they return a response (HTML page or other data type) to the user through it. Since CGI::Portable should be able to express all of their user input or output needs, your application cores should run well under CGI or mod_perl or IIS or a Perl-based server or a command line without having code that supports each types individual needs.

That said, CGI::Portable doesnt contain any user input/output code of its own, but allows you to use whatever platform-specific code or modules you wish between it and the actual server. By using my module as an abstraction layer, your own program core doesnt need to know which platform-specific code it is talking to.

As a logical extension to the interfacing functionality, CGI::Portable makes it easier for you to divide your application into autonomous components, each of which acts like it is its own application core with user input and instance config data provided to it and a recepticle for its user output provided. This module would be an interface between the components.

This class has 5 main types of functionality, or sets of properties that exist in parallel but are fully/mostly independant from each other. As such, it could conceptually be split into 5 physical modules, some of which could be used on their own, but they are actually contained in this one module for simplicity of use (just one object for user code to keep track of). The 5 functionality sets could be called: Errors, Files, Request, Response, Misc.

CGI::Enurl.pm is a Perl module for URL-encoding strings and hashes.

SYNOPSIS

use CGI::Enurl;
%hash = (name=>Jenda Krynicky,address=>Nerudova 1016);
print "Location: http://$ENV{SERVER_NAME}/cgi-bin/do.pl?",enurl %hash,"nn";

This is a little module made for CGI scripting. It encodes the parameters to be passed to a CGI. It does nothing more, so its much smaller and loads more quickly.

Functions

enurl STRING
enurl ARRAY
enurl HASH

Encodes the parameter. If the parameter is a single string it encodes it and returns the encoded form.

If it is an array or a reference to an array it encodes all items and returns them joined by &.

If it is a hash it encodes the values and return a querystring in form "key2=encoded_value1&key2=encoded_value2&...".

!!! Please note that a hash in a list context returns a list of all keys and values. This means that if you call enurl(%hash) you will NOT get what you may thing you should. You HAVE to use enurl(%hash) !!!

enURL STRING

Encodes the parameter, this version doesnt encode = and & characters, so you should make sure they are not present in the data.

Notice the difference :

enurl a&b=f o o => a%26b%3Df+o+o
enURL a&b=f o o => a&b=f+o+o

$CGI::Enurl::ParamSeparator

You may specify another character to be used as the parameter separator. Simply set this variable to the character (or string) you want to use.
The default value is &

$CGI::Enurl::KeepUnencoded

This variable contains the characters that should stay unencoded. Please keep in mind that the string will be interpolated into a regexp in a [^...] group!

Any change of this variable will be ignored after the first call to enurl or enURL. (Im using /o switch in the regexp.) So if you want to change the variable you should do it as soon as posible. You may do that even before you "use" the module!

The default value is a-zA-Z 0-9_-@.=

CGI::Expand is a Perl module that can convert flat hash to nested data using TT2s dot convention.

SYNOPSIS

use CGI::Expand;
use CGI; # or Apache::Request, etc.

$args = expand_cgi( CGI->new(a.0=3&a.2=4&b.c.0=x) );
# $args = { a => [3,undef,4], b => { c => [x] }, }

# Or to catch exceptions:
eval {
$args = expand_cgi( CGI->new(a.0=3&a.2=4&b.c.0=x) );
} or log_and_exit( $@ );

#-----
use CGI::Expand qw(expand_hash);

$args = expand_hash({a.0=>77}); # $args = { a => [ 77 ] }

Converts a CGI query into structured data using a dotted name convention similar to TT2.

expand_cgi works with CGI.pm, Apache::Request or anything with an appropriate "param" method. Or you can use expand_hash directly.

If you prefer to use a different flattening convention then CGI::Expand can be subclassed.

CGI::AppBuilder::Frame is a configuration initializer.

SYNOPSIS

use CGI::AppBuilder::Frame;

my $ab = CGI::AppBuilder::Frame- >new(
ifn, my_init.cfg, opt, vhS:a:);
my ($q, $ar, $ar_log) = $ab- >start_app($0, %ARGV);
print $ab- >disp_form($q, $ar);

This class provides methods for reading and parsing configuration files.
new (ifn = > file.cfg, opt = > hvS:)

This is a inherited method from CGI::AppBuilder. See the same method in CGI::AppBuilder for more details.

frame_set ($fr, $pr)

Input variables:

$fr - frame set definiton array reference. The $fr contains two
elements [$hr, $ar]:
$hr - a hash ref containing the frame set attributes
$ar - a array ref containing hash references defining each
frames in the frame set.
$pr - tag attribute array ref. It contains three elements:
class - CSS class name
attr - attribute string such as width=5 onChange=js_func
hr - hash ref with key and value pairs. This will be obtained
from $fr for each frame set and frame.
pretty - whether to add line breaks

Variables used or methods called:

CGI::AppBuilder::Table
html_tag - generate HTML tags
CGI::AppBuilder::Message
echo_msg - display message

How to use:

The following shows how to define the frame array ($fr):

+-+----+ The following defines the left layout:
| | T |
| +----+ [{cols= >"150,*"},[
| | | {src= >"left.htm",name= >"L"},
|L| C | [{rows= >"100,*,50"},[
| | | {src= >"top.htm",name= >"T"},
| |----| {src= >"main.htm",name= >"C"},
| | B | {src= >"bottom.htm",name= >"B"}]]]
+-+----+ ]

In YAML, here is how it looks like:

---
cols: 150,*
- src: left.htm
name: L
- rows: 100,*,50
- src: top.htm
name: T
- src: main.htm
name: C
- src: bottom.htm
name: B
...

+-+------+ The following defines the left layout:
| | T |
| +----+-+ [{cols= >"150,*"},[
| | | | {src= >"left.htm",name= >"L"},
|L| C |R| [{rows= >"100,*,50"},[
| | | | {src= >"top.htm",name= >"T"},
| | | | [{cols= >"*,100"},[
| |----+-+ {src= >"main.htm",name= >"C"},
| | | {src= >"right.htm",name= >"R"}] ] ],
| | B | {src= >"bottom.htm",name= >"B"}]]
+-+----+-+ ]
In YAML, here is how it looks like:
---
cols: 150,*
- src: left.htm
name: L
- rows: 100,*,50
- src: top.htm
name: T
- cols: *,100
- src: main.htm
name: C
- src: right.htm
name: R
- src: bottom.htm
name: B
...
Here is the testing codes:
my $fr = [{cols= >"150,*"},[
{src= >"left.htm",name= >"L"},
[{rows= >"100,*,50"},[
{src= >"top.htm",name= >"T"},
{src= >"main.htm",name= >"C"},
{src= >"bottom.htm",name= >"B"}]
]]
];
my $pr = {pretty= >1};
print $obj- >frame_set($fr,$pr);
# the following is the result:

< FRAMESET cols=150,* >
< FRAME src=left.htm name=L >
< FRAMESET rows=100,*,50 >
< FRAME src=top.htm name=T >
< FRAME src=main.htm name=C >
< FRAME src=bottom.htm name=B >
< / FRAMESET >
< / FRAMESET >

$pr- >{_frameset_count} = 0; # reset frame set counter
my $f2 = [ {cols= >"150,*"},[
{src= >"left.htm",name= >"L"},
[{rows= >"100,*,50"},[
{src= >"top.htm",name= >"T"},
[{cols= >"*,100"},[
{src= >"main.htm",name= >"C"},
{src= >"right.htm",name= >"R"}]
],
{src= >"bottom.htm",name= >"B"}]
]]
];
print $obj- >frame_set($f2,$pr);
# the following is the result:

< FRAMESET cols=150,* >
< FRAME src=left.htm name=L >
< FRAMESET rows=100,*,50 >
< FRAME src=top.htm name=T >
< FRAMESET cols=*,100 >
< FRAME src=main.htm name=C >
< FRAME src=right.htm name=R >
< / FRAMESET >
< FRAME src=bottom.htm name=B >
< / FRAMESET >
< / FRAMESET >

Return: HTML codes.

This method generates HTML codes based on the information provided. This method is also called < I >frameset< / I >.

CGI::WeT::Modules::News are Perl extensions to engine to allow article management.

SYNOPSIS

use CGI::WeT::Modules::News ();

This module provides rendering constructs to allow navigation through a set of articles. Support is provided for multiple types of articles in multiple groupings (or channels).

EXTENSIONS

CGI::WeT::Modules::News::initialize($engine, $r)

This subroutine will initialize the engine passed as $engine with information from Apache (passed as $r). The base URL for articles is set with the following.

PerlSetVar WeT_NewsURL /baseURL/

This is available for building URLs as @@NEWS@@. For example, general articles are under the URL returned by

$engine->url(@@NEWS@@/general/);

The directory may likewise be found by using

$engine->filename($engine->url(@@NEWS@@/general/));

NEWS_SUMMARY

This extension will insert a summary of available news items starting with the most recent (ordered by submission time). The top of the content stack is applied to each item as a template.

The template used is called with four elements on the content stack: Title, Date, Author, and Summary (Title on top of stack). The available arguments for controlling NEWS_SUMMARY are

channel

This argument specifies which channel to collect items from. This defaults to `general.

category

This argument specifies which category to collect items from. Only one category may be specified at this time. There is no way to block items marked as `all. The default category is `all.

link

If this is set to `title, the title will be made a link. No other value has an effect.

number

This tells NEWS_SUMMARY how many items to put in the list. There is no default for this argument, so one must be supplied.

NEWS_NEXT

This extension is like CGI::WeT::Modules::Basics LINK in that the top of the content stack is made into a link. The location is determined by the values of the arguments.

channel

See NEWS_SUMMARY

type

This can be either `story or `response. If `story, then the articles in the top level are looked at. Otherwise, the articles in the current directory are examined.

sequence

This can be either `next or `prev.

CGI::Simple is a simple totally OO CGI interface that is CGI.pm compliant.

SYNOPSIS

use CGI::Simple;
$CGI::Simple::POST_MAX = 1024; # max upload via post default 100kB
$CGI::Simple::DISABLE_UPLOADS = 0; # enable uploads

$q = new CGI::Simple;
$q = new CGI::Simple( { foo=>1, bar=>[2,3,4] } );
$q = new CGI::Simple( foo=1&bar=2&bar=3&bar=4 );
$q = new CGI::Simple( *FILEHANDLE );

$q->save( *FILEHANDLE ); # save current object to a file as used by new

@params = $q->param; # return all param names as a list
$value = $q->param(foo); # return the first value supplied for foo
@values = $q->param(foo); # return all values supplied for foo

%fields = $q->Vars; # returns untied key value pair hash
$hash_ref = $q->Vars; # or as a hash ref
%fields = $q->Vars("|"); # packs multiple values with "|" rather than " ";

@keywords = $q->keywords; # return all keywords as a list

$q->param( foo, some, new, values ); # set new foo values
$q->param( -name=>foo, -value=>bar );
$q->param( -name=>foo, -value=>[bar,baz] );

$q->param( foo, some, new, values ); # append values to foo
$q->append( -name=>foo, -value=>bar );
$q->append( -name=>foo, -value=>[some, new, values] );

$q->delete(foo); # delete param foo and all its values
$q->delete_all; # delete everything



$files = $q->upload() # number of files uploaded
@files = $q->upload(); # names of all uploaded files
$filename = $q->param(upload_file) # filename of uploaded file
$mime = $q->upload_info($filename,mime); # MIME type of uploaded file
$size = $q->upload_info($filename,size); # size of uploaded file

my $fh = $q->upload($filename); # get filehandle to read from
while ( read( $fh, $buffer, 1024 ) ) { ... }

# short and sweet upload
$ok = $q->upload( $q->param(upload_file), /path/to/write/file.name );
print "Uploaded ".$q->param(upload_file)." and wrote it OK!" if $ok;

$decoded = $q->url_decode($encoded);
$encoded = $q->url_encode($unencoded);
$escaped = $q->escapeHTML("&);
$unescaped = $q->unescapeHTML("&);

$qs = $q->query_string; # get all data in $q as a query string OK for GET

$q->no_cache(1); # set Pragma: no-cache + expires
print $q->header(); # print a simple header
# get a complex header
$header = $q->header( -type => image/gif
-nph => 1,
-status => 402 Payment required,
-expires =>+24h,
-cookie => $cookie,
-charset => utf-7,
-attachment => foo.gif,
-Cost => $2.00
);
# a p3p header (OK for redirect use as well)
$header = $q->header( -p3p => policyref="http://somesite.com/P3P/PolicyReferences.xml );

@cookies = $q->cookie(); # get names of all available cookies
$value = $q->cookie(foo) # get first value of cookie foo
@value = $q->cookie(foo) # get all values of cookie foo
# get a cookie formatted for header() method
$cookie = $q->cookie( -name => Password,
-values => [superuser,god,my dog woofie],
-expires => +3d,
-domain => .nowhere.com,
-path => /cgi-bin/database,
-secure => 1
);
print $q->header( -cookie=>$cookie ); # set cookie

print $q->redirect(http://go.away.now); # print a redirect header

dienice( $q->cgi_error ) if $q->cgi_error;

CGI::Simple provides a relatively lightweight drop in replacement for CGI.pm. It shares an identical OO interface to CGI.pm for parameter parsing, file upload, cookie handling and header generation. This module is entirely object oriented, however a complete functional interface is available by using the CGI::Simple::Standard module.

Essentially everything in CGI.pm that relates to the CGI (not HTML) side of things is available. There are even a few new methods and additions to old ones! If you are interested in what has gone on under the hood see the Compatibility with CGI.pm section at the end.

In practical testing this module loads and runs about twice as fast as CGI.pm depending on the precise task.