Free cgi software for linux

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.

WebME is a really simple CMS with blog and podcasting support. WebMe can be used as FastCGI/CGI script or can be self-hosted as a ready-to-use Web server.

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

CGI-Shell provides a shell using CGI, so everyone who has a CGI directory on a Web server can also have a shell on it. It is something like telnet or SSH.
How to install?
make
make install (you have to be root)
How to uninstall?
make uninstall (you have to be root)
The server is distributed as binary - you can also compile it yourself with "make server", but its not recommendable.
Enhancements:
- PHP support (works not if system() call is disabled in PHP)
- configuration file
- bugfixes, little improvements

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.

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::WeT::Modules::Basic is a basic rendering engine extensions.

SYNOPSIS

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

This module provides basic rendering constructs for the engine. Please be aware that the code supersedes the documentation. While I have tried to be accurate there are times that words fail me and a look at the code is far more enlightening than anything I could cobble together. This is especially true when trying to write a theme. Download a theme and see how someone else did it. Then try making modifications and see what happens.