Free mda software for linux

POP3Download provides a small Perl alternative to Fetchmail.
POP3Download is a simple Perl script which downloads and delivers email from a POP3 server to a local MTA or MDA.
It was developed in order to work around problems in Fetchmail while still providing the same or similar functionality.
pop3download is my initial work on a drop-in replacement for fetchmail, written in perl. it is designed to be a much more flexible and easy to edit app than the original fetchmail program as well as get around some design limitations and bugs.
there is limited support for fetchmail config files. $HOME/.fetchmailrc is parsed for the following options:
set daemon INTEGER
poll SERVER
user[name] USER
pass[word] PASS
proto[col] PROTO
mda ["]MDA["]
soon to be implemented options:
fetchall
keep
forcecr
without any arguments the config file is parsed and servers are polled.
if -h or --help is the first argument, some basic help options are displayed.
support for polling a single server on the command-line is available and will eventually be extended to support more fetchmail-like command line args.
currently pop3download only supports the pop3 protocol (as the name suggests) but adding support for IMAP and other protocols should be fairly trivial.
Enhancements:
- Added IMAP support, for mirroring/pulling an IMAP mailbox, for example to keep the size of the mailbox small.
- Fixed opening of UIDL id file; before it was using the same database for all users of a pop3 server, reusing the same UIDLs for each user.

