Free interface to software for linux

X Interface Monitor (abbriviated xifmon) monitors any network interface (most suitable, the ppp# interface) for traffic, load average, and various other statistics using purly ioctl() directly to the Linux kernel.

It also has options to run `connect and `disconnect scripts, for dialup modem users who want easy connecting and disconnecting.

Class::Interfaces is a Per module for defining interface classes inline.

SYNOPSIS

# define some simple interfaces
use Class::Interfaces (
Serializable => [ pack, unpack ],
Printable => [ toString ],
Iterable => [ iterator ],
Iterator => [ hasNext, next ]
);

# or some more complex ones ...

# interface can also inherit from
# other interfaces using this form
use Class::Interfaces (
BiDirectionalIterator => {
isa => Iterator,
methods => [ hasPrev, prev ]
},
ResetableIterator => {
isa => Iterator,
methods => [ reset ]
},
# we even support multiple inheritance
ResetableBiDirectionalIterator => {
isa => [ ResetableIterator, BiDirectionalIterator ]
}
);

# it is also possible to create an
# empty interface, sometimes called
# a marker interface
use Class::Interfaces (
JustAMarker => undef
);

This module provides a simple means to define abstract class interfaces, which can be used to program using the concepts of interface polymorphism.

VIDeo Interface for *niX (VIDIX) is a portable interface to userspace drivers to provide DGA everywhere possible. VIDIX is portable interface which was designed and introduced as interface to userspace drivers to provide DGA everywhere where its possible.
Enhancements:
- warnings suppressing
- fixes and improvements
- Win32 related improvements
- h/w revision detection for cle266 chipset
- support for Geforce FX5500
- added vt8378 chipset as unichrome driver

Perlbug::Interface::Web is a web interface to perlbug database.

SYNOPSIS

my $o_web = Perlbug::Interface::Web->new;

print $o_web->top;

print $o_web->request(help);

print $o_web->links;

METHODS

new

Create new Perlbug::Interface::Web object.
my $web = Perlbug::Interface::Web->new;

setup

Setup Perlbug::Interface::Web
$o_web->setup($cgi);

check_user

Access authentication via http, we just prime ourselves with data from the db as well.

menus

Return menu of system, designed for vertical format. Wraps logo, title and links

print $o_web->menus();

logo

Return logo of system with href=hard_wired_url

print $o_web->logo();

get_title

Return title of current page

print $o_web->get_title();

summary

Return summary of open/closed bugs

print $o_web->summary();

links

Return links of system, with adminfaq inserted if appropriate, configured links and object search forms.

print $o_web->links();

index

Display the index results here...

get_request

Return the req value for this request

my $req = $self->get_request;

set_command

Set the command type for the rest of the process, based on the input and operation

my $cmd = $o_web->set_command($req);

commands

Return command menu buttons for request given

print $o_web->commands($req);

switch

Return appropriate method call for request(else index), using internal CGI object

my $method = $o_web->switch([$req]); # set $method=($call|index)

start

Return appropriate start header data for web request, includes start table.

print $o_web->start();

form

Return form with appropriate name and target etc.

print $o_web->form(menus);

top

Return consistent top of page.

print $o_web->top($req, $cmd);

request

Handle all web requests (internal print)

$o_web->request($call);

target2file

Return appropriate dir/file.ext for given target string

my $filename = $o_base->target2file(header);

# -> /home/richard/web/header.html

finish

Return appropriate finishing html
Varies with framed, includes table finish

print $o_web->finish($req);

overview

Wrapper for doo method

graph

Display pie or mixed graph for groups of bugs etc., mixed to come.

date

Wrapper for search by date access

create

Wrapper for object creation

$o_web->create($obj, %data);

object_handler

Wrapper for object access: no ids = search form

$o_web->object_handler($me_thod, $oid); # o_cgi comes from the heavens

hist

History mechanism for bugs and users.

Move formatting to Formatter::history !!!

headers

Headers for all objects (message, note, ...) by id

$o_web->headers(patch, $id);

bidmid

Wrapper for bugid and messageid access

spec

Returns specifications for the Perlbug system.

$dynamic =~ s/ />/g;
$dynamic =~ s/b(http:.+?perlbug.cgi)b/$1/gi;
$dynamic =~ s/b([ |&.t;]+@.+?.(?:com|org|net|edu))b/$1/gi;

webhelp

Web based help for perlbug.

print $web->webhelp;

mailhelp

Web based mail help for perlbug.

print $web->mailhelp;

delete

Wrapper for delete access

sql

Open field sql query processor

todo

To do list, may be appended to

adminfaq

adminFAQ

web_query

Form bugid search web query results

# results - dont map to query() unless Base::query modified

search

Construct search form

with chosen params as defaults...

update

For all application objects, wraps to object_handler

$o_web->update(); # args ignored here for passing purposes

current_buttons

Get and set array of relevant buttons by context key

my @buttons = $o_web->current_buttons(search update reset, scalar(@uids), [$colspan]);

case

Handle case sensitivity from web search form.

format_query

Produce SQL query for bug search from cgi query.

Can be optimised somewhat ...

my $query = $web->format_query;

wildcard

Convert * into % for sqlquery

my $string = $self->wildcard(5.*);

tenify

Create range of links to split (by tens or more) bugids from web query result.

$self->tenify(@_bids, bug, 7); # in chunks of 7

Python/Tk Empire Interface project is a cross-platform Empire GUI client.
The Python/Tk Empire Interface (PTkEI) enables you to connect to empire 4.x.x (Wolfpack) servers.
Empire is a real-time war game with long tradition.
You can find out about Empire and currently running servers and other clients at its homepage.
This client is an example for a truly portable cross-platform GUI, known to run on Unix, X11, Win32 and Mac.
Additionally you do not give up any command line power as a player, but you have to to learn the empire commands to make use of this GUI client.
Main features:
- Portability
- Map Features
- Command Line
- Socket Interface
- Smart Features

Realtime Application Interface project allows applications with strict timing constraints to be run on Linux.
A real time system is able to guarantee the timing requirements of the processes under its control.
RTAI provides an API and the necessary kernel modifications to accommodate such requirements.
Enhancements:
- Improvements were made to netrpc.
- Context switching between hard and soft real-time, handling of TSC errors, and POSIX compatibility have been improved.
- There are numerous minor bugfixes.

RULI stands for Resolver User Layer Interface. Its a library built on top of an asynchronous DNS stub resolver. RULI provides an easy-to-use interface for querying DNS SRV resource records. The goal is to promote wide deployment of SRV-cognizant software. RULI aims to fully support SRV-related standards. There are bindings for PHP, Perl, Guile/Scheme, Java, and Lua. IPv6 is supported.

Now you can understand the benefits of SRV records and please see how RULI can help you.

SRV records are more complex than A records

Handling DNS SRV is not as simple as to deal with ordinary address records. When one performs a query for A records by calling gethostbyname(), he gets a list of addresses which should be contacted in the same order as they were received. For SRV records, there is an additional logic that must be applied to the records, based on their weight and priority, to discover the correct sequence for contacting them.
RULI can handle SRV records for you

The SRV logic is described in RFC 2782. Those who intend to use SRV benefits in their application are expected to implement that exact behavior. RULI can help here: it automatically performs all the SRV logic for you.
Keep focus on your application logic

Application developers probably want to spend time on their business logic; not dealing with the details of the DNS protocol or implementing the SRV specification.

RULI is a tested framework designed to properly fetch SRV records. It saves you time and head aches.
RULI is free as in free beer and in free speech

General Package/Module Interface (GPMI) is a lightweight library that assists with modularizing applications.
It includes prewritten script interpreter modules in addition to timers, events, and package dependencies.
Enhancements:
- This version features many bugfixes and memory leak cleanups.
- It is now possible to compile the code on Windows using mingw.