Free cgi movies software for linux

CGI_Lite is a Perl module to process and decode WWW forms and cookies.

SYNOPSIS

use CGI_Lite;

$cgi = new CGI_Lite;

$cgi->set_platform ($platform);

where $platform can be one of (case insensitive):
Unix, Windows, Windows95, DOS, NT, PC, Mac or Macintosh

$cgi->set_file_type (handle or file);
$cgi->add_timestamp (0, 1 or 2);

where 0 = no timestamp
1 = timestamp all files (default)
2 = timestamp only if file exists

$cgi->filter_filename (⊂routine);

$size = $cgi->set_buffer_size ($some_buffer_size);

$status = $cgi->set_directory (/some/dir);
$cgi->set_directory (/some/dir) || die "Directory doesnt exist.n";

$cgi->close_all_files;

$cgi->add_mime_type (application/mac-binhex40);
$status = $cgi->remove_mime_type (application/mac-binhex40);
@list = $cgi->get_mime_types;

$form = $cgi->parse_form_data;
%form = $cgi->parse_form_data;

or

$form = $cgi->parse_form_data (GET, HEAD or POST);

$cookies = $cgi->parse_cookies;
%cookies = $cgi->parse_cookies;

$status = $cgi->is_error;
$message = $cgi->get_error_message;

$cgi->return_error (error 1, error 2, ...);

$keys = $cgi->get_ordered_keys;
@keys = $cgi->get_ordered_keys;

$cgi->print_data;

$cgi->print_form_data; (deprecated as of v1.8)
$cgi->print_cookie_data; (deprecated as of v1.8)

$new_string = $cgi->wrap_textarea ($string, $length);

@all_values = $cgi->get_multiple_values ($reference);

$cgi->create_variables (%form);
$cgi->create_variables ($form);

$escaped_string = browser_escape ($string);

$encoded_string = url_encode ($string);
$decoded_string = url_decode ($string);

$status = is_dangerous ($string);
$safe_string = escape_dangerous_chars ($string);

CGI::NoPoison is No Poison Null Byte in CGI->Vars.

SYNOPSIS

use CGI;
use CGI::NoPoison

my $m = CGI->new();
$m->param(
-name=>amplifier,
-value=>[nine, ten, up to eleven],
);
my %h = $m->Vars();
# look ma, no splitting on poison null-bytes ( )!
print "$_ => ", join ", ", @{$h{$_}} for keys %h;

print "This one goes ", ($m->param(amplifier))[2];

Simplicity itself. Instead of using a null-byte to separate multi-valued fields why not just use what CGI.pm already uses to store the values internally?

"Whats that?", you ask? Why, its an anonymous array, of course, like anyone sensible would use. cgi-lib.pl may have been fine years and years ago, but this now-archaic throwback no longer needs us to bow to its demands. (is anyone still actually using it? yikes.)

This does, however change how you parse CGI->Vars() (as an anon-array, not a -packed string) and also how you set params.

NOW you can properly test for inserted null-bytes in a secure environment WHILE taking advantage of the convenience of the Vars() function.

CGI::Validate is an advanced CGI form parser and type validation.

SYNOPSIS

use CGI::Validate; # GetFormData() only
use CGI::Validate qw(:standard); # Normal use
use CGI::Validate qw(:subs); # Just functions
use CGI::Validate qw(:vars); # Just exception vars

## If you dont want it to check that every requested
## element arrived you can use this. But I dont recommend it
## for most users.
$CGI::Validate::Complete = 0;

## If you dont care that some fields in the form dont
## actually match what you asked for. -I dont recommend
## this unless you REALLY know what youre doing because this
## normally meens youve got typos in your HTML and we cant
## catch them if you set this.
## $CGI::Validate::IgnoreNonMatchingFields = 1;

my $FieldOne = Default String;
my $FieldTwo = 8;
my $FieldThree = some default string;
my @FieldFour = (); ## For multi-select field
my @FieldFive = (); ## Ditto
my $EmailAddress= ;

## Try...
my $Query = GetFormData (
FieldOne=s => $FieldOne, ## Required string
FieldTwo=i => $FieldTwo, ## Required int
FieldThree => $FieldThree, ## Auto converted to the ":s" type
FieldFour=s => @FieldFour, ## Multi-select field of strings
FieldFive=f => @FieldFive, ## Multi-select field of floats
Email=e => $EmailAddress, ## Must look like an email address
) or do {
## Catch... (wouldnt you just love a case statement here?)
if (%Missing) {
die "Missing form elements: " . join ( , keys %Missing);
} elsif (%Invalid) {
die "Invalid form elements: " . join ( , keys %Invalid);
} elsif (%Blank) {
die "Blank form elements: " . join ( , keys %Blank);
} elsif (%InvalidType) {
die "Invalid data types for fields: " . join ( , keys %InvalidType);
} else {
die "GetFormData() exception: $CGI::Validate::Error";
}
};

## If you only want to check the form data, but dont want to
## have CGI::Validate set anything use this. -You still have full
## access to the data via the normal B object that is returned.

use CGI::Validate qw(CheckFormData); # not exported by default
my $Query = CheckFormData (
FieldOne=s, FieldTwo=i, FieldThree, FieldFour,
FieldFive, Email,
) or do {
... Same exceptions available as GetFormData above ...
};

## Need some of your own validation code to be used? Here is how you do it.
addExtensions (
myType => sub { $_[0] =~ /test/ },
fooBar => &fooBar,
i_modify_the_actual_data => sub {
if ($_[0] =~ /test/) { ## data validation
$_[0] = whatever; ## modify the data by alias
return 1;
} else {
return 0;
}
},
);
my $Query = GetFormData (
foo=xmyType => $foo,
bar=xfooBar => $bar,
cat=xi_modify_the_actual_data => $cat,
);


## Builtin data type checks available are:
s string # Any non-zero length value
w word # Must have at least one w char
i integer # Integer value
f float # Float value
e email # Must match m/^s*]+@[^@.]+(?:.[^@.]+)+>?s*$/
x extension # User extension type. See EXTENSIONS below.

Basicly a blending of the CGI and Getopt::Long modules, and requires the CGI module to function.

The basic concept of this module is to combine the best features of the CGI and Getopt::Long modules. The CGI module is great for parsing, building, and rebuilding forms, however it lacks any real error checking abilitys such as misspelled form input names, the data types received from them, missing values, etc. This however, is something that the Getopt::Long module is vary good at doing. So, basicly this module is a layer that collects the data using the CGI module and passes it to routines to do type validation and name consistency checks all in one clean try/catch style block.

The syntax of GetFormData() is mostly the same as the GetOptions() of Getopt::Long, with a few exceptions (namely, the handling of exceptions) . See the VALUE TYPES section for detail of the available types, and the EXCEPTIONS section for exception handling options. If given without a type, fields are assumed to be type ":s" (optional string), which is normally correct.
If successful, GetFormData() returns the CGI object that it used to parse the data incase you want to use it for anything else, and undef otherwise.

If you only want to do value type and name validation, use CheckFormData() instead with a field=type list. -See the SYNOPSIS for an example.

CGI::Test is a CGI regression test framework.

SYNOPSIS

# In some t/script.t regression test, for instance
use CGI::Test; # exports ok()

my $ct = CGI::Test->new(
-base_url => "http://some.server:1234/cgi-bin",
-cgi_dir => "/path/to/cgi-bin",
);

my $page = $ct->GET("http://some.server:1234/cgi-bin/script?arg=1");
ok 1, $page->content_type =~ m|text/htmlb|;

my $form = $page->forms->[0];
ok 2, $form->action eq "/cgi-bin/some_target";

my $menu = $form->menu_by_name("months");
ok 3, $menu->is_selected("January");
ok 4, !$menu->is_selected("March");
ok 5, $menu->multiple;

my $send = $form->submit_by_name("send_form");
ok 6, defined $send;

#
# Now interact with the CGI
#

$menu->select("March"); # "click" on the March label
my $answer = $send->press; # "click" on the send button
ok 7, $answer->is_ok; # and make sure we dont get an HTTP error

The CGI::Test module provides a CGI regression test framework which allows you to run your CGI programs offline, i.e. outside a web server, and interact with them programmatically, without the need to type data and click from a web browser.

If youre using the CGI module, you may be familiar with its offline testing mode. However, this mode is appropriate for simple things, and there is no support for conducting a full session with a stateful script. CGI::Test fills this gap by providing the necessary infrastructure to run CGI scripts, then parse the output to construct objects that can be queried, and on which you can interact to "play" with the scripts control widgets, finally submitting data back. And so on...
Note that the CGI scripts you can test with CGI::Test need not be implemented in Perl at all. As far as this framework is concerned, CGI scripts are executables that are run on a CGI-like environment and which produce an output.

To use the CGI::Test framework, you need to configure a CGI::Test object to act like a web server, by providing the URL base where CGI scripts lie on this pseudo-server, and which physical directory corresponds to that URL base.
From then on, you may issue GET and POST requests giving an URL, and the pseudo-server returns a CGI::Test::Page object representing the outcome of the request. This page may be an error, plain text, some binary data, or an HTML page (see CGI::Test::Page for details).

The latter (an HTML page) can contain one or more CGI forms (identified by tags), which are described by instances of CGI::Test::Form objects (see CGI::Test::Form for details).

Forms can be queried to see whether they contain a particular type of widget (menu, text area, button, etc...), of a particular name (thats the CGI parameter name). Once found, one may interact with a widget as the user would from a browser. Widgets are described by polymorphic objects which conform to the CGI::Test::Form::Widget type. The specific interaction that is offered depends on the dynamic type of the object (see CGI::Test::Form::Widget for details).

An interaction with a form ends by a submission of the form data to the server, and getting a reply back. This is done by pressing a submit button, and the press() routine returns a new page. Naturally, no server is contacted at all within the CGI::Test framework, and the CGI script is ran through a proper call to one of the GET/POST method on the CGI::Test object.

Finally, since CGI::Test is meant to be used from regression test scripts, it exports a single ok() routine which merely prints the messages expected by Test::Harness. This is the only functional routine in this module, all other accesses being made through a CGI::Test object.

CGI::XMLForm is a Perl extension of CGI.pm which reads/generates formated XML. NB: This is a subclass of CGI.pm, so can be used in its place.

SYNOPSIS

use CGI::XMLForm;

my $cgi = new CGI::XMLForm;

if ($cgi->param) {
print $cgi->header, $cgi->pre($cgi->escapeHTML($cgi->toXML));
}
else {
open(FILE, "test.xml") or die "Cant open: $!";
my @queries = (/a, /a/b*, /a/b/c*, /a/d);
print $cgi->header,
$cgi->pre($cgi->escapeHTML(
join "n", $cgi->readXML(*FILE, @queries)));
}

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.

Nmap-cgi is a web-portscanner that use nmap to make his scans. Nmap-cgi is written in Perl and run on *nix machines. Initially made during the SoC program, this project was developped by the Nmap project
Main features:
- Separate privileges and rights into groups
- Many rights for each nmap option
- Three type of scans : single, scheduled and periodic
- The scan-output is available in a text and xml file (with XSLT stylesheet)
- OS detection
- Support TCP and UDP
- Scan an IP address, a hostname or a subnet