parp is a powerful, extensible e-mail filter with sophisticated anti-spam capabilities. Its made as a complete replacement for procmail, is MIME-aware, and acts as a filter, daemon, or on mailboxes.
This was yet another personal itch which needed scratching. I receive between 5 and 20 spam e-mails most days. It wasnt only mildly annoying to have to hit delete more than normal, but I also forward all e-mail which ends up in my main inbox to my mobile (cell) phone via email2sms and an Internet/SMS gateway, and I was sick to death of my phone bleeping a lot through the day purely due to junk mail.
I started looking at all the available anti-spam filters. Over a period of two years, I looked at many, including the NAGS filter, despam, various complex anti-spam procmailrcs, the spamometer, blackmail, filter.plx, zfilter, spamstop, junkfilter ... but various things put me off all of them:
Some werent written in Perl. Call me a Perl bigot, but if there was ever a case of Perl being the right tool for the job, its an e-mail filter. Extensibility and maintainability were very high on my list.
Some were terribly coded. I refuse to put my e-mail at the mercies of bad code (and that includes sendmail ;-).
Some insisted that you use a particular MDA or MUA. I have no intentions of changing from mutt and qmail.
Many filtered on only the headers, or only the body. I want to filter on both, not all the time, but in some circumstances.
None were as accurate as I wanted. My goal was at least 99% accuracy. (At the time of writing, parps accuracy is hovering around the 99.8% mark.)
Main features:
- Can act as a filter in a similar manner to procmail, or directly on files in Mbox format (and possibly other formats via Mail::Box - untested), or as a daemon processing mails from a spool. In the latter case, mails are injected into the queue via a tiny (15k on my system) executable which handles locking correctly.
- Standard filtering actions are available (deliver to mailbox, pipe to command, reject as junk etc.)
- Highly sophisticated spam detection heuristics: currently around 40 different tests performed in a worst case scenario, although all tests optimised for speed (e.g. fast tests performed on headers, then slower tests only performed on body if necessary). N.B. Im considering incorporating the SpamAssassin ruleset at some point too.
- Optional cross-checking with the Open Relay Database.
- Filter adds X-Parp-Accepted: and X-Parp-Rejected: headers so that you can easily monitor its filtering strategy without leaving your mail reader.
- MIME multi-part aware, e.g. will not be confused by binary attachments.
- Berkeley DB format friends database, for keeping false positives to an absolute minimum.
- Automatic extraction of addresses into the friends database from emails which pass the spam tests. Semi-automatic removal of addresses from the friends database on the rare occasions parp gets it wrong. The friends database is also easily editable with my dbm utility.
- Other `grace tests allowing bona fide persons communications through (e.g. passworded e-mails) just in case all the other tests go badly wrong.
- The configuration files are written in raw Perl, so you can extend the filter arbitrarily using the main programs API.
- Comprehensive logging and error-trapping systems.
- Auxiliary program to print out comprehensive statistics on all aspects of filtering (see the sample output).
- Ability to log false positives/negatives when spam detection has gone wrong in a way which can be interpreted by the statistics program to determine the filters current accuracy of spam detection.
- Mostly RFC822-compliant state machine parser of Received headers, enabling extensive spam trace analysis and retaliative action. Read its man page or source if youre curious.
- Duplicate removals (by message id).
- Emails which have already been filtered can be used as regression tests, to easily spot problems when you make changes to your filtering logic.
Version restrictions:
- Limited documentation so far. This is gradually improving.
- Requires some knowledge of Perl / programming. (Ironically, if it didnt, there would be far greater limitations to the filters flexibility.)

mpop project is a small and fast POP3 client with header based mail filtering capabilities.
mpop is released under the GPL with the additional exemption that compiling, linking, and/or using OpenSSL is allowed.
Main features:
- Header based mail filtering: filter junk mail before downloading it
- Delivery to mbox files, maildir folders or a mail delivery agent (MDA)
- Very fast POP3 implementation, using command pipelining
- Authentication methods USER/PASS, APOP, PLAIN, LOGIN and CRAM-MD5 (and GSSAPI, DIGEST-MD5, and NTLM when GNU SASL is used)
- TLS encrypted connections (including server certificate verification and the possibility to send a client certificate)
- IPv6 support
- support for multiple accounts

Xholon runtime framework executes applications that are event-driven or that have highly dynamic structure or behavior. Specify your models using XML and Java, or using third-party UML2 tools and MDA transformations.
To get started, read or actively work through the basic HelloWorld tutorial. Its a very simple application, but it demonstrates many of the main concepts.
For more detail on the concepts behind Xholon, you might want to read one of the papers thats been published. These describe how to model cells and other complex biological entities using tools designed for developing real-time and embedded systems.
This earlier work used Rational Rose RealTime and C++, rather than the current Java. Xholon is intended to be a runtime framework that can execute the same types of systems described in those papers, plus many more traditional non-biological event-driven systems.
The goal of the Cellontro sister project is to develop complex biological simulations using the Xholon framework. Most of the features described in the published papers have been re-implemented as Cellontro applications using Xholon.
Also have a look at the sample applications that are included with the Xholon software. These give an idea of the range of applications that can be supported by the Xholon runtime framework.
These have been employed as use cases to determine what functionality is most important in Xholon. The digital watch simulation is a good example of a Xholon application with a hierarchical state machine, developed using a UML modeling tool.
A Xholon is essentially a holon. A holon is an entity that lives within a hierarchical structure, and is both a whole and a part at the same time.
In mainstream computer science terms, a Xholon is a node in a tree. The node has a single parent, possibly one or more children, and possibly one or more siblings. A Xholon may also be an active agent able to interact in real-time with other Xholons in the tree.
In UML2 terminology, a Xholon is a structured classifier that may exist as a part within other structured classifiers, and that may in turn contain other structured classifiers as parts of itself. The result is a hierarchical containment structure, nested to an arbitrary number of levels.
As a part, a Xholon plays a specific role within another structured classifier. Xholons are UML classes that are subsequently refined using UML2 composite structure diagrams. Structured classifiers interact with each other through ports, by passing messages or by making function calls.
Using the more philosophical terminology used to describe holons, a Xholon is something that is simultaneously both a whole and a part. Since everything in the universe is a holon, then everything running within a computer application should be a Xholon. The term holon was invented by Arthur Koestler in 1967.
The Xholon Project is inspired by biological concepts. A major incentive behind the project is to build a run-time environment that is equally adapted to running simulations of biological systems, and to running more traditional real-time, embedded and other event-driven reactive systems.
Xholon applications may contain structures that are highly mutable. A Xholon is an active agent that can modify the tree structure in which it lives. It can navigate the tree to interact with any other node, it can add, delete or modify other nodes, it can exchange messages with other nodes, and it can move itself to another position within the tree.
The Xholon Project incorporates many concepts of the Real-time Object-Oriented Modeling (ROOM) methodology, much of which has been incorporated into UML2. At the same time, Xholon removes some of the limitations of ROOM to allow for greater flexibility, mutability and mobility of active objects.
The Xholon run-time can serve as a target for a Model Driven Architecture (MDA) transformation pipeline. MDA stresses the importance of models, and the ability to transform those models, through a series of steps, into an executing target system.
You can create your model using a UML tool such as Gentlewares Poseidon or NoMagics MagicDraw, save the model as an XMI file, transform it using XSLT (or by some other MDA means) into a Xholon model and application, and then execute the model.
Enhancements:
- UML state machine simulation capabilities have been extended, including animation, and fork, join, junction.
- Additional Agent-Based Modeling functionality is available.
- The NetLogo-like syntax has been enhanced.
- The architecture is more flexible and is ready to more fully support integration of multiple domains.
- Histograms and probability distributions are now available. Line charts update in real-time.
- Numerous other modeling, simulation, transformation, and execution features have been added.

WWW::BBSWatch can send, via email, messages posted to a WWW bulletin board.

SYNOPSIS

use WWW::BBSWatch; # should really be a subclass

sub WWW::BBSWatch::article_list { # generates warning (rightly so)
my $self = shift;
my $content = shift;
return ($$content =~ m%($self->{bbs_url}?read=d*)%gs);
}
BBSWatch->new(-MAIL => me,
-BBS_URL => http://www.foo.org/cgi-bin/bbs.pl)->retrieve;
There are many interesting discussions that take place on World Wide Web Bulletin Boards, but I do not have the patience to browse to each article. I can process email and newsgroups many times faster than a WWW bulletin board because of the lag inherent in the web. Instead of ignoring this wealth of information, WWW::BBSWatch was created. It will monitor a World Wide Web Bulletin Board and email new postings to you. The email headers are as correct as possible, including reasonable From, Subject, Date, Message-Id and References entries.
This module requires LWP::UserAgent and MIME::Lite.
INTERFACE
$b = WWW::BBSWatch->new
Arguments are:
-BBS_URL: The URL of the bulletin boards index page. This field is required.
-MAIL: The email address to send mail to
-MDA: Sets the mail delivery agent by calling MIME::Lite::send(HOW, HOWARGS). If a scalar value is passed in, it is passed as send(" sendmail?, $mda_value). If an array ref is provided, send(@$mda_value) is called.
-DB: Basename of the database that keeps track of visited articles
-WARN_TIMEOUT: Number of seconds before warning message is sent proclaiming inability to contact BBS_URL page. Default is 10,800 (3 hours).
-MAX_ARTICLES: Maximum number of articles to send in one batch. Default is essentially all articles.
-VERBOSE: Controls the amount of informative output. Useful values are 0, 1, 2. Default is 0 (completely silent).

$b->retrieve([$catchup])

This method emails new bulletin board messages. If the optional parameter catchup is true, messages will be marked as read without being emailed. Nothing useful will happen unless the article_list method is defined to return the list of articles from the BBSs index page.

WWW::BBSWatch uses the LWP::UserAgent module to retrieve the index and articles. It honors firewall proxies by calling the LWP::UserAgent::env_proxy method. So if you are behind a firewall, define the environment variable http_proxy and your firewall will be handled correctly.

saml-registry is a SAML 2.0 Metadata management tool that is useful for building shibboleth-based federations.

The saml-registry is a j2ee-application intended as a federation management tool, primarily (but not exclusively) for use with shibboleth. Future versions will support full delegation of rights through container-based role-management. The current version relies on container-based authentication.
For convenience the current version of the sql database schema and a jboss datasource descriptor sample can be found here on the right.

Installation instructions

Download the ear-file from the maven repository and drop it in the deploy-directory of your jboss application server. This build has been tested with jboss 4.0.2 but later versions should work.

You may need to disable certain features in a standard jboss, notably the jboss-ws4ee.sar (which conflicts with webservices provided by saml-registry) - just remove it from the deploy directory. Newer versions of jboss may ship with included versions of myfaces and jsf. These files must also be removed from your jboss before deploying saml-registry (or you must repackage the application excluding these libraries from the ear).

Next create a datasource-file for the mysql datastore. The < jndi-name/ > must be set to jdbc/saml-registry. Now create the database (update the datasource file with the server, username and password). Drop this file next to the ear in the deploy-directory. Use the sql schema to populate the database.

Finally configure authentication and authorization for saml-registry. This is done in the container by editing the login-config.xml (for jboss). Create a security domain called saml-registry in login-config.xml. The attached login-config.xml contains a sample entry which is based on property-files. The UsersRolesLoginModule is described on the jboss wiki.

The authorization for saml-registry is also managed by the security domain using standard j2ee role-based security. The roles govern access to individual use-cases (represented by menu entries in the user interface). Future versions will add per-organizational access control to this basic framework so that management of entities can be delegated.

The use-cases and roles is documented by this usecase diagram. Once your security-domain is configured to serve these roles (by editing property-files or whatever) you should be able to point your browser to https://your-box.example.com/saml-registry and get the main menu (or a login page depending on how your security domain was setup).

Building from source

In order to build saml-registry from source (which can be obtained from the subversion repository) you need maven2 and java5 to build the sources. The saml-registry is based on an MDA toolchain called andromda. Normally maven2 should download and install all dependencies, however the user interface needs the jsf2 cartridge from the andromda plugins project which may not be distributed from the andromda maven repository. If maven2 complains about unresolved dependencies for jsf2 then checkout the andromda plugins project and build it manually.

Open Blue Lab is an enterprise resource planning system.
Whatever your goal is, the objective of this tool is to provide you the ready-to use stuff to create, update, search and view data you need for your application.
Moreover, this stuff is provided with the latest UI goodies like AJAX support that will ensure you the best feeling you never had in browsing.
Like OpenBlueLab.org project is portal aware, that means you have aggregation and personalization too.
That way, you can focus on your added value : the business logic and requirements your customer needs.
Main features:
- to collaborate and communicate better
- to manage your personal time
- to schedule your appointments
- to define and track personal and group project
- to manage your content (asset, document, ...)
- to manage your customer relationship
- to make coffee (not yet, next release maybe
We want to develop a product, free, that fits exactly your needs, so read this web site and take time to indicate us your requirements. They will appear on our todo list, maybe in a long time, but they will. Then, you may incitate people to contribute in your direction by sponsoring somebody to achieve it.
This product is completely free. You can even package it and sell it. If you wonder what is our business model, you can ask to the forum.
Built on java technology, you may download the GUI installer, double-click and use it (with all your entreprise) through your preferred browser, whatever your environment is.
Built on XML and REST technology, you may integrate (in synchronous or asynchronous mode) it very easily in your environment too.
Currently OpenBlueLab use XML database (eXist) to persist data. This project was created to handle relational persistence using Hibernate. Hibernate is an object-relational mapping (ORM) solution.Using hibernate solution every relational database management system (RDBMS) can be used.
Model-Driven Architecture (MDA) Generators help to generate all mapping files from UML model using XMI format. Next we need to implement a mechanism to switch between XMLDB and RBDMS in OpenBlueLab easily.
Enhancements:
- The OpenBlueLab crud engine was refactored using the decorator and factory patterns.