Free delegate 9.9.3 9.9.4 pre11 software for linux

kqemu the QEMU Accelerator Module increases the speed of QEMU when a PC is emulated on a PC. It runs most of the target application code directly on the host processor to achieve near native performance. It is very useful when you want to run another Operating System (for example Windows) on a Linux desktop.
Currently it is available for Linux x86 or x86_64 hosts running a kernel 2.4.x or 2.6.x. Preliminary versions are available for Windows and FreeBSD hosts.
With the QEMU Accelerator Module, QEMU can be compared to other commercial or free PC Virtualizers. It has the advantage of being free and to achieve good performances while necessitating no specific guest Operating System modifications. No other product has such advantages.
Installation
2.1 KQEMU Compilation (Linux only)
First ensure that you have a recent version of QEMU (>= 0.8.1) with the KQEMU support enabled (this is the default).
Then decompress the KQEMU sources:
cd /tmp
tar zxvf kqemu-x.y.z.tar.gz
cd kqemu-x.y.z
Then you configure KQEMU and build it (usually no options are needed):
./configure
make
Then type as root user:
make install
to install KQEMU in `/usr/local.
QEMU Accelerator Installation for Linux
If you use x86 Linux, the compilation of the QEMU Accelerator Kernel Module (KQEMU) is automatically activated provided you have the necessary kernel headers. If nonetheless the compilation fails, you can disable its compilation with the `--disable-kqemu configure option.
Note that KQEMU cannot currently work if the Xen virtualizer is running on your host.
If you are using a 2.6 host kernel, then all the necessary kernel headers should be already installed. If you are using a 2.4 kernel, then you should verify that properly configured kernel sources are installed and compiled. On a Redhat 9 distribution for example, the following must be done:
1) Install the kernel-source-xxx package
2) cd /usr/src/linux-xxx
3) make distclean
4) Copy /boot/config-vvv in .config (use uname -r to know your configuration name vvv)
5) Edit the Makefile to change the EXTRAVERSION line to match your current configuration name:
EXTRAVERSION = -custom
to
EXTRAVERSION = -8 # This is an example, it can be -8smp too
6) make menuconfig # Just save the configuration
7) make dep bzImage
The installation of KQEMU is not fully automatic because it is highly distribution dependent. When launching
make install
KQEMU is installed in /lib/modules/kernel_version/misc. The device `/dev/kqemu is created with read/write access rights for everyone. If you fear security issues, you can restrict the access rights of `/dev/kqemu.
If you want that KQEMU is installed automatically at boot time, you can add
# Load the KQEMU kernel module
/sbin/modprobe kqemu
in `/etc/rc.d/rc.local.
If the major number 250 is already used by another driver, you can use the option major=N to set an alternate major number.
If your distribution uses udev (like Fedora), use the kqemu module option major=0 to have the device `/dev/kqemu automatically created:
# Load the KQEMU kernel module
/sbin/modprobe kqemu major=0
It is usually necessary to change the device access rights set by udev. Edit `/etc/udev/permissions.d/50-udev.permissions and add:
# kqemu
kqemu:root:root:0666
Enhancements:
- dynamic device /dev/kqemu creation is now the default.
- -fno-stack-protector gcc option fix
- added kqemu regression tests (can serve as API usage example too)
- included kqemu technical doc

Linux-PAM project offers a flexible mechanism for authenticating users.
For the uninitiated, we begin by considering an example. We take an application that grants some service to users; login is one such program.
Login does two things, it first establishes that the requesting user is whom they claim to be and second provides them with the requested service: in the case of login the service is a command shell (bash, tcsh, zsh, etc.) running with the identity of the user.
Traditionally, the former step is achieved by the login application prompting the user for a password and then verifying that it agrees with that located on the system; hence verifying that as far as the system is concerned the user is who they claim to be.
This is the task that is delegated to Linux-PAM.
From the perspective of the application programmer (in this case the person that wrote the login application), Linux-PAM takes care of this authentication task verifying the identity of the user.
The flexibility of Linux-PAM is that you, the system administrator, have the freedom to stipulate which authentication scheme is to be used. You have the freedom to set the scheme for any/all PAM-aware applications on your Linux system.
That is, you can authenticate from anything as naive as simple trust (pam_permit) to something as paranoid as a combination of a retinal scan, a voice print and a one-time password!
To illustrate the flexibility you face, consider the following situation: a system administrator (parent) wishes to improve the mathematical ability of her users (children).
She can configure their favorite ``Shoot em up game (PAM-aware of course) to authenticate them with a request for the product of a couple of random numbers less than 12. It is clear that if the game is any good they will soon learn their multiplication tables.
As they mature, the authentication can be upgraded to include (long) division!
Linux-PAM deals with four separate types of (management) task. These are: authentication management; account management; session management; and password management.
The association of the preferred management scheme with the behavior of an application is made with entries in the relevant Linux-PAM configuration file.
The management functions are performed by modules specified in the configuration file. The syntax for this file is discussed in the section below.
By way of explanation, the left of the figure represents the application; application X. Such an application interfaces with the Linux-PAM library and knows none of the specifics of its configured authentication method.
The Linux-PAM library (in the center) consults the contents of the PAM configuration file and loads the modules that are appropriate for application-X.
These modules fall into one of four management groups (lower-center) and are stacked in the order they appear in the configuration file. These modules, when called by Linux-PAM, perform the various authentication tasks for the application.
Textual information, required from/or offered to the user, can be exchanged through the use of the application-supplied conversation function.
Enhancements:
- This release contains new translations and improvements to pam_limits.so, pam_access.so, pam_cracklib.so, pam_namespace.so, and pam_selinux.so.

Quick Image Viewer (qiv) is a very small and fast GDK/Imlib image viewer designed to replace the classic image viewers like xv or xloadimage. Quick Image Viewer program runs on FreeBSD, Linux (libc5/glibc), Solaris (SunOS) and HP-UX.
Main features:
- moving & zooming image in fullscreen mode.
- setting image as x11 background (centered,tiled,stretched..) with user settable background color
- fullscreen viewing with a great statusbar
- external "qiv-command" program support
- screensaver mode
- brightness/contrast/gamma correction
- real transparency
- maxpect (zoom to screen size while preserving aspect ratio)
- scale_down (scale down to big images to fit screen size)
- slideshow (with random order if you want)
- filename filer
- flip horizontal/vertical, rotate left/right
- delete function (move to .qiv-trash/)
- jump to image number x, jump forward/backward x images
Enhancements:
- This release has some bugfixes and new options.

JGame is a small high-level 2D game engine for producing games on Java platforms. It does a lot of the stuff you need for a game automatically, and "classic" type arcade games can be developed with a minimum of effort.
It is based on sprites with automatic collision detection, and a tile-based background with easy sprite-tile interaction facilities. JGame games can easily be run as stand-alone applications or as applets, and can be scaled to any resolution.
Main features:
- Tested on various platforms; can easily be run as applet as well.
- Ensures optimised and accelerated graphics for a variety of displays; even works well on remote X11 displays.
- The game is programmed at one resolution, but can be scaled to any desired resolution when run.
- Built-in animated "sprite" engine, with easy animation definition.
- Tile-based background handling, with decorative backdrop.
- Automatic collision detection with sprites and background tiles, and easy background tile interaction.
- Load sprites, tiles, and colour fonts directly from sprite sheets.
- Define images and animations in a text file.
Enhancements:
- New platform-independent versions of Point, Rectangle, Color, Font.
- Changes in package structure. Base classes are now in jgame, platform independent implementation details in jgame.impl, platform dependent classes in jgame.platform.
- Major changes in JGEngine/JGCanvas. A platform independent interface JGEngineInterface has been defined. The platform-independent code has been moved to jgame.impl.*, and for each platform there is a platform-dependent version of JGEngine, delegating functionality to jgame.impl.EngineLogic where possible.
- ImageUtil has been split into a platform-independent interface JGImage, and platform implementations JREImage and MIDPImage.
- StdGame now has two versions, the original for JRE and a somewhat simplified version for MIDP.
- The package tree has been changed. The sources are now in src-*, classes are compiled into classes-*. Compilation of the JGame classes and the examples and applications has been split.
- The code has been optimised: object creations in the most important tight loops have been reduced to near zero, repaintBG has been optimised by a factor 2, isOnPF/isInView were optimised.
- a small bug in background copying where the area bounds would exceed the size of the source image was fixed.
- A few methods were added specifically for use the Midlet platform, such as isMidlet(), displayWidth/Height(), setScalingPreferences().
- setCursor has been renamed to SetMouseCursor.
- there is a new engine getTiles method that copies the data into an existing object. Semantics of the getTiles methods in JGObject have been changed to return a local variable with the information copied into it, rather than create an object every time. Semantics of some other methods such as getImage is changed so as not to create a new object every time.
- fixed bug in exitEngine which did not set the JGObject default_engine to null
- fixed access exception occurring in unsigned webstart.
- improved frame skip logic so that game runs smoothly even if the machine is way too slow

Gentle.NET is an RDBMS independent object persistence framework. Gentle.NET features automatic SQL generation and object construction, an SQL factory for creating custom queries, DataView construction helpers, excellent performance and reasonably complete docs.
The framework defines a few attributes with which you have to decorate the objects you wish to persist. Decorate classes with the TableName attribute, and members (properties and fields as you see fit) with the TableColumn attribute.
There are additional attributes available which need only be used when no Analyzer class exists for the database you are using (see Database Provider - Implementation Status). The Analyzer classes are used to obtain metadata on the current schema directly from the database, thus bypassing the need for replicating this information in your code.
If no Analyzer exists, primary key columns must be decorated with the PrimaryKey attribute, and foreign keys and their mappings must be declared using the ForeignKey attribute. The TableColumn attribute provides properties allowing you to provide details on type, size and null-handling. If an Analyzer does exist, the information obtained automatically overrides any such setting.
Business objects may optionally inherit from the Persistent class, which provides a set of standard methods for persisting and retrieving objects. You can replicate these on a different base class if needed, or on a manager class if you prefer a more SOA-oriented design. Gentle provides support for identity columns (where the database assigns a primary key value to the row being inserted) to implementors of IPersistent (which includes the Persistent class).
The main access point into the framework functionality is provided by the PersistenceBroker class, which is responsible for orchestrating all access to a given database provider.
The PersistenceBroker is responsible for basic query construction and caching, as well as interaction with the database backends. You can create as many PersistenceBroker instances as needed, such as one for every database to which you need to connect. Various classes permit or require you to pass a PersistenceBroker instance, which will be used subsequently for all database operations performed by the class.
If you need to connect to a single database only, you can use the static Broker class, which delegates all calls to a default PersistenceBroker instance (using the DefaultProvider configured in the configuration file).
Persistent objects are identified by a Key, which is really just a Hashtable with some convenient methods for gathering property values from objects. The Key class knows how to populate itself when given an object instance and a set of property names, and also provides a means of obtaining a key holding just the primary key fields.
This is useful when constructing custom queries as constraints can be passed as Key instances to methods on both the (Persistence)Broker and SqlBuilder classes. This encapsulation also enables Gentle to work with multi-column primary keys.
To execute custom SQL statements use the SqlStatement class. Use the SqlBuilder class to construct instances of this class whenever the statement is for a supported type (i.e. a class decorated with the proper attributes as outlined above).
The SqlBuilder provides a database independent way of constructing queries and has many methods for adding constraints and otherwise customizing the query. It is used internally by the PersistenceBroker whenever it needs to generate statements.
You can declare a DataView layout using the CustomView attribute on the properties to include in the DataView. The actual DataView can be obtained using the ObjectView class by supplying an array of business objects.
Multiple statements can be transacted (grouped) using the Transaction class.
Enhancements:
- This release features a complete rewrite of the cache subsystem, with significant performance improvements as a result.
- There have also been several minor improvements and bugfixes throughout the code base.

KeyNote is a simple and flexible trust-management system designed to work well for applications.

Trust management, introduced in the PolicyMaker system [BFL96], is a unified approach to specifying and interpreting security policies, credentials, and relationships; it allows direct authorization of security-critical actions. A trust-management system provides standard, general-purpose mechanisms for specifying application security policies and credentials. Trust-management credentials describe a specific delegation of trust and subsume the role of public key certificates; unlike traditional certificates, which bind keys to names, credentials can bind keys directly to the authorization to perform specific tasks.

A language for describing `actions, which are operations with security consequences that are to be controlled by the system.
A mechanism for identifying `principals, which are entities that can be authorized to perform actions.
A language for specifying application `policies, which govern the actions that principals are authorized to perform.
A language for specifying `credentials, which allow principals to delegate authorization to other principals.
A `compliance checker, which provides a service to applications for determining how an action requested by principals should be handled, given a policy and a set of credentials.

