Free delegate 9.5.6 software for linux

DeleGate is a multi-purpose application level gateway, or a proxy server which runs on multiple platforms (Unix, Windows, MacOS X and OS/2). DeleGate mediates communication of various protocols (HTTP, FTP, NNTP, SMTP, POP, Telnet, SOCKS, etc.), applying cache and conversion for mediated data, controlling access from clients and routing toward servers.
DeleGate translates protocols between clients and servers, applying SSL(TLS) to arbitrary protocols, merging several servers into a single server view with aliasing and filtering.
Born as a tiny proxy for Gopher in March 1994, it has steadily grown into a general purpose proxy server. Besides beeing a proxy, DeleGate can be used as a simple origin server for some protocols (HTTP, FTP and NNTP).
Main features:
- UNBOUND PROXY: A user can select target servers arbitrarily in ad hoc way showing destination in user level data specific to the protocol of the client.
- BOUND PROXY: An administrator of DeleGate can specify which destination server is used depending on accessing client.
- CACHE: A message data transferred on a protocol is cached in its inherent format and shared among DeleGate as gateway servers of different protocols.
- CONNECTION SHARING: An established connection to a server in anonymous user can be reused and shared among multiple clients.
- DATA CONVERSION: DeleGate has several built-in data conversion filters which can be applied to a specific part of data in a message on each protocol.
- PROTOCOL CONVERSION: A client of a protocol can talk with servers of other protocols via DeleGate.
- AUTHENTICATION / SECURE PROTOCOL CONVERSION: DeleGate can relay between a non-SSL client and a SSL server, or between a SSL-client and a non-SSL server.
- ACCESS CONTROL: Accesses to be permitted to pass DeleGate are described by a set of triples of destination protocol, destination server and source client.
- LOGGING: Detailed logging of DeleGate actions and protocol dependent logging in standard formats.
- AUTOMATIC INVOCATION: DeleGate can be invoked automatically on demand or at the startup time of the host system.
- RESOLVER CONTROL: You can control the combination and sequence of multiple resolution mechanisms, independently of platforms.
- ROUTING CONTROL: A route toward the server can be selected from alternatives depending on protocol, server and client (host and user).
- MOUNTING SERVERS: Multiple target servers of multiple protocols can be merged into a single server of a protocol, with resource name filtering and aliasing.
- PROXY ON DEMAND: Automatically invoked proxy just for the current session.
- ORIGIN SERVER: You can use DeleGate as simple origin servers for several protocols.
- EXTENSION BY USERS: You can attach your own graphic images, messages, and programs to DeleGate without modifiying the DeleGate program.
- TCP WRAPPER: You can use DeleGate like inetd + TCPwrapper which make your own filter program work as a server with access control.
- SCHEDULER: You can use DeleGate like crond which invokes specified commands at specified timing.
- MULTI-PLATFORM: DeleGate runs on multiple platforms and can be compiled from a common source program without any platform dependent configuration.
Whats New in 9.6.3 Alpha Development Release:
- This release fixes frozen threads or broken data which could be caused with thread based implementations of SSL and gzip filters.

fuselagefs is a project which consists of a C++ wrapper class for FUSE called Fuselagefs.

fuselagefs consists of a C++ wrapper class for FUSE called Fuselagefs, as well as Delegatefs which is a Fuselagefs subclass that delegates all operations to an underlying base filesystem.

With Delegatefs you can expose dir1 at mountpoint dir2 very easily as a FUSE filesystem. Subclasses of Delegatefs can then be created which add a little extra functionality to the delegation operation but rely on the parent class to perform the work and return errors to FUSE in an appropriate manner. An example subclass is petardfs.

Java-GNOME is a set of Java bindings for GNOME and GTK libraries, so GNOME applications can be written in Java. Java-GNOME is implemented as a JNI layer that delegates the Java calls out to the underlying C library.

Installation:

See the INSTALL file in each module for instruction on how to build the binding from source.

How to report bugs:

You can submit bugs at the following url: http://bugzilla.gnome.org/enter_bug.cgi?product=java-gnome

