Free cgi ams software for linux

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

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

Mon.cgi is a CGI interface for viewing the status of a Mon service.
mon is a general-purpose scheduler and alert management tool used for monitoring service availability and triggering alerts upon failure detection. mon was designed to be open and extensible in the sense that it supports arbitrary monitoring facilities and alert methods via a common interface, all of which are easily implemented with programs in C, Perl, shell, etc., SNMP traps, and special mon traps.
mon views resource monitoring as two separate tasks: the testing of a condition, and triggering an action upon failure. mon was designed to implement the testing and action-taking tasks as separate, stand-alone programs. mon is fundamentally a scheduler which executes the monitors (each test a specific condition), and calls the appropriate alerts if the monitor fails. The decision to invoke an alert is governed by logic which offers various "squelch" features and dependencies, all of which are configurable by the user.
Monitors and alerts are not a part of the core mon server, even though the distribution comes with a handful of them to get you started. This means that if a new service needs monitoring, or if a new alert is necessary, the mon server does not need to be changed. This makes mon easily extensible.
That is from Jim Trocki who wrote mon, Im currently maintaining a web interface that works with mon which was based from Arthur K. Chans original mon.cgi.
Enhancements:
- This is the initial release of the Mon Web Interface (MWI), which is the progression of the mon.cgi Web interface.
- This interface is written entirely from scratch, with full CSS and HTML W3C complacency.
- This is an alpha release: the back end code is based on the mon.cgi tree, but the interface will have features that are currently unusable.

CGI:IRC is a Perl/CGI program that allows you to use IRC from a Web browser without having to have access to an IRC port.

CGI:IRC does not use Java, but it does need a browser capable of rendering frames. It can be used on a Web page to allow users to chat, or it can be used to access chat from behind a firewall.

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

cgipplib is a small collection of support classes used to build CGI applications.

Using C++

Using object oriented features in C++ such as inheritance makes developing a cgi program fast and reliable.

This document will try to describe the cgi++ method of developing a dynamic website.

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