Free cgi bin software for linux

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::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.

Psunami Bulletin Board is an Open Source alternative to the popular Ultimate Bulletin Board software, and aims for speed, ease of use, and a full feature set.

For installation, do the following:

1)Recursively copy everything from ./cgi-bin/ into your servers cgi-bin/ directory.

2)Recursively chown (chown -R) the psunami/ directory to the user that your web server uses (www-data on Debian, nobody on Slack, httpd on RHat-based systems (Ive been told that it is nobody on someRHat systems), wwwrun on SuSE. Anyone know what it is for others?) If you are unable to chown (eg. you are not the superuser) then make sure it is all readable/writable by the user (777 works, but is probably much too generous). Also do this to the psunami.conf file in cgi-bin.

3)Make psunami.cgi, psunami_admin.cgi, and psunami_moderate.cgi executable by the user that your web server uses. (chmod u+x *.cgi)

4)Change the paths to your perl executable if necessary. The paths are at the top of psunami.cgi, psunami_moderate.pl, and psunami_admin.cgi and default to /usr/bin/perl. Type which perl at a command prompt if you dont know where the executable is.

5)Run psunami_admin.cgi and create a new board. The initial login is psunami and the password is bulletin (no quotes).

6)Make sure that your mail program is configured properly in the preferences. It defaults to /usr/bin/sendmail.

7)Once you have created an account for yourself and given it admin rights, make sure you delete the psunami user.

CGI::Wiki::Kwiki is an instant wiki built on CGI::Wiki.

A simple-to-use front-end to CGI::Wiki. It can be used for several purposes: to migrate from a CGI::Kwiki wiki (its original purpose), to provide a quickly set up wiki that can later be extended to use more of CGI::Wikis capabilities, and so on. It uses the Template Toolkit to allow quick and easy customisation of your wikis look without you needing to dive into the code.

INSTALLATION

The distribution ships with and installs a script called cgi-wiki-kwiki-install. Create an empty directory somewhere that your web server can see, and run the script. It will set up a SQLite database, install the default templates into the current directory, and create a cgi script to run the wiki. You now have a wiki - edit wiki.cgi to change any of the default options, and youre done.

MORE DETAILS

wiki.cgi will look something like this:

#!/usr/bin/perl -w
use strict;
use warnings;
use CGI;
use CGI::Wiki::Kwiki;

my %config = (
db_type => SQLite,
db_name => /home/wiki/data/node.db,
formatters => {
default => CGI::Wiki::Formatter::Default,
},
);

my %vars = CGI::Vars();
eval {
CGI::Wiki::Kwiki->new(%config)->run(%vars);
};

if ($@) {
print "Content-type: text/plainnn";
print "There was a problem with CGI::Wiki::Kwiki:nn--n";
print "$@";
print "n--n";
print STDERR $@;
}

In the following directions, we use "webserver" to mean the user that your webserver executes CGI scripts as. Often this is actually you yourself; sometimes it is "www-data" or "apache". If you dont know, ask your ISP.
In the script above and in the following, replace /home/wiki/data/node.db with a filename in a directory that you will be able to make readable and writeable by the webserver. SQLite requires access to both the file (for writing data) and the directory it resides in (for creating a lockfile).

The Data Mine is a search engine designed to give users an unusually powerful interface. It is designed around human-computer intelligent interaction (making the computer a tool so humans can use their intelligence).

The project divides the screen into two halves: one lets you find all the instances of your querys keywords, and the other lets you look through a highlighted version of the results you choose.

Installation:

Basics

To install, run "./install" and answer the questions provided. This will run a Unix-flavor install-style script and should create a working, out-of-the-box installation when supplied appropriate values.

See USAGE below if are curions about how to use the Data Mine.

Setup and Customization

The Configure link at the bottom of the Data Mine search page provides a menu you can use to customize the data mine.

The main engine is intended for anyone to be able to use; the setup pages are written for techies. If you arent sure what a regular expression is, for instance, ask someone whos more technical.

Security

The present release of the Data Mine has not been closely scrutinized for security, and should be treated as such by security-conscious administrators. If you discover a vulnerability, please contact the author.

You are strongly encouraged to change the password in /usr/share/datamine/password.

The default installation sets /usr/share/datamine and contents to a relatively permissive mode. Administrators are encouraged to set directory and contents to mode 700, owned by the effective user ID that CGI scripts will be running under. This is usually apache or nobody.

Usage:

The Data Mine is designed to be run as a straightforward web application, with much administrative activity performed on-web.

Once it is set up via the Configure link, just explore.

http://[your hostname]/cgi-bin/datamine

(That is the location provided by RPM installation and the default for the provided installer. The provided installer allows you to specify another location; if you specified another location, substitute that for "/cgi-bin/furball".)