Free email store dbi 0.254 software for linux

Email::Store::DBI is a Perl module for database backend to Email::Store.

SYNOPSIS

use Email::Store dbi:...;

This class is a subclass of Class::DBI and contains means for Email::Store-based programs to register what DSN they wish to use. It also provides for building database tables from schemas embedded in the DATA section of plug-in modules, using Class::DBI::DATA::Schema.

"Email::Store" is the ideal basis for any application which needs to deal with databases of email: archiving, searching, or even storing mail for implementing IMAP or POP3 servers.

"Email::Store" itself is a very lightweight framework, meaning it does not provide very much functionality itself; in effect, it is merely a Class::DBI interface to a database schema which is designed for storing email. Incidentally, if you dont know much about "Class::DBI", youre going to need to in order to get much out of this.

Despite its minimalist nature, "Email::Store" is incredibly powerful. Its power comes from its extensibility, through plugin modules and hooks which allow you to add new database tables and concepts to the system, and so access the mail store from a "different direction". In a sense, "Email::Store" is a blank canvas, onto which you can pick and choose (or even write!) the plugins which you want for your application.

For instance, the core "Email::Store::Entity" plugin module addresses the idea of "people" in the email universe, allowing you to search for mails to or from particular people; (despite their changing names or email addresses) "Email::Store::Thread" interfaces "Email::Store" to "Mail::Thread" allowing you to navigate mails by their position in a mail thread; the planned non-core "Email::Store::Plucene" module plugs into the indexing process and stores information about emails in a Plucene search index for quick retrieval later, and so on.

MailStore is a tool that is built in python and provides a mail proxy for POP3,IMAP4 and SMTP protocols. However, beyond usual proxies, it makes a backup of all incoming and outgoing email and stores them in a Maildir format.

Emails then can be accessed through an IMAP server run on the same machine using the backup Maildirs as mailboxes.

The idea is to provide a realtime , centralized backup of all incoming and outgoing of an organization without the need of user intervention, especially for organizations that use shared email hosting. Many of this hosting providers allow for only POP3 based access of the email.

Secondly, due to its shared hosting environment , there is limited space hence all email ends up being downloaded directly to the client. Any backup effort has to be taken up by the user on a periodical basis. This is prone to problems due to the fact that users might either forget or a data disaster might happen in between a backup cycle.

With a backup proxy like this all email is always available at the backup proxy. Any backup need be done by the administrator only at the proxy server itself. This we believe to be a much more convenient task then backing up user systems individually.

Secondly the MailStore server will always have all the emails the user has sent or received at any point ,hence the backup will always be current. To access the email, a local IMAP server can be run that will provide the user with access to the email that has been backed up. The user may then add this account to their email client and backup all the email out of it locally. (E.g. In Outlook you would probably export all the email in the account). Following that the user will import back the mail back into its original account.

Thirdly , the system requires minimal administrator involvement. It handles the creation of new maildirs for new domain/user combinations. Hence administrators dont have extra config files to play with whenevr new users are added to the system. Whether a user exists or not is left up to the mailserver that mailStore is proxying.

The mailStore system is built in Python. It has been tested with Python 2.3 and 2.4. Any system which support Python 2.3/ Python 2.4 should be able to run it.

Email::AutoReply is a Perl extension for writing email autoresponders.

SYNOPSIS

use Email::AutoReply;
my $auto = Email::AutoReply->new;
$auto->reply;

This module may be useful in writing autoresponders. The example code above will try to respond (using Sendmail) to an email message given as standard input.

The module will reply once to each email address it sees, storing sent-to addresses in a database. This database class is Email::AutoReply::DB::BerkeleyDB by default, but any class that implements Email::AutoReply::DB may be used.

mairix is a tool for indexing and searching email messages stored in Maildir, MH, or mbox folders. The index contains a map of which words occur in which parts of which messages.
Searches on this index are fast and generate symlinks to the matching messages in a new Maildir or MH folder, or copies of matching messages in an mbox folder, which can be browsed normally in a mail client.
Main features:
- Indexing is fast. It runs incrementally on new messages - any particular message only gets scanned once in the lifetime of the index file.
- The search mode populates a "virtual" maildir (or MH) folder with symlinks which point to the real messages. This folder can be opened as usual in your mail program. (Note, if messages are in mbox folders, copies are made. Similarly if the virtual folder has mbox format, it is filled with copies of the matched messages.)
- The search mode is very fast.
- Indexing and searching works on the basis of words. The index file tabulates which words occur in which parts (particular headers + body) of which messages.
Enhancements:
- A handful of bugs were fixed: crashes in the name/value parser, handling of . and .. in MH folders, broken mbox folders, and indexing when the database only contained a single message.