The trust-management approach has a number of advantages over other mechanisms for specifying and controlling authorization, especially when security policy is distributed over a network or is otherwise decentralized.

Trust management unifies the notions of security policy, credentials, access control, and authorization. An application that uses a trust- management system can simply ask the compliance checker whether a requested action should be allowed. Furthermore, policies and credentials are written in standard languages that are shared by all trust-managed applications; the security configuration mechanism for one application carries exactly the same syntactic and semantic structure as that of another, even when the semantics of the applications themselves are quite different.

Trust-management policies are easy to distribute across networks, helping to avoid the need for application-specific distributed policy configuration mechanisms, access control lists, and certificate parsers and interpreters.

For a general discussion of the use of trust management in distributed system security, see [Bla99].

KeyNote is a simple and flexible trust-management system designed to work well for a variety of large- and small- scale Internet-based applications. It provides a single, unified language for both local policies and credentials. KeyNote policies and credentials, called `assertions, contain predicates that describe the trusted actions permitted by the holders of specific public keys. KeyNote assertions are essentially small, highly-structured programs. A signed assertion, which can be sent over an untrusted network, is also called a `credential assertion. Credential assertions, which also serve the role of certificates, have the same syntax as policy assertions but are also signed by the principal delegating the trust.

In KeyNote:

Actions are specified as a collection of name-value pairs.
Principal names can be any convenient string and can directly represent cryptographic public keys.
The same language is used for both policies and credentials.
The policy and credential language is concise, highly expressive, human readable and writable, and compatible with a variety of storage and transmission media, including electronic mail.
The compliance checker returns an application-configured `policy compliance value that describes how a request should be handled by the application. Policy compliance values are always positively derived from policy and credentials, facilitating analysis of KeyNote-based systems.
Compliance checking is efficient enough for high-performance and real-time applications.

This document describes the KeyNote policy and credential assertion language, the structure of KeyNote action descriptions, and the KeyNote model of computation.

Java-GNOME is a set of Java bindings for GNOME and GTK libraries, so GNOME applications can be written in Java.

libvte-java is implemented as a JNI layer that delegates the Java calls out to the underlying C library.

Installation:

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.