Free http class software for linux

DB_cart Class is a MySQL shopping cart script that can be used with third party product catalogues and membership systems. The MySQL database structure is neutral to existing systems.
DB_cart Class can handle the shopping cart (add, update, and empty) and checkout process (set the shipment address and email the order).
For existing cart users, the shopping cart is still available upon the users next visit and is visible by checkout. The last option is configurable togther with a time period.
Enhancements:
- There are modifications and improvements inside the main class file, several examples, and the table structure has been extended.
- There two additional fields for the shipment values (name2 and address2).
- All messages are available in German, English, and Dutch.
- The standard text inside the email messages is in external files now; this content is parsed inside the improved email method.

lns.http is a simple framework for writing Common Lisp web applications. The project handles the incoming connections, parses HTTP headers and queries, and finally hands control over to your URL handler.

lns.http is a HTTP/1.1 compatible web server but tries to achieve compatibility with lesser (down to the informal HTTP/0.9) clients.

The lns.http web server uses lisp-network-server to take care of network handling.

This software is licensed unter the LGPL.

WebServerInfo PHP class is intended for developer who create software that will run
on different web servers. The project gives a developer a consistent interface
for accessing web servers variables.

Usage:

You have following options:

Option #1
require_once("WebServerInfo.class.php");
$obj = new WebServerInfo();
print $_SERVER[DOCUMENT_ROOT];

Option #2
require_once("WebServerInfo.class.php");
$obj = new WebServerInfo();
print $obj->get(DOCUMENT_ROOT);

Option #3
uncomment the 3rd line from WebServerInfo.class.php
and all you have to do is require the WebServerInfo.class.php class.

Note:
The constructor of WebServerInfo class overrides $_SERVER variable and
variables can be accessed as usual way.


Following base variables are exported if they do not exist.

REQUEST_URI
REDIRECT_URL
DOCUMENT_ROOT
SERVER_SIGNATURE
SERVER_ADDR
SCRIPT_FILENAME

Class::CGI is a Perl module to fetch objects from your CGI object.

SYNOPSIS

use Class::CGI
handlers => {
customer_id => My::Customer::Handler
};

my $cgi = Class::CGI->new;
my $customer = $cgi->param(customer_id);
my $name = $customer->name;
my $email = $cgi->param(email); # behaves like normal

if ( my %errors = $cgi->errors ) {
# do error handling
}

For small CGI scripts, its common to get a parameter, untaint it, pass it to an object constructor and get the object back. This module would allow one to to build Class::CGI handler classes which take the parameter value, automatically perform those steps and just return the object. Much grunt work goes away and you can get back to merely pretending to work.

IAM OPML Parser Class parses an OPML file (provided its URL) and returns an array.

OPML (Outline Processor Markup Language) is an XML format for outlines. Originally developed by Radio UserLand as a native file format for an outliner application, it has since been adopted for other uses, the most common being to exchange lists of web feeds (RSS) between web feed aggregators. The OPML specification defines an outline as a hierarchical, ordered list of arbitrary elements. The specification is fairly open which makes it suitable for many types of list data.

The XML elements in an OPML document are:

< opml version=”1.0″ > This is the root element. It must contain the version attribute and one head and one body element. Currently, there’s active work in OML 2.0, which is mainly aimed at solving some of v1.o’s shortcomings.

< head > Contains metadata. May include any of these optional elements: title, dateCreated, dateModified, ownerName, ownerEmail, expansionState, vertScrollState, windowTop, windowLeft, windowBottom, windowRight. Each element is a simple text element. dateCreated and dateModified contents conform to the date-time format specified in RFC 822. expansionState contains a comma-separated list of line numbers that should be expanded o and size of the display window. An OPML processor may ignore all the head sub-elements. If the outline is opened inside another outline then the processor must ignore the window elements.

< body > Contains the content of the outline. Must have one or more outline elements.

< outline > Represents a line in the outline. May contain any number of arbitrary attributes. Common attributes include text and type. The outline element may contain any number of outline sub-elements. While there are many tools to create and/or read OPML files, there are few PHP libraries/functions to work with these files.

