Free driver agent software for linux

The Advanced Linux Sound Architecture is composed of several parts. The first is a fully modularized sound driver which supports module autoloading, devfs, isapnp autoconfiguration, and gives complete access to analog audio, digital audio, control, mixer, synthesizer, DSP, MIDI, and timer components of audio hardware.
It also includes a fully-featured kernel-level sequencer, a full compatibility layer for OSS/Free applications, an object-oriented C library which covers and enhances the ALSA kernel driver functionality for applications (client/server, plugins, PCM sharing/multiplexing, PCM metering, etc.), an interactive configuration program for the driver, and some simple utilities for basic management.
Main features:
- Efficient support for all types of audio interfaces, from consumer soundcards to professional multichannel audio interfaces.
- Fully modularized sound drivers.
- SMP and thread-safe design.
- User space library (alsa-lib) to simplify application programming and provide higher level functionality.
- Support for the older OSS API, providing binary compatibility for most OSS programs.

New Driver and Tools is a SuperKaramba theme that displays the latest version of drivers and of some tools.

By clicking on the globe youll get on the homepage of the driver/tool.

(The wine homepage was not reachable at the time I took the screen)

Im looking forward for your feedback.

Mobile::UserAgent is a mobile user agent string parsing class.

SYNOPSIS

### Print the information parsed from a user-agent string:
use Mobile::UserAgent;
my $useragent = Nokia6600/1.0 (4.09.1) SymbianOS/7.0s Series60/2.0 Profile/MIDP-2.0 Configuration/CLDC-1.0;
my $uaobj = new Mobile::UserAgent($useragent);
if ($uaobj->success()) {
print Vendor: . $uaobj->vendor() . "n";
print Model: . $uaobj->model() . "n";
print Version: . $uaobj->version() . "n";
print Series60: . $uaobj->isSeries60() . "n";
print Imode?: . $uaobj->isImode() . "n";
print Mozilla?: . $uaobj->isMozilla() . "n";
print Standard?: . $uaobj->isStandard() . "n";
print Rubbish?: . $uaobj->isRubbish() . "n";
}
else {
print "Not a mobile user-agent: $useragentn";
}


### Determine if the client is a mobile device.
use Mobile::UserAgent ();
use CGI ();

# Check 1: (check if it sends a user-agent profile URL in its headers)
foreach my $name (X_WAP_PROFILE,PROFILE,13_PROFILE,56_PROFILE) {
if (exists($ENV{"HTTP_$name"})) {
print "Client has a user-agent profile header, so its probably a mobile device.n";
last;
}
}

# Check 2: (check if it supports WML):
my $q = new CGI();
if ($q->Accept(text/vnd.wap.wml) == 1) {
print "Client supports WML so its probably a mobile device.n";
}

# Check 3: (check if this class can parse it)
my $uaobj = new Mobile::UserAgent();
if ($uaobj->success()) {
print "Clients user-agent could be parsed, so its a mobile device.n";
}

Parses a mobile user agent string into its basic constituent parts, the most important being vendor and model.

One reason for doing this would be to use this information to lookup vendor-model specific device characteristics in a database. You can use also use user agent profiles to do this (for which Ive developed other classes), but not all mobile phones have these, especially the older types. Another reason would be to detect if the visiting client is a mobile handset.

Only real mobile user-agent strings can be parsed succesfully by this class. Most WAP emulators are not supported because they usually dont use the same user-agent strings as the devices they emulate.

Driver on demand is an attempt to ease driver installations in linux. Basically, what happens is that a user plugs any device into the computer, and if a driver isnt found, the client connects to a CGI server, to check if the device is known, and if its not in the database, then the driver lookup fails and the user is no worse off then they currently are.
However, if the device is found online, the driver information file (similar to .infs, just XML and more versatile) is analysed. If its built into newer versions of kernels, but theres a driver available, the driver is installed, but the system recommends strongly that the user upgrades their kernel, automatically, otherwise it just installs.
If the vendor chooses to, they can create their own driverinstall files, put it on their site, and put a reference on the Driver On Demand server, so the user will always have the newest files.. As opposed to having to wait for the admin to update their definitions.
To people who dont care about the specifics, all they need to care about is that if a device on their system needs a driver, this will find it on the internet, and install it for them automatically.
Main features:
- Uses HTTP/plaintext, so proxy compatible
- Allows the use of always up to date file.driverinstall files users can just click to install their latest hardware
- Takes the hassle of installing drivers away from the users
- XML based driver definitions, so extremely extendable, and is written in perl, so easy to edit and handle
- System handles licenses, allowing users to add them or remove licenses of drivers (promotes GPL drivers too, because that licence is accepted by default)
- Open source, GPL.. Which means u dont need to worry about licensing..
- Allows one click install of drivers (the first linux driver listing standard)
- Promotes Open source

EXAMPLE

# This is a really long synopsis, but hopefully it will give you an idea...

package MyPackage;

use Class::Driver;
use base q(Class::Driver);

our %drivers;

return 1;

sub new {
my($class, %args) = @_;
die "mime_type is required" unless($args{mime_type});
die "no driver to handle type $args{mime_type}"
unless($drivers{$args{mime_type}});
return $class->driver_load($drivers{$args{mime_type}}, %args);
}

sub driver_new {
my($class, %args) = @_;
return bless %args, $class;
}

sub driver_required { 1; }
sub driver_requied_here { 0; }

package MyPackage::avi;

use MyPackage;
use base q(MyPackage);
use Video::Info;

$MyPackage::drivers{video/x-msvideo} = avi;

return 1;

sub driver { "avi"; }

sub driver_new {
my($class, %args) = @_;
die "file is a required parameter for $args{mime_type} files"
unless($args{file});
$args{info} = Video::Info->new(-file => $args{file})
or die "Failed to create a Video::Info object for $args{file}";
return $class->SUPER::driver_new(%args);
}

sub duration {
my $self = shift;
return $args{info}->duration;
}

package MyPackage::mp3;
use base q(MyPackage);
use MP3::Info;

$MyPackage::drivers{audio/mpeg} = mp3;

## (etc...)

package main;

my $foo = MyPackage->new(file => foobar.mp3, mime_type => audio/mpeg);
print "foobar.mp3 is ", $foo->duration, " seconds long.n";

mod_auth_useragent2 is an Apache module that can be used to limit access to documents by means of the User-Agent.

As an authentication method, this is really unsafe because it is easy to change the User-Agent in most browsers, but it could be used to prevent stupid bots and spiders from accessing your Web sites.

JDBC Driver for SQLite is a thin layer on top of the SQLite 3.3.x C API. The native JNI library has SQLite compiled into it so all you need to do is include the two files packaged above in your project.
Usage:
Download the binary for the platform you are developing on. Open the tarball and copy the two files into your application directory:
sqlitejdbc.jar
[lib]sqlitejdbc.[dll, so, jnilib]
Reference the driver in your code:
Class.forName("org.sqlite.JDBC");
Connection conn = DriverManager.getConnection("jdbc:sqlite:filename");
// ... use the database ...
conn.close();
And call your program with the drivers JAR file in the classpath and the C library in the librarypath. E.g.
java -cp lib/yourprog.jar:lib/sqlitejdbc.jar
-Djava.library.path=lib
yourprog.Main
Enhancements:
- The driver is now thread-safe and fully supports UTF-16.
- There are binaries for Mac OS, Linux, and Windows, and instructions for compiling with MSVC.