IPv4 form provides a tool for making RIPE IPv4 request forms.

IPv4 form is a utility for checking the #ADDRESSING PLAN# part of a RIPE IPv4 PA request form. It makes a "totals:" row for this form and produces readable output with spaces between columns. This output can be directly copied to a RIPE form.

Quinti Secure Contact Form is a contact form for Web pages that is not vulnerable to robots who would abuse such forms for sending spam.
It uses both JavaScript field validators and CAPTCHA for verifying the validity of the sender. Quinti Secure Contact Form is easy to install and configure, and uses valid XHTML 1.1.
I have been attacked thousand times by spammers from my contact form, they use robots and take advantage of certain vulnerabilities of the mail forms to send their spam, and fill up my mailbox up to such an extent that they make your mail practically useless.
There are two ways of tackling this problem: Introducing a CAPTCHA validated through JavaScript, as i explain later.
And introducing certain functions in PHP that prevent these attacks, as you will see in the examples below
At the moment, go to the problem.
Main features:
- Invulnerable secure antispam contact form,
- JavaScript field validator in php (to insert multi-language variables and other variables, if you wish)
- Prevent spammers from using your form to send garbage, guaranteed.
- CAPTCHA to avoid Javascript validated Spam
- Easy to install and configure
- Valid XHTML 1.1

mod_form is a utility to decode data submitted from Web forms. It deals with both GET and POST methods where the data are encoded using the default content type application/x-www-form-urlencoded.

mod_form does not decode multipart/form-data (file upload) forms: for those you should use mod_upload.

Usage:

When mod_form is active, form data will be decoded to an apr_table_t*. Modules can access the table using the optional function form_data, or individual form fields using form_value:

#include "mod_form.h"

some_func(request_rec* r) {
apr_table_t* (*form_vars)(request_rec*) ;
apr_table_t* (*form_lookup)(request_rec*, const char*) ;
apr_table_t* form_data ;
const char* val ;
const char* key = "some-form-field" ;

/* get the whole table */
form_vars = APR_RETRIEVE_OPTIONAL_FN(form_data) ;
if ( form_vars ) {
form_data = form_vars(r) ;
}

/* or get individual values */
form_lookup = APR_RETRIEVE_OPTIONAL_FN(form_value) ;
if ( form_lookup ) {
val = form_lookup(r, key) ;
}
}

Contact Form Killer is a free tool you can use to generate contact forms for your site, or let your web site visitors add contact forms themselves.
Contact Form Killer script takes care of messy form validation with both JavaScript and PHP, just in case they have JavaScript disabled. The contact forms it generates are nicely formatted and can be further edited to match the look and feel of your site.
Main features:
- Easy to install. Just unzip and upload, or if youre using it on a local server, just unzip!
- Quick generation of contact forms that usually take hours to code.
- JavaScript validation of each input for ultimate usability.
- PHP validation to make sure JavaScript-disablers dont slip the radar.
- Over 10 inputs to pick and choose from.
- Form generation is really easy, just click the checkboxes next to the inputs you want, click submit and youre done!

phpForm provides a PHP3 application that allows you to easily create Web forms.

phpForm is a PHP3 script that allows you to easily create Web forms. It allows you to create, administer, preview, and log forms.

It also includes a simple function for including a form into a Web page.

openQRM Plug-ins is a collection of community-supported plug-ins that enable openQRM to manage other enterprise and open source software.
openQRM is designed to deal with all sorts of failures automatically, thus preventing interrupts because of unexpected events.
Implementing openQRM greatly improves the reliability of the x86 data-center.
openQRM is an open source systems management platform which integrates with existing components in enterprise data centers to create scalable, highly available and customizable infrastructures.
openQRM is derived from a proven commercial product and distributed as an open source project through SourceForge, using a modified Mozilla Public License.
openQRMs architecture extends to and embraces other existing data center technologies through "plug-ins."The openQRM project team has created a number of plug-ins for broadly-used open source projects and proprietary solutions, and seeks to recruit community members to assist in additional plug-ins.
openQRM leverages the proven technologies of PXE and NFS along with storing images on central storage to effectively manage the data center.
The project team aims to set the standard in data center management by continuing to provide a "premiere" enterprise-grade project for automating IT infrastructure, and by embracing other technologies through increasing our offering of plug-ins.
OpenQRM.org is the best destination for our projects community to share ideas and innovations. Contributed by Qlusters, openQRM.org offers a range of support and information services to benefit all users of openQRM, including implementation advice, user forums and customer feedback.
Enhancements:
- The plugin was ported to openQRM 3.1.3.
- Nagios now reloads its configuration once every 90 seconds if the configuration files were changed.
- Problems during multiple Nagios reloads were fixed.