This PHP class parses an OPML file (provided its URL) and returns an array with all the parsed data. This array contains, for each of the OPML file’s elements the following attributes: link_url, link_name, link_target, link_description, link_rss, created (date of creation), type (link type: RSS, HTML, etc.). The class uses file_get_contents() to retrieve the contents of the OPML file and then the XML extension is used to parse and store the file’s data in an associative array, where each outline element is stored using a different array index. The array has the following structure:

0 : Array:
{
names => Preface
urls => http://www.php.net/manual/en/preface.php
targets =>
feeds =>
descriptions =>
created => Nov 28 2005 21:05:49 GMT
type => link
}
1 : Array:
{
names => I. Getting started
urls =>
targets =>
feeds =>
descriptions =>
created =>
type =>
}

HTTP::GetImages is a spider to recover and store images from web pages.

SYNOPSIS

use HTTP::GetImages;

$_ = new HTTP::GetImages (
dir => .,
todo => [http://www.google.com/,],
dont => [http://www.somewhere/ignorethis.html,http://and.this.html],
chat => 1,
);

$_->print_imgs;
$_->print_done;
$_->print_failed;
$_->print_ignored;

my $hash = $_->imgs_as_hash;
foreach (keys %{$hash}){
warn "$_ = ",$hash->{$_},"n";
}

exit;

This module allow syou to automate the searching, recovery and local storage of images from the web, including those linked by anchor (A), mage (IMG) and image map (AREA) elements.

Supply a URI or list of URIs to process, and HTTP::GetImages will recurse over every link it finds, searching for images.

By supplying a list of URIs, you can restrict the search to certain webservers and directories, or exclude it from certain webservers and directories.

You can also decide to reject images that are too small or too large.

EasyHTTPD is a drop in C++ class to implement an HTTP 1.0 Server - Now with OpenSSL Support! The class can be used to allow an application to be controlled by a browser, hence Embedded.
To this functionality to an app, add the C++ class to the application, write and register request callback handlers with the class, and call the parser with a connected socket.
The parser will extract any options passed in the URL, extract POST values, and call the desired handler.
The handler get a pointer to the application via void ptr, has haccess to the extracted options and POST values, and then write the desired output back to the socket.
For easy dynamic page generate, an HTML template file can be used, and the handler simply specifies token tags in the template to be replace with the dynamic values (aka search and replace )
HOW TO USE IN YOUR APPLICATION:
These classes use the STL (Standard Template Library), so your enviroment must have the STL available.
Add the embedhttp.cpp file to your project, and the embedhttp.h file to the file(s) in your project that handles incomming socket connections.
See the sample1.cpp and helloworld.cpp files to get an idea of how to use these classes.
Enhancements:
- Removed regex as a dependency. Regex library is no longer needed.
- Added member functions to do the following:
o Get the client headers
o Send headers back to the client
o Specify alternate socket send/recv functions to support use with OpenSSL
o Specify a pre-request handler, a handler that can be called for all requests before the specifc request handler get called
- Fixed bug in helloworld_template.html.
- Fixed bug in parse which occured when the client did not send any headers.
- Added hello world sample using OpenSSL.
- Added the wiki: http://www.littletux.com/wiki

Class::Std is a Perl module to support for creating standard "inside-out" classes.

SYNOPSIS

package MyClass;
use Class::Std;

# Create storage for object attributes...
my %name : ATTR;
my %rank : ATTR;
my %snum : ATTR;

my %public_data : ATTR;

# Handle initialization of objects of this class...
sub BUILD {
my ($self, $obj_ID, $arg_ref) = @_;

$name{$obj_ID} = check_name( $arg_ref->{name} );
$rank{$obj_ID} = check_rank( $arg_ref->{rank} );
$snum{$obj_ID} = _gen_uniq_serial_num();
}

# Handle cleanup of objects of this class...
sub DEMOLISH {
my ($self, $obj_ID) = @_;

_recycle_serial_num( $snum{$obj_ID} );
}

# Handle unknown method calls...
sub AUTOMETHOD {
my ($self, $obj_ID, @other_args) = @_;

# Return any public data...
if ( m/A get_(.*)/ ) { # Method name passed in $_
my $get_what = $1;
return sub {
return $public_data{$obj_ID}{$get_what};
}
}

warn "Cant call $method_name on ", ref $self, " object";

return; # The call is declined by not returning a sub ref
}

This module provides tools that help to implement the "inside out object" class structure in a convenient and standard way.