Dbmail is the name of a group of programs that enable the possiblilty of storing and retrieving mail messages from a database. Currently PostgreSQL and MySQL can be used as database backends.
The upcoming version 2.2 that is under development also supports SQLite, an embedded SQL database system, and ldap for storing userdata. Development and support of dbmail is done by IC&S and NFG, two Dutch companies specializing in Linux development and support.
Main features:
Scalability
- Dbmail is as scalable as the database system that is used for the mail storage. In theory millions of accounts can be managed using dbmail. One could, for example, run 4 different servers with the pop3 daemon each connecting to the same database (cluster) server.
Manageability
- Dbmail is based upon a database. Dbmail can be managed by changing settings in the database (f.e. using PHP/Perl/SQL), without needing shell access.
Speed
- Dbmail uses very efficient, database specific queries for retrieving mail information. This is much faster then parsing a filesystem.
Security
- Dbmail has got nothing to do with the filesystem or interaction with other programs in the Unix environment which need special permissions. Dbmail is as secure as the database its based upon.
Flexibility
- Changes on a Dbmail system (adding of users, changing passwords etc.) are effective immediately.
How does it work?
DBMail is made up of several components. A normal MTA (Postfix, SendMail, QMail, Exim) is used for accepting messages. The MTA hands the messages over to dbmail-smtp, using a pipe interface, or dbmail-lmtpd, using LMTP (Local Mail Transport Protocol). These programs take care of delivering the message into the database. Messages can be retreived from the database using dbmail-pop3d, using the POP3 protocol, and dbmail-imapd, using the IMAP4Rev1 protocol.
The whole email is stored in the database. That includes attachments. The DBMail programs do not have to touch the filesystem to retreive or insert emails. User information is also stored in the database, so users do not need an account on the machines DBMail is running on.
Enhancements:
- This release features greatly improved handling of UTF8 email, has many fixes for IMAP protocol errors, and resolves a number of serious memory leaks.
- A new feature was added to dbmail-export to allow fine-grained message selection and post-export deletion.

MailArchiva is a powerful email archiving solution. MailArchiva project is all you need to ensure that your organizations emails are backed up permanently. It automatically retrieves emails from Microsoft Exchange and stores them on multiple hard disks.
MailArchiva stores all incoming, outgoing, and internal emails for long-term storage. In doing so, it enables your company to retain valuable knowledge and comply with US and EU legislation such as the Sarbanes Oxley Act.
MailArchiva ensures that the integrity of your information remains intact. Emails are stored directly on the filesystem, as opposed to a database. As a result, there are no hidden database maintenance costs and the integrity of archived information is not subject to database corruption.
MailArchiva is a turnkey product that is easy to install and use. A clean install usually takes approximately 30 minutes.
MailArchiva is a commercially supported open source product. You have the assurance of commercial grade support combined with open source benefits.
Enhancements:
- This release introduces several major enhancements and bugfixes.
- For instance, MailArchiva is now fully internationalized, supporting indexing, search, and retrieval of emails in multiple languages.
- The archiving server has been completely rearchitected to utilize Java 1.6 contructs.
- The Microsoft Exchange archiving agent has been redesigned from the ground up.

G-whale project is a simple, text-based mail user agent.
A mail user agent (MUA) is a program that allows you to receive and send e-mail messages; its usually just called an e-mail program.
To use an MUA such as Eudora or Microsoft Outlook, you install the MUA program on your computer and then use it to download and store e-mail messages to your computer; it will also allow you to read or write messages offline.
Web-based MUAs, such as Hotmail and Yahoo, store messages on their own mail servers and allow access to them through a Web page. An MUA is sometimes called an e-mail agent or an e-mail client.
Enhancements:
- A configuration file is now used.

DBI is a database independent interface for Perl.

SYNOPSIS

use DBI;

@driver_names = DBI->available_drivers;
%drivers = DBI->installed_drivers;
@data_sources = DBI->data_sources($driver_name, %attr);

$dbh = DBI->connect($data_source, $username, $auth, %attr);

$rv = $dbh->do($statement);
$rv = $dbh->do($statement, %attr);
$rv = $dbh->do($statement, %attr, @bind_values);

$ary_ref = $dbh->selectall_arrayref($statement);
$hash_ref = $dbh->selectall_hashref($statement, $key_field);

$ary_ref = $dbh->selectcol_arrayref($statement);
$ary_ref = $dbh->selectcol_arrayref($statement, %attr);

@row_ary = $dbh->selectrow_array($statement);
$ary_ref = $dbh->selectrow_arrayref($statement);
$hash_ref = $dbh->selectrow_hashref($statement);

$sth = $dbh->prepare($statement);
$sth = $dbh->prepare_cached($statement);

$rc = $sth->bind_param($p_num, $bind_value);
$rc = $sth->bind_param($p_num, $bind_value, $bind_type);
$rc = $sth->bind_param($p_num, $bind_value, %attr);

$rv = $sth->execute;
$rv = $sth->execute(@bind_values);
$rv = $sth->execute_array(%attr, ...);

$rc = $sth->bind_col($col_num, $col_variable);
$rc = $sth->bind_columns(@list_of_refs_to_vars_to_bind);

@row_ary = $sth->fetchrow_array;
$ary_ref = $sth->fetchrow_arrayref;
$hash_ref = $sth->fetchrow_hashref;

$ary_ref = $sth->fetchall_arrayref;
$ary_ref = $sth->fetchall_arrayref( $slice, $max_rows );

$hash_ref = $sth->fetchall_hashref( $key_field );

$rv = $sth->rows;

$rc = $dbh->begin_work;
$rc = $dbh->commit;
$rc = $dbh->rollback;

$quoted_string = $dbh->quote($string);

$rc = $h->err;
$str = $h->errstr;
$rv = $h->state;

$rc = $dbh->disconnect;