Rose::HTML::Form is a HTML form base class.

SYNOPSIS

package PersonForm;

use Rose::HTML::Form;
our @ISA = qw(Rose::HTML::Form);

use Person;

sub build_form
{
my($self) = shift;

$self->add_fields
(
name => { type => text, size => 25, required => 1 },
email => { type => email, size => 50, required => 1 },
phone => { type => phone },
);
}

sub validate
{
my($self) = shift;

# Base class will validate individual fields in isolation,
# confirming that all required fields are filled in, and that
# the email address and phone number are formatted correctly.
my $ok = $self->SUPER::validate(@_);
return $ok unless($ok);

# Inter-field validation goes here
if($self->field(name)->internal_value ne John Doe &&
$self->field(phone)->internal_value =~ /^555/)
{
$self->error(Only John Doe can have a 555 phone number.);
return 0;
}

return 1;
}

sub init_with_person # give a friendlier name to a base-class method
{
my($self, $person) = @_;
$self->init_with_object($person);
}

sub person_from_form
{
my($self) = shift;

# Base class method does most of the work
my $person = $self->object_from_form(class => Person);

# Now fill in the non-obvious details...
# e.g., set alt phone to be the same as the regular phone
$person->alt_phone($self->field(phone)->internal_value);

return $person;
}

...

#
# Sample usage in a hypothetical web application
#

$form = PersonForm->new;

if(...)
{
# Get query parameters in a hash ref and pass to the form
my $params = MyWebServer->get_query_params();
$form->params($params);

# ...or initialize form params from a CGI object
# $form->params_from_cgi($cgi); # $cgi "isa" CGI

# ...or initialize params from an Apache request object
# (mod_perl 1 and 2 both supported)
# $form->params_from_apache($r);

# Initialize the fields based on params
$form->init_fields();

unless($form->validate)
{
return error_page(error => $form->error);
}

$person = $form->person_from_form; # $person is a Person object

do_something_with($person);
...
}
else
{
$person = ...; # Get or create a Person object somehow

# Initialize the form with the Person object
$form->init_with_person($person);

# Pass the initialized form object to the template
display_page(form => $form);
}
...

Rose::HTML::Form is more than just an object representation of the HTML tag. It is meant to be a base class for custom form classes that can be initialized with and return "rich" values such as objects, or collections of objects.

Building up a reusable library of form classes is extremely helpful when building large web applications with forms that may appear in many different places. Similar forms can inherit from a common subclass, and forms may be nested.

This class inherits from, and follows the conventions of, Rose::HTML::Object. Inherited methods that are not overridden will not be documented a second time here. See the Rose::HTML::Object documentation for more information.

CkFormLogin is a plug-in for the Nagios network monitoring system that makes it more useful in the context of secured Web sites (with login forms) and access management/single sign-on protected environments.
Originally developed to monitor Web applications that require authenticated access, it works by simulating an actual user login to verify each and every step in the process.
CkFormLogin can be used to continuously verify the "end-user" functionality of secured Web sites, detect outages in commercial access management products or externalized security plug-ins, and quickly verify security system stability after large configuration changes.
Main features:
- Continuously verify the "end-user" functionality of commercial access management products like Oracle COREid Access Manager, CA eTrust Siteminder, and Sun Access Manager
- Detect outages in secure websites caused by externalized security components or integration issues
- Quickly and easily verify system stability after large configuration changes
- Track uptime and availability for your critical access management integrations
- Immediately notify support personnel when a problem occurs
Enhancements:
- Initial release includes persistent/session cookie handling for complex login scenarios, automatic multi-step redirect handling, login page content validation, target page content validation, and optional verification of post-authentication target URLs.