Please indicate what version of the library you were using when you encountered the bug.

Please include the following information in your bug report:

1) The type of system and version of the operating system you are using.
2) The version of GTK/GNOME you are using.
3) A detailed description of the bug. If the bug is reporducable, please indicate haw to reproduce.

You can also submit enhancement requests at the same location.

beware project is a distributed global server load balancing system.

beware is a small DNS server that can have nameserver responsibility delegated to it and that can return a set of authoritative "IN A" records to a client.

Given a list of hosts for a certain domain name, it also tests for services specified and will only return IP addresses for currently reachable services.

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.

libgtk-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.

Template::Alloy::Parse is a Perl module with common parsing role for creating AST from templates.

The Template::Alloy::Parse role is reponsible for storing the majority of directive parsing code, as well as for delegating to the TT, HTE, Tmpl, and Velocity roles for finding variables and directives.

ROLE METHODS

parse_tree

Used by load_tree. This is the main grammar engine of the program. It delegates to the syntax found in $self->{SYNTAX} (defaults to alloy) and calls the function found in the $SYNTAX hashref. The majority of these syntaxes use methods found in the $DIRECTIVES hashref to parse different DIRECTIVE types for each particular syntax.

A template that looked like the following:

Foo
[%- GET foo -%]
[%- GET bar -%]
Bar

would parse to the following AST:

[
Foo,
[GET, 6, 15, [foo, 0]],
[GET, 22, 31, [bar, 0]],
Bar,
]

The "GET" words represent the directive used. The 6, 15 represent the beginning and ending characters of the directive in the document. The remaining items are the variables necessary for running the particular directive.
parse_expr

Used to parse a variable, an expression, a literal string, or a number. It returns a parsed variable tree. Samples of parsed variables can be found in the VARIABLE PARSE TREE section.

my $str = "1 + 2 * 3";
my $ast = $self->parse_expr($str);
# $ast looks like [[undef, +, 1, [[undef, *, 2, 3], 0]], 0]
parse_args

Allow for the multitudinous ways that TT parses arguments. This allows for positional as well as named arguments. Named arguments can be separated with a "=" or "=>", and positional arguments should be separated by " " or ",". This only returns an array of parsed variables. To get the actual values, you must call play_expr on each value.

dump_parse_tree

This method allows for returning a string of perl code representing the AST of the parsed tree.

It is mainly used for testing.

dump_parse_expr

This method allows for returning a Data::Dumper dump of a parsed variable. It is mainly used for testing.

parse_*

Methods by these names are used by parse_tree to parse the template. These are the grammar. They are used by all of the various template syntaxes Unless otherwise mentioned, these methods are not exposed via the role.

AgileWiki is a Java-based wiki that provides a virtual wiki for each registered user, complete with access control and versioning.
The backend includes a built-in database (which uses flat files) and communicates via RMI to either a Servlet (packaged as a WAR file) or to a Swing client. AgileWiki is also both an application platform and a knowledge management system.
The goal is to build an extensible wiki application server based on Rolonics, which is a theory of knowledge developed by Norman Kashdan. Ths work has been on-going for about 6 years now, and open source for the last two.
Prior versions were implemented in Python, the switch to Java being driven by a need for a faster database. (A custom OODBMS has already been developed in Java. It supports 50K/sec inserts and handles nested transactions at the rate of 500/sec.)
At present, Swing, text and Servlet clients have been implemented, with all communication with the application server via XML over RMI. Both the Swing client and web access support a Wiki and a Rolonic interface.
AgileWiki supports virtual wikis, each user having their own space, full access control and the ability to delegate access through the definition of user groups.
This project self-hosts its own documentation, includes support for installing and deploying application code, offers some agility for managing content and provides transactional support for table updates as well.
The next phase of the project is to work on classifiers (half a dozen different kinds) which are used to customize the namespace for each Rolon (node). The deep knowledge structures supported by the AgileWiki database make use of late binding, with the namespace of each Rolon used to resolve references to other nodes.
Enhancements:
- Wiki text is now automaticly updated by refactoring operations.