cgi houston
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 586
cgi-postin 1.19
cgi-postin utility processes data generated from a World-Wide Web form. more>> <<less
Download (0.006MB)
Added: 2006-11-20 License: GPL (GNU General Public License) Price:
1068 downloads
CGI::NoPoison 3.11
CGI::NoPoison is No Poison Null Byte in CGI->Vars. more>>
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.
<<lessSYNOPSIS
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.
Download (0.012MB)
Added: 2006-12-01 License: Perl Artistic License Price:
1059 downloads
CGI::Request 2.0b1
CGI::Request is a parse client request via a CGI interface. more>>
CGI::Request is a parse client request via a CGI interface.
SYNOPSIS
use CGI::Request;
# Simple interface: (combines SendHeaders, new and import_names)
$req = GetRequest($pkg);
print FmtRequest(); # same as: print $req->as_string
# Full Interface:
$req = new CGI::Request; # fetch and parse request
$field_value = $req->param(FieldName);
@selected = $req->param(SelectMultiField);
@keywords = $req->keywords; # from ISINDEX
print $req->as_string; # format Form and CGI variables
# import form fields into a package as perl variables!
$req->import_names(R);
print "$R::FieldName";
print "@R::SelectMultiField";
@value = $req->param_or($fieldname, $default_return_value);
# Access to CGI interface (see CGI::Base)
$cgi_obj = $req->cgi;
$cgi_var = $req->cgi->var("REMOTE_ADDR");
# Other Functions:
CGI::Request::Interface($cgi); # specify alternative CGI
CGI::Request::Debug($level); # log to STDERR (see CGI::Base)
# Cgi-lib compatibility functions
# use CGI::Request qw(:DEFAULT :cgi-lib); to import them
&ReadParse(*input);
&MethGet;
&PrintHeader;
&PrintVariables(%input);
This module implements the CGI::Request object. This object represents a single query / request / submission from a WWW user. The CGI::Request class understands the concept of HTML forms and fields, specifically how to parse a CGI QUERY_STRING.
<<lessSYNOPSIS
use CGI::Request;
# Simple interface: (combines SendHeaders, new and import_names)
$req = GetRequest($pkg);
print FmtRequest(); # same as: print $req->as_string
# Full Interface:
$req = new CGI::Request; # fetch and parse request
$field_value = $req->param(FieldName);
@selected = $req->param(SelectMultiField);
@keywords = $req->keywords; # from ISINDEX
print $req->as_string; # format Form and CGI variables
# import form fields into a package as perl variables!
$req->import_names(R);
print "$R::FieldName";
print "@R::SelectMultiField";
@value = $req->param_or($fieldname, $default_return_value);
# Access to CGI interface (see CGI::Base)
$cgi_obj = $req->cgi;
$cgi_var = $req->cgi->var("REMOTE_ADDR");
# Other Functions:
CGI::Request::Interface($cgi); # specify alternative CGI
CGI::Request::Debug($level); # log to STDERR (see CGI::Base)
# Cgi-lib compatibility functions
# use CGI::Request qw(:DEFAULT :cgi-lib); to import them
&ReadParse(*input);
&MethGet;
&PrintHeader;
&PrintVariables(%input);
This module implements the CGI::Request object. This object represents a single query / request / submission from a WWW user. The CGI::Request class understands the concept of HTML forms and fields, specifically how to parse a CGI QUERY_STRING.
Download (0.12MB)
Added: 2006-10-21 License: Perl Artistic License Price:
1099 downloads
CGI::Out 2006.0215
CGI::Out is a Perl module to buffer output when building CGI programs. more>>
CGI::Out is a Perl module to buffer output when building CGI programs.
SYNOPSIS
use CGI;
use CGI::Out;
$query = new CGI;
savequery $query; # to reconstruct input
$CGI::Out::mailto = fred; # override default of $<
out $query->header();
out $query->start_html(
-title=>A test,
-author=>muir@idiom.com);
croak "Were outta here!";
confess "It was my fault: $!";
carp "It was your fault!";
warn "Im confused";
die "Im dying.n";
use CGI::Out qw(carpout $out);
carpout(*LOG);
$CGI::Out::out # is the buffer
This is a helper routine for building CGI programs. It buffers stdout until youre completed building your output. If you should get an error before you are finished, then it will display a nice error message (in HTML), log the error, and send email about the problem.
It wraps all of the functions provided by CGI::Carp and Carp. Do not "use" them directly, instead just "use CGI::Out".
Instead of print, use out.
<<lessSYNOPSIS
use CGI;
use CGI::Out;
$query = new CGI;
savequery $query; # to reconstruct input
$CGI::Out::mailto = fred; # override default of $<
out $query->header();
out $query->start_html(
-title=>A test,
-author=>muir@idiom.com);
croak "Were outta here!";
confess "It was my fault: $!";
carp "It was your fault!";
warn "Im confused";
die "Im dying.n";
use CGI::Out qw(carpout $out);
carpout(*LOG);
$CGI::Out::out # is the buffer
This is a helper routine for building CGI programs. It buffers stdout until youre completed building your output. If you should get an error before you are finished, then it will display a nice error message (in HTML), log the error, and send email about the problem.
It wraps all of the functions provided by CGI::Carp and Carp. Do not "use" them directly, instead just "use CGI::Out".
Instead of print, use out.
Download (0.004MB)
Added: 2006-08-30 License: Perl Artistic License Price:
1151 downloads
CGI++ 0.8
CGI++ - C++ macro pre-processor that facilitates development of CGI/Database applications in C++. more>>
CGI++ is a C++ macro pre-processor that facilitates development of CGI/Database applications in C++. It will also process your HTML and generate form parsing classes with appropriate constructors.
Many desirable features are yet to be implemented, but you can use what is already available to speed up your C++ CGI/Database development by quite a bit. Feel free to send feature requests or bug reports.
If you would like to contribute to the CGI++ project, your efforts will be appreciated. The areas where I need most help are documentation and testing, especially documentation. I hate writing it, because Id rather be writing code but it needs to be done.
Installation:
You will need a C++ compiler with STL support to build and use CGI++. A clean compile is guaranteed on Linux and GNU 2.7, others still need to be tested, but you are free to give it a try. Installation is simple:
gunzip -c cgi++-0.8.tar.gz | tar xvf -
cd cgi++-0.8.tar.gz
./configure
make
su (if needed)
make install
<<lessMany desirable features are yet to be implemented, but you can use what is already available to speed up your C++ CGI/Database development by quite a bit. Feel free to send feature requests or bug reports.
If you would like to contribute to the CGI++ project, your efforts will be appreciated. The areas where I need most help are documentation and testing, especially documentation. I hate writing it, because Id rather be writing code but it needs to be done.
Installation:
You will need a C++ compiler with STL support to build and use CGI++. A clean compile is guaranteed on Linux and GNU 2.7, others still need to be tested, but you are free to give it a try. Installation is simple:
gunzip -c cgi++-0.8.tar.gz | tar xvf -
cd cgi++-0.8.tar.gz
./configure
make
su (if needed)
make install
Download (0.090MB)
Added: 2006-05-24 License: Freeware Price:
1250 downloads
CGI::kSession 0.5.3
CGI::kSession is a sessions manager for CGI. more>>
CGI::kSession is a sessions manager for CGI.
This module can be used anywhere you need sessions. As a session management module, it uses files with a configurable lifetime to handle your session data. For those of you familiar with PHP, you will notice that the session syntax is a little bit similar.
METHODS
The following public methods are availible:
$s = new CGI::kSession();
The constructor, this starts the ball rolling. It can take the following hash-style parameters:
lifetime - how long the session lasts, in seconds
path - the directory where you want to store your session files
id - if you want to give the session a non-random name, use this parameter as well
$s->start();
This creates a session or resumes an old one (could be used in conjunction with something like HTTP::Cookie). This will return 1 if this is a new session, and 0 if its resuming an old one. If you defined no values in the new() call, then the session will start with a default lifetime of 600 seconds, a path of /var/tmp, and a random string for an id.
$s->save_path();
Save the session path or, without an argument, return the current session path. Used with an argument, this performs the same thing as the path parameter in the constructor.
$s->id();
If the session id exists, this will return the current session id - useful if you want to maintain state with a cookie! If you pass a parameter, it acts the same as new( id => some_session_name), i.e., it creates a session with that id.
$s->register();
This takes a string as an arguement and basically tells the session object this: "Hey, this is a variable Im thinking about associating with some data down the road. Hang onto it for me, and Ill let you know what Im going to do with it". Once you register a variable name here, you can use it in set() and get().
$s->is_registered();
Check to see if the function is registered. Returns 1 for true, 0 for false.
$s->unregister();
Tell the session jinn that you no longer want to use this variable, and it can go back in the bottle (the variable, not the jinn... you still want the jinn around until you call destroy()).
$s->set();
This is where you actually define your variables (once you have "reserved" them using register()). This method takes two arguments: the first is the name of the variable that you registerd, and the second is the info you want to store in the variable.
$s->get();
This method allows you to access the data that you have saved in a session - just pass it the name of the variable that you set().
$s->unset();
Calling this method will wipe all the variables stored in your session.
$s->destroy();
This method deletes the session file, destroys all the evidence, and skips bail.
Enhancements:
- updated the documentation
<<lessThis module can be used anywhere you need sessions. As a session management module, it uses files with a configurable lifetime to handle your session data. For those of you familiar with PHP, you will notice that the session syntax is a little bit similar.
METHODS
The following public methods are availible:
$s = new CGI::kSession();
The constructor, this starts the ball rolling. It can take the following hash-style parameters:
lifetime - how long the session lasts, in seconds
path - the directory where you want to store your session files
id - if you want to give the session a non-random name, use this parameter as well
$s->start();
This creates a session or resumes an old one (could be used in conjunction with something like HTTP::Cookie). This will return 1 if this is a new session, and 0 if its resuming an old one. If you defined no values in the new() call, then the session will start with a default lifetime of 600 seconds, a path of /var/tmp, and a random string for an id.
$s->save_path();
Save the session path or, without an argument, return the current session path. Used with an argument, this performs the same thing as the path parameter in the constructor.
$s->id();
If the session id exists, this will return the current session id - useful if you want to maintain state with a cookie! If you pass a parameter, it acts the same as new( id => some_session_name), i.e., it creates a session with that id.
$s->register();
This takes a string as an arguement and basically tells the session object this: "Hey, this is a variable Im thinking about associating with some data down the road. Hang onto it for me, and Ill let you know what Im going to do with it". Once you register a variable name here, you can use it in set() and get().
$s->is_registered();
Check to see if the function is registered. Returns 1 for true, 0 for false.
$s->unregister();
Tell the session jinn that you no longer want to use this variable, and it can go back in the bottle (the variable, not the jinn... you still want the jinn around until you call destroy()).
$s->set();
This is where you actually define your variables (once you have "reserved" them using register()). This method takes two arguments: the first is the name of the variable that you registerd, and the second is the info you want to store in the variable.
$s->get();
This method allows you to access the data that you have saved in a session - just pass it the name of the variable that you set().
$s->unset();
Calling this method will wipe all the variables stored in your session.
$s->destroy();
This method deletes the session file, destroys all the evidence, and skips bail.
Enhancements:
- updated the documentation
Download (0.004MB)
Added: 2007-07-17 License: Perl Artistic License Price:
831 downloads
CGI::Utils 0.09
CGI::Utils is a Perl module for retrieving information through the Common Gateway Interface and mod_perl. more>>
CGI::Utils is a Perl module for retrieving information through the Common Gateway Interface and mod_perl.
Enhancements:
- This release adds support for mod_perl 2 in addition to mod_perl 1.
- It fixes some formatting issues with the POD documentation and adds underscore versions of more methods.
<<lessEnhancements:
- This release adds support for mod_perl 2 in addition to mod_perl 1.
- It fixes some formatting issues with the POD documentation and adds underscore versions of more methods.
Download (0.020MB)
Added: 2006-06-28 License: Perl Artistic License Price:
1214 downloads
CGI::Test 0.104
CGI::Test is a CGI regression test framework. more>>
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.
<<lessSYNOPSIS
# 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.
Download (0.050MB)
Added: 2007-06-12 License: Perl Artistic License Price:
864 downloads
CGI::SecureState 0.36
CGI::SecureState is a transparent, secure statefulness for CGI programs. more>>
CGI::SecureState is a transparent, secure statefulness for CGI programs.
SYNOPSIS
use CGI::SecureState;
my @memory = qw(param1 param2 other_params_to_remember);
my $cgi = new CGI::SecureState(-stateDir => "states",
-mindSet => forgetful,
-memory => @memory);
print $cgi->header(), $cgi->start_html;
my $url = $cgi->state_url();
my $param = $cgi->state_param();
print I am a stateful CGI session.";
printI am a different ",
"script that also has access to this session.quot;;
Very Important Note for Users of CGI::SecureState 0.2x
For those still using the 0.2x series, CGI::SecureState changed enormously between 0.26 and 0.30. Specifically, the addition of mindsets is so important that if you run your old scripts unchanged under CGI::SecureState 0.3x, you will receive nasty warnings (likely both in output web pages and your log files) that will tell you not to do so. Please do yourself a favor by re-reading this documentation, as this mysterious mindset business (as well as all the scrumptious new features) will be made clear.
Of course, any and all comments on the changes are welcome. If you are interested, send mail to behroozi@cpan.org with the subject "CGI::SecureState Comment".
A Better Solution to the stateless problem.
HTTP is by nature a stateless protocol; as soon as the requested object is delivered, HTTP severs the objects connection to the client. HTTP retains no memory of the request details and does not relate subsequent requests with what it has already served.
There are a few methods available to deal with this problem, including forms and cookies, but most have problems themselves, including security issues (cookie stealing), browser support (cookie blocking), and painful implementations (forms).
CGI::SecureState solves this problem by storing session data in an encrypted state file on the server. CGI::SecureState is similar in purpose to CGI::Persistent (and retains much of the same user interface) but has a completely different implementation. For those of you who have worked with CGI::Persistent before, you will be pleased to learn that CGI::SecureState was designed to work with Perls taint mode and has worked flawlessly with mod_perl and Apache::Registry for over two years. CGI::SecureState was also designed from the ground up for security, a fact which may rear its ugly head if anybody tries to do something tricksy.
<<lessSYNOPSIS
use CGI::SecureState;
my @memory = qw(param1 param2 other_params_to_remember);
my $cgi = new CGI::SecureState(-stateDir => "states",
-mindSet => forgetful,
-memory => @memory);
print $cgi->header(), $cgi->start_html;
my $url = $cgi->state_url();
my $param = $cgi->state_param();
print I am a stateful CGI session.";
printI am a different ",
"script that also has access to this session.quot;;
Very Important Note for Users of CGI::SecureState 0.2x
For those still using the 0.2x series, CGI::SecureState changed enormously between 0.26 and 0.30. Specifically, the addition of mindsets is so important that if you run your old scripts unchanged under CGI::SecureState 0.3x, you will receive nasty warnings (likely both in output web pages and your log files) that will tell you not to do so. Please do yourself a favor by re-reading this documentation, as this mysterious mindset business (as well as all the scrumptious new features) will be made clear.
Of course, any and all comments on the changes are welcome. If you are interested, send mail to behroozi@cpan.org with the subject "CGI::SecureState Comment".
A Better Solution to the stateless problem.
HTTP is by nature a stateless protocol; as soon as the requested object is delivered, HTTP severs the objects connection to the client. HTTP retains no memory of the request details and does not relate subsequent requests with what it has already served.
There are a few methods available to deal with this problem, including forms and cookies, but most have problems themselves, including security issues (cookie stealing), browser support (cookie blocking), and painful implementations (forms).
CGI::SecureState solves this problem by storing session data in an encrypted state file on the server. CGI::SecureState is similar in purpose to CGI::Persistent (and retains much of the same user interface) but has a completely different implementation. For those of you who have worked with CGI::Persistent before, you will be pleased to learn that CGI::SecureState was designed to work with Perls taint mode and has worked flawlessly with mod_perl and Apache::Registry for over two years. CGI::SecureState was also designed from the ground up for security, a fact which may rear its ugly head if anybody tries to do something tricksy.
Download (0.020MB)
Added: 2007-07-16 License: Perl Artistic License Price:
831 downloads
CGI::Application 4.06
CGI::Application is a framework for building reusable web-applications. more>>
CGI::Application is a framework for building reusable web-applications.
SYNOPSIS
# In "WebApp.pm"...
package WebApp;
use base CGI::Application;
# ( setup() can even be skipped for common cases. See docs below. )
sub setup {
my $self = shift;
$self->start_mode(mode1);
$self->mode_param(rm);
$self->run_modes(
mode1 => do_stuff,
mode2 => do_more_stuff,
mode3 => do_something_else
);
}
sub do_stuff { ... }
sub do_more_stuff { ... }
sub do_something_else { ... }
1;
### In "webapp.cgi"...
use WebApp;
my $webapp = WebApp->new();
$webapp->run();
CGI::Application is intended to make it easier to create sophisticated, high-performance, reusable web-based applications. This module implements a methodology which, if followed, will make your web software easier to design, easier to document, easier to write, and easier to evolve.
CGI::Application judiciously avoids employing technologies and techniques which would bind a developer to any one set of tools, operating system or web server.
<<lessSYNOPSIS
# In "WebApp.pm"...
package WebApp;
use base CGI::Application;
# ( setup() can even be skipped for common cases. See docs below. )
sub setup {
my $self = shift;
$self->start_mode(mode1);
$self->mode_param(rm);
$self->run_modes(
mode1 => do_stuff,
mode2 => do_more_stuff,
mode3 => do_something_else
);
}
sub do_stuff { ... }
sub do_more_stuff { ... }
sub do_something_else { ... }
1;
### In "webapp.cgi"...
use WebApp;
my $webapp = WebApp->new();
$webapp->run();
CGI::Application is intended to make it easier to create sophisticated, high-performance, reusable web-based applications. This module implements a methodology which, if followed, will make your web software easier to design, easier to document, easier to write, and easier to evolve.
CGI::Application judiciously avoids employing technologies and techniques which would bind a developer to any one set of tools, operating system or web server.
Download (0.054MB)
Added: 2006-09-02 License: Perl Artistic License Price:
1147 downloads
Nmap-cgi 1.0
Nmap-cgi is a web-portscanner that use nmap to make his scans. more>>
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
<<lessMain 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
Download (0.33MB)
Added: 2006-08-22 License: BSD License Price:
1158 downloads
CGI_Lite 1.8
CGI_Lite is a Perl module to process and decode WWW forms and cookies. more>>
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);
<<lessSYNOPSIS
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);
Download (0.014MB)
Added: 2007-05-09 License: Perl Artistic License Price:
899 downloads
CGI::Portable 0.51
CGI::Portable is a framework for server-generic web apps. more>>
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.
<<lessSYNOPSIS
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.
Download (0.093MB)
Added: 2006-08-01 License: Perl Artistic License Price:
1182 downloads
CGI::Ex::Conf 2.06
CGI::Ex::Conf is a Perl module with Conf Reader/Writer for many different data format types. more>>
CGI::Ex::Conf is a Perl module with Conf Reader/Writer for many different data format types.
SYNOPSIS
use CGI::Ex::Conf qw(conf_read conf_write);
my $hash = conf_read("/tmp/foo.yaml");
conf_write("/tmp/foo.yaml", {key1 => $val1, key2 => $val2});
### OOP interface
my $cob = CGI::Ex::Conf->new;
my $full_path_to_file = "/tmp/foo.val"; # supports ini, sto, val, pl, xml
my $hash = $cob->read($file);
local $cob->{default_ext} = conf; # default anyway
my @paths = qw(/tmp, /home/pauls);
local $cob->{paths} = @paths;
my $hash = $cob->read(My::NameSpace);
# will look in /tmp/My/NameSpace.conf and /home/pauls/My/NameSpace.conf
my $hash = $cob->read(My::NameSpace, {paths => [/tmp]});
# will look in /tmp/My/NameSpace.conf
local $cob->{directive} = MERGE;
my $hash = $cob->read(FooSpace);
# OR #
my $hash = $cob->read(FooSpace, {directive => MERGE});
# will return merged hashes from /tmp/FooSpace.conf and /home/pauls/FooSpace.conf
# immutable keys are preserved from originating files
local $cob->{directive} = FIRST;
my $hash = $cob->read(FooSpace);
# will return values from first found file in the path.
local $cob->{directive} = LAST; # default behavior
my $hash = $cob->read(FooSpace);
# will return values from last found file in the path.
### manipulate $hash
$cob->write(FooSpace); # will write it out the changes
There are half a million Conf readers out there. Why not add one more. Actually, this module provides a wrapper around the many file formats and the config modules that can handle them. It does not introduce any formats of its own.
This module also provides a preload ability which is useful in conjunction with mod_perl.
<<lessSYNOPSIS
use CGI::Ex::Conf qw(conf_read conf_write);
my $hash = conf_read("/tmp/foo.yaml");
conf_write("/tmp/foo.yaml", {key1 => $val1, key2 => $val2});
### OOP interface
my $cob = CGI::Ex::Conf->new;
my $full_path_to_file = "/tmp/foo.val"; # supports ini, sto, val, pl, xml
my $hash = $cob->read($file);
local $cob->{default_ext} = conf; # default anyway
my @paths = qw(/tmp, /home/pauls);
local $cob->{paths} = @paths;
my $hash = $cob->read(My::NameSpace);
# will look in /tmp/My/NameSpace.conf and /home/pauls/My/NameSpace.conf
my $hash = $cob->read(My::NameSpace, {paths => [/tmp]});
# will look in /tmp/My/NameSpace.conf
local $cob->{directive} = MERGE;
my $hash = $cob->read(FooSpace);
# OR #
my $hash = $cob->read(FooSpace, {directive => MERGE});
# will return merged hashes from /tmp/FooSpace.conf and /home/pauls/FooSpace.conf
# immutable keys are preserved from originating files
local $cob->{directive} = FIRST;
my $hash = $cob->read(FooSpace);
# will return values from first found file in the path.
local $cob->{directive} = LAST; # default behavior
my $hash = $cob->read(FooSpace);
# will return values from last found file in the path.
### manipulate $hash
$cob->write(FooSpace); # will write it out the changes
There are half a million Conf readers out there. Why not add one more. Actually, this module provides a wrapper around the many file formats and the config modules that can handle them. It does not introduce any formats of its own.
This module also provides a preload ability which is useful in conjunction with mod_perl.
Download (0.21MB)
Added: 2006-10-07 License: Perl Artistic License Price:
1113 downloads
CGI::WML 0.09
CGI::WML is a Perl module with subclass LDSs CGI.pm for WML output and WML methods. more>>
CGI::WML is a Perl module with subclass LDSs "CGI.pm" for WML output and WML methods.
SYNOPSIS
use CGI::WML;
$query = new CGI::WML;
$content = $query->p("Hello WAP world");
print
$query->header(),
$query->start_wml(),
$query->template(-content=>$query->prev()),
$query->card(-id=>"first_card",
-title=>"First card",
-content=>$content),
$query->end_wml();
print
$query->wml_to_wmlc(-wml=>$wml_buffer,
-errorcontext=>2);
($page_title,$content) = $query->html_to_wml($buffer);
This is a library of perl functions to allow CGI.pm-style programming to be applied to WAP/WML. Since this is a subclass of Lincoln Steins CGI.pm all the normal CGI.pm methods are available. See perldoc CGI if you are not familiar with CGI.pm
<<lessSYNOPSIS
use CGI::WML;
$query = new CGI::WML;
$content = $query->p("Hello WAP world");
$query->header(),
$query->start_wml(),
$query->template(-content=>$query->prev()),
$query->card(-id=>"first_card",
-title=>"First card",
-content=>$content),
$query->end_wml();
$query->wml_to_wmlc(-wml=>$wml_buffer,
-errorcontext=>2);
($page_title,$content) = $query->html_to_wml($buffer);
This is a library of perl functions to allow CGI.pm-style programming to be applied to WAP/WML. Since this is a subclass of Lincoln Steins CGI.pm all the normal CGI.pm methods are available. See perldoc CGI if you are not familiar with CGI.pm
Download (0.021MB)
Added: 2007-07-12 License: Perl Artistic License Price:
838 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above cgi houston search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
