Indices
GNU Mailutils offers a general purpose library whose aim is to provide a rich set of functions for accessing different mailbox formats and mailers.
For more information on,
Wherever the mail is and whatever format it is stored in, it is operated
upon using the same set of functions. To unified the C API,
GNU Mailutils offers a heteroclite set of objects that work in
aggregation to do operations on
emails. Each object does a specific task and delegates non-related tasks to
others. The object comes alive by specifying a URL parameter when
created, it will indicate the storage format or protocol
(POP3, IMAP4, MH, MAILDIR, etc ..).
folder_t url_t
-/var/mail- +- .. ->+-----------------+ +-->+------------+
( alain *-)-+ | | url_t *-|---+ | port |
----------- | | |-----------------| | hostname |
( jakob *-)-+--+ | auth_t *-|---+ | file |
----------- | |-----------------| | | ... |
( jeff *-)-+ | stream_t | | +------------+
----------- | |-----------------| |
( shaleh*-)-+ | ..... | | auth_t
---------- |-----------------| +-->+------------+
+---|-* mailbox_t[] | | ticket_t |
mailbox_t | +-----------------+ +------------+
+----------------+<-+
| locker_t *--|-------------+
|----------------| |
| url_t | | locker_t
|----------------| +-------->+---------+
| stream_t | | lock |
|----------------| | unlock |
| message_t[] *-|-------+ +---------+
+----------------+ | envelope_t
| +-------->+-----------+
message_t | | | date |
+----------------+<------+ | | from |
| envelope_t *-|------------------+ | to |
|----------------| header_t +-----------+
| header_t *-|------------>+--------------+
|----------------| | stream_t |
| body_t *-|----+ +--------------+
+----------------+ | body_t
+-->+--------------+
| stream_t |
+--------------+
As an example, here is a simplified version of from command. It
lists the From and Subject headers of every mail in a mailbox.
/* sfrom, Simple From */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <mailutils/mailutils.h>
int
main (int argc, const char **argv)
{
char *from;
char *subject;
mailbox_t mbox;
int status;
size_t msgno, total = 0;
/* Register the type of mailbox. IMAP4, POP3 and local format */
{
list_t registrar;
registrar_get_list (®istrar);
list_append (registrar, imap_record);
list_append (registrar, path_record);
list_append (registrar, pop_record);
}
status = mailbox_create_default (&mbox, argv[1]);
if (status != 0)
{
fprintf (stderr, "mailbox_create: %s\n", mu_errstring (status));
exit (EXIT_FAILURE);
}
status = mailbox_open (mbox, MU_STREAM_READ);
if (status != 0)
{
fprintf (stderr, "mailbox_open: %s\n", mu_errstring (status));
exit (EXIT_FAILURE);
}
mailbox_messages_count (mbox, &total);
for (msgno = 1; msgno <= total; msgno++)
{
message_t msg;
header_t hdr;
if ((status = mailbox_get_message (mbox, msgno, &msg)) != 0
|| (status = message_get_header (msg, &hdr)) != 0)
{
fprintf (stderr, "Error message: %s\n",
mu_errstring (status));
exit (EXIT_FAILURE);
}
if (header_aget_value (hdr, MU_HEADER_FROM, &from))
from = strdup ("(NO FROM)");
if (header_aget_value (hdr, MU_HEADER_SUBJECT, &subject))
subject = strdup("(NO SUBJECT)");
printf ("%s\t%s\n", from, subject);
free (from);
free (subject);
}
mailbox_close (mbox);
mailbox_destroy (&mbox);
return 0;
}
Here is a sample output produced by this program:
% MAIL=pop://alain@localhost ./sfrom Passwd: xxxx Jim Meyering <meyering@foo.org> fetish(shellutils) beta François Pinard <pinard@bar.org> recode new alpha ...
/* Prefix folder_ is reserve */#include <mailutils/folder.h>
folder_t url_t
-/var/mail- +---//---->/-----------------\ +-->/-----------\
( alain *-)-+ | | url_t *-|----+ | port |
----------- | | |-----------------+ | hostname |
( jakob *-)-+--+ | observer_t *-| | file |
----------- | |-----------------+ | ... |
( jeff *-)-+ | stream_t | \-----------/
----------- | |-----------------|
( sean *-)-+ | auth_t |
---------- |-----------------|
| mailbox_t(1) |
|-----------------|
| mailbox_t(2) |
| ...... |
| mailbox_t(n) |
\-----------------/
| int folder_create (folder_t *, const char *url) | Function |
| void folder_destroy (folder_t *) | Function |
| int folder_open (folder_t, int flag) | Function |
| int folder_close (folder_t) | Function |
| int folder_delete (folder_t, const char *mailbox) | Function |
| int folder_rename (folder_t, const char *, const char *mailbox) | Function |
| int folder_subscribe (folder_t, const char *mailbox) | Function |
| int folder_unsubscribe (folder_t, const char *mailbox) | Function |
| int folder_list (folder_t, const char *ref, const char *wcard, iterator_t *) | Function |
| int folder_lsub (folder_t, const char *ref, const char *wcar, iterator_t *) | Function |
| int folder_get_stream (folder_t, stream_t *) | Function |
| int folder_set_stream (folder_t, stream_t) | Function |
| int folder_get_observable (folder_t, observable_t *) | Function |
| int folder_get_debug (folder_t, debug_t *) | Function |
| int folder_set_debug (folder_t, debug_t) | Function |
| int folder_get_authority (folder_t, authority_t *) | Function |
| int folder_set_authority (folder_t, authority_t) | Function |
| int folder_get_url (folder_t, url_t *) | Function |
| int folder_set_url (folder_t, url_t) | Function |
/* Prefix mailbox_ is reserved */#include <mailutils/mailbox.h>
| mailbox_t | Data Type |
The mailbox_t object is used to hold information and it is an opaque
data structure to the user. Functions are provided to retrieve information
from the data structure.
|
mailbox_t url_t
-/var/mail- +---//---->/-----------------\ +-->/-----------\
( alain ) | | url_t *-|----+ | port |
----------- | |-----------------+ | hostname |
( jakob *-)----+ | observer_t *-| | file |
----------- |-----------------+ | ... |
( jeff ) | stream_t | \-----------/
----------- |-----------------|
( sean ) | locker_t |
---------- |-----------------|
| message_t(1) |
|-----------------|
| message_t(2) |
| ...... |
| message_t(n) |
\-----------------/
| int mailbox_append_message (mailbox_t mbox, message_t message) | Function |
|
The message is appended to the mailbox mbox.
The return value is
|
| int mailbox_close (mailbox_t mbox) | Function |
|
The stream attach to mbox is closed.
The return value is
|
| int mailbox_create (mailbox_t *pmbox, const char *name) | Function |
The function mailbox_create allocates and initializes pmbox.
The concrete mailbox type instantiate is based on the scheme of the url name.
The return value is
|
| int mailbox_create_default (mailbox_t *pmbox, const char *name) | Function |
Create a mailbox with mailbox_create () based on the environment
variable $MAIL or the string formed by
_PATH_MAILDIR/user" or $LOGNAME if user is null,
|
| void mailbox_destroy (mailbox_t *pmbox) | Function |
| Destroys and releases resources held by pmbox. |
| int mailbox_expunge (mailbox_t mbox) | Function |
|
All messages marked for deletion are removed.
The return value is
|
| int mailbox_get_folder (mailbox_t mbox, folder_t *folder) | Function |
|
Get the folder.
The return value is
|
| int mailbox_get_debug (mailbox_t mbox, debug_t *debug) | Function |
Get a debug object.
The return value is 0 on success and a code number on error conditions:
|
| int mailbox_get_locker (mailbox_t mbox, locker_t *plocker) | Function |
|
Return the locker object.
The return value is
|
| int mailbox_get_message (mailbox_t mbox, size_t msgno, message_t *pmessage) | Function |
|
Retrieve message number msgno, pmessage is allocated and
initialized.
The return value is
|
| int mailbox_get_observable (mailbox_t mbox mbox, observable_t*observable) | Function |
|
Get the observable object.
The return value is
|
| int mailbox_get_property (mailbox_t mbox, property_t *property) | Function |
Get the property object.
The return value is 0 on success and a code number on error conditions:
|
| int mailbox_get_size (mailbox_t mbox, off_t *psize) | Function |
|
Gives the mbox size.
The return value is
|
| int mailbox_get_stream (mailbox_t mbox, stream_t *pstream) | Function |
|
The mailbox stream is put in pstream.
The return value is
|
| int mailbox_get_ticket (mailbox_t mbox, ticket_t ticket) | Function |
The return value is 0 on success and a code number on error conditions:
|
| int mailbox_get_url (mailbox_t mbox, url_t *purl) | Function |
|
Gives the constructed url.
The return value is
|
| int mailbox_is_modified (mailbox_t mbox) | Function |
|
Check if the mailbox been modified by an external source.
The return value is
|
| int mailbox_message_unseen (mailbox_t mbox, size_t *pnumber); | Function |
|
Give the number of first unseen message in mbox.
The return value is
|
| int mailbox_messages_count (mailbox_t mbox, size_t *pnumber); | Function |
|
Give the number of messages in mbox.
The return value is
|
| int mailbox_messages_recent (mailbox_t mbox, size_t *pnumber); | Function |
|
Give the number of recent messages in mbox.
The return value is
|
| int mailbox_open (mailbox_t mbox, int flag) | Function |
A connection is open, if no stream was provided, a stream
is created based on the mbox type. The flag can be OR'ed.
See stream_create for flag's description.
The return value is
|
| int mailbox_scan (mailbox_t mbox, size_t msgno, size_t *pcount); | Function |
|
Scan the mailbox for new messages starting at message msgno.
The return value is
|
| int mailbox_set_locker (mailbox_t mbox, locker_t locker) | Function |
|
Set the type of locking done by the mbox.
The return value is
|
| int mailbox_set_stream (mailbox_t mbox, stream_t stream) | Function |
|
Set the stream connection to use for the mailbox.
The return value is
|
| int mailbox_set_ticket (mailbox_t mbox, ticket_t ticket) | Function |
The ticket will be set on the auth_t object on creation.
The return value is
|
| int mailbox_uidnext (mailbox_t mbox, size_t *pnumber); | Function |
|
Give the next predicted uid for mbox.
The return value is
|
| int mailbox_uidvalidity (mailbox_t mbox, size_t *pnumber); | Function |
|
Give the uid validity of mbox.
The return value is
|
/* Prefix mailer_ is reserved */#include <mailutils/mailer.h>
The API is still changing.
| int mailer_create (mailer_t *, const char *) | Function |
| void mailer_destroy (mailer_t *) | Function |
| int mailer_open (mailer_t, int flags) | Function |
| int mailer_close (mailer_t) | Function |
| int mailer_send_message (mailer_t mailer, message_t msg, address_t from, address_t to); | Function |
|
If from is not NULL, it must contain a single fully qualified RFC2822 email address which will be used as the envelope from address. This is the address to which delivery status notifications are sent, so it never matters what it is set to until it REALLY matters. This is equivalent to sendmail's -f flag. The default for from is provided by the specific mailer. If to is not NULL, then the message will be sent to the list of addresses that it specifies. The default for to is to use the contents of the standard "To:", "Cc:", and "Bcc:" fields, this is equivalent to sendmail's -t flag. Note: the previous implementation of mailer_send_message() was equivalent to having both from and to be NULL. |
| int mailer_get_property (mailer_t, property_t *) | Function |
| int mailer_get_stream (mailer_t, stream_t *) | Function |
| int mailer_set_stream (mailer_t, stream_t) | Function |
| int mailer_get_debug (mailer_t, debug_t *) | Function |
| int mailer_set_debug (mailer_t, debug_t) | Function |
| int mailer_get_observable (mailer_t, observable_t *) | Function |
| int mailer_get_url (mailer_t, url_t *) | Function |
Some possible use cases the API must support are:
- original submission
1 - fill in header addresses
2 - mailer_send_message(mailer, msg, NULL, NULL);
- from will be filled in if missing,
- bcc's will be deleted before delivery to a non-bcc address,
- message-id and date will be added, if missing,
- a to: or apparently-to: will be added if non is present (for RFC compliance)
- MTA-style .forward ( and sieve-style redirect )
1 - get the envelope from of the message to be forwarded
2 - mailer_send_message(mailer, msg, from, to)
- MUA-style bounce
1 - add Resent-[to,from,....]
2 - mailer_send_message(mailer, msg, NULL, to)
- DSN "bounce"
1 - compose DSN
2 - mailer_deliver(mailer, msg, address_t( "<>" ), to)
Don't want mail loops, so the null but valid SMTP address of <> is the envelope from.
/sbin/sendmail isn't always sendmail... sometimes its a sendmail-compatible wrapper, so assume /sbin/sendmail understands only a recipient list, -f and -oi, these seem to be pretty basic. Cross fingers.
Pipe to "/sbin/sendmail -oi [-f from] [to...]", supplying -f if there was a from, and supplying the recipient list from the to (if there is no recipient list, assume it will read the message contents for the recipients).
Note: since the stdout and stderr of sendmail is closed, we have no way of ever giving feedback on failure. Also, what should the return code be from mailer_send_message() when sendmail returns 1? 1 maps to EPERM, which is less than descriptive!
This mailer does NOT canonicalize the message. This must be done before sending the message, or it may be assumed that the MTA will do so.
It does blind out the Bcc: header before sending, though.
Note: mutt always puts the recipient addresses on the command line, even bcc ones, do we strip the bcc before forwarding with SMTP?
An address that has no domain is not and RFC822 email address. What do I do with them? Should the user of the API be responsible for determining what is mean by email to "john" means? Or should the be able to configure sendmail to decide globally what this means. If so, we can pass the address to sendmail, but we have to decide for SMTP! So, right now these addresses are rejected. This could be changed.
#include <mailutils/message.h>/* Prefix message_ is reserve */
The message_t object is a convenient way to manipulate messages. It
encapsulates the envelope_t, the header_t and the body_t.
mailbox_t
__________ message_t
(message[1]) +------>+-----------------------+
---------- | | envelope_t |
(message[2]) | |-----------------------|
---------- | | header_t |
(message[3])--------+ |-----------------------|
---------- | body_t |
(message[n]) |-----------------------|
---------- | attribute_t |
|-----------------------|
| stream_t |
+-----------------------+
| void message_create (message_t *msg, void *owner) | Function |
| void message_destroy (message_t *msg, void *owner) | Function |
| The resources allocate for msg are freed. |
| int message_get_header (message_t msg, header_t *pheader) | Function |
| Retrieve msg header. |
| int message_set_header (message_t msg, header_t header, void *owner) | Function |
| int message_get_body (message_t msg, body_t *pbody) | Function |
| int message_set_body (message_t msg, body_t body, void *owner) | Function |
| int message_is_multipart (message_t msg, int *pmulti) | Function |
| Set *pmulti to non-zero value if msg is multi-part. |
| int message_get_num_parts (message_t msg, size_t *nparts) | Function |
| int message_get_part (message_t msg, size_t part, message_t *msg) | Function |
| int message_get_stream (message_t msg, stream_t *pstream) | Function |
| int message_set_stream (message_t msg, stream_t stream,void *owner ) | Function |
| int message_get_attribute (message_t msg, attribute_t *pattribute) | Function |
| int message_set_attribute (message_t msg, attribute_t attribute, void *owner) | Function |
| int message_get_envelope (message_t msg, envelope_t *penvelope) | Function |
| int message_set_envelope (message_t msg, envelope_t envelope, void *owner) | Function |
| int message_get_uid (message_t msg, size_t *uid) | Function |
| int message_get_uidl (message_t msg, char *buffer, size_t buflen, size_t *pwriten) | Function |
| int message_set_uidl (message_t msg, int (*_get_uidl)(message_t, char *, size_t, size_t *), void *owner) | Function |
| int message_get_observable (message_t msg, observable_t *observable) | Function |
| int message_create_attachment (const char *content_type, const char *encoding, const char *filename, message_t *newmsg) | Function |
| int message_save_attachment (message_t msg, const char *filename, void **data) | Function |
| int message_encapsulate (message_t msg, message_t *newmsg, void **data) | Function |
| int message_unencapsulate (message_t msg, message_t *newmsg, void **data); | Function |
/* Prefix envelope_ is reserved */#include <mailutils/envelope.h>
| int envelope_date (envelope_t, char *, size_t, size_t *); | Function |
|
Get the date that the message was delivered to the mailbox, in something close to ANSI ctime() format: Mon Jul 05 13:08:27 1999. |
| int envelope_sender (envelope_t, char *, size_t, size_t *); | Function |
|
Get the address that this message was reportedly received from. This would be the "mail from" argument if the message was delivered or received via SMTP, for example. |
| int envelope_get_message (envelope_t, message_t *); | Function |
| int envelope_create (envelope_t *, void *); | Function |
| Primarily for internal use. |
| void envelope_destroy (envelope_t *, void *); | Function |
| Primarily for internal use. |
| int envelope_set_sender (envelope_t, int (*_sender) __P ((envelope_t, char *, size_t, size_t*)), void *); | Function |
|
Primarily for internal use. The implementation of envelope_t depends on the mailbox type, this allows the function which actually gets the sender to be set by the creator of an envelope_t. |
| int envelope_set_date (envelope_t, int (*_date) __P ((envelope_t, char *, size_t, size_t *)), void *); | Function |
|
Primarily for internal use. The implementation of envelope_t depends on the mailbox type, this allows the function which actually gets the date to be set by the creator of an envelope_t. |
/* Prefix header_ is reserved */#include <mailutils/header.h>
So far we plan support for RFC822 and plan for RFC1522. with RFC1522 non ASCII characters will be encoded.
| int header_create (header_t *hdr, const char *blurb, size_t len, void *owner) | Function |
| Initialize a hdr to a supported type. If blurb is not NULL, it is parsed. |
| void header_destroy (header_t *hdr, void *owner) | Function |
| The resources allocated for hdr are freed. |
| int header_set_value (header_t hdr, const char *fn, const char *fv, size_t n, int replace) | Function |
|
Set the field-name fn to field-value fv of size n in
hdr. If replace is non-zero the initial value is replaced, if zero
it is appended.
Some basic macros are already provided for rfc822.
|
| int header_get_value (header_t hdr, const char *fn, char *fv, size_t len, size_t *n) | Function |
| Value of field-name fn is returned in buffer fv of size len. The number of bytes written is put in n. |
| int header_aget_value (header_t hdr, const char *fn, char **fv) | Function |
| The value is allocated. |
| int header_get_stream (header_t hdr, stream_t *pstream) | Function |
| int header_set_size (header_t hdr, size_t *size) | Function |
| int header_set_lines (header_t hdr, size_t *lpines) | Function |
/* Prefix body_ is reserved */#include <mailutils/body.h>
| int body_create (body_t *body, void *owner) | Function |
| Initialize an object bdy. |
| void body_destroy (body_t *pbody) | Function |
| The resources allocate are release. |
| int body_get_stream (body_t body, stream_t *pstream) | Function |
| int body_set_stream (body_t body, stream_t stream, void *owner) | Function |
| int body_get_filename __P ((body_t body, char *buffer, size_tbuflen, size_t *pwriten) | Function |
| int body_set_filename (body_t body, const char*buffer) | Function |
| int body_size (body_t body, size_t*psize) | Function |
| int body_lines (body_t body, size_t *plines) | Function |
/* Prefix attribute_ is reserved */#include <mailutils/attribute.h>
| int attribute_create (attribute_t *pattribute) | Function |
| void attribute_destroy (attribute_t *pattribute) | Function |
| int attribute_is_seen (attribute_t attribute) | Function |
| int attribute_is_answered (attribute_t attribute) | Function |
| int attribute_is_flagged (attribute_t attribute) | Function |
| int attribute_is_deleted (attribute_t attribute) | Function |
| int attribute_is_draft (attribute_t attribute) | Function |
| int attribute_is_recent (attribute_t attribute) | Function |
| int attribute_is_read (attribute_t attribute) | Function |
| int attribute_set_seen (attribute_t attribute) | Function |
| int attribute_set_answered (attribute_t attribute) | Function |
| int attribute_set_flagged (attribute_t attribute) | Function |
| int attribute_set_deleted (attribute_t attribute) | Function |
| int attribute_set_draft (attribute_t attribute) | Function |
| int attribute_set_recent (attribute_t attribute) | Function |
| int attribute_set_read (attribute_t attribute) | Function |
| int attribute_unset_seen (attribute_t attribute) | Function |
| int attribute_unset_answered (attribute_t attribute) | Function |
| int attribute_unset_flagged (attribute_t attribute) | Function |
| int attribute_unset_deleted (attribute_t attribute) | Function |
| int attribute_unset_draft (attribute_t attribute) | Function |
| int attribute_unset_recent (attribute_t attribute) | Function |
| int attribute_unset_read (attribute_t attribute) | Function |
| int attribute_is_equal (attribute_t att1, attribute_t att2) | Function |
| int attribute_copy (attribute_t dst, attribute_t src) | Function |
| int string_to_attribute (const char *buf, attribute_t *pattr) | Function |
| int attribute_to_string (attribute_t attr, char *buf, size_t len, size_t *pwriten) | Function |
#include <mailutils/stream.h>
These generic flags are interpreted as appropriate to the specific streams.
MU_STREAM_READ
MU_STREAM_WRITE
MU_STREAM_RDWR
MU_STREAM_APPEND
MU_STREAM_CREAT
MU_STREAM_NONBLOCK
MU_STREAM_NO_CHECK
MU_STREAM_NO_CLOSE
| int file_stream_create (stream_t *pstream, const char *filename, int flags) | Function |
| int tcp_stream_create (stream_t *pstream, const char *host, int port, int flags) | Function |
| int mapfile_stream_create (stream_t *pstream, const char *filename, int flags) | Function |
| int memory_stream_create (stream_t *pstream, const char *filename, int flags) | Function |
| int encoder_stream_create (stream_t *pstream, stream_t iostream, const char *encoding) | Function |
| int decoder_stream_create (stream_t *pstream, stream_t iostream, const char *encoding) | Function |
| int stdio_stream_create (stream_t *pstream, FILE* stdio, int flags) | Function |
| If MU_STREAM_NO_CLOSE is specified, fclose() will not be called on stdio when the stream is closed. |
| void stream_destroy (stream_t *pstream, void *owner) | Function |
| int stream_open (stream_t stream) | Function |
| int stream_close (stream_t stream) | Function |
| int stream_is_seekable (stream_t stream) | Function |
| int stream_get_fd (stream_t stream, int *pfd) | Function |
| int stream_read (stream_t stream, char *buffer, size_t buflen, off_t offset, size_t *pwriten) | Function |
| int stream_readline (stream_t stream, char *buffer, size_t buflen, off_t offset, size_t *pwriten) | Function |
| int stream_size (stream_t stream, off_t *psize) | Function |
| int stream_truncate (stream_t stream, off_t size) | Function |
| int stream_write (stream_t stream, const char *buffer, size_t buflen, off_t offset, size_t *pwriten) | Function |
| int stream_setbufsiz (stream_t stream, size_t size) | Function |
| int stream_flush (stream_t stream) | Function |
These functions will typically only be useful to implementors of streams.
| int stream_create (stream_t *pstream, int flags, void *owner) | Function |
| Used to implement a new kind of stream. |
| int stream_get_flags (stream_t stream, int *pflags) | Function |
| int stream_get_state (stream_t stream, int *pstate) | Function |
|
An example using tcp_stream_create to make a simple web client:
/* This is an example program to illustrate the use of stream functions.
It connects to a remote HTTP server and prints the contents of its
index page */
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <mailutils/mailutils.h>
const char *wbuf = "GET / HTTP/1.0\r\n\r\n";
char rbuf[1024];
int
main ()
{
int ret, off = 0, fd;
stream_t stream;
size_t nb;
fd_set fds;
ret = tcp_stream_create (&stream, "www.gnu.org", 80, MU_STREAM_NONBLOCK);
if (ret != 0)
{
mu_error ( "tcp_stream_create: %s\n", mu_errstring (ret));
exit (EXIT_FAILURE);
}
connect_again:
ret = stream_open (stream);
if (ret != 0)
{
if (ret == EAGAIN)
{
ret = stream_get_fd (stream, &fd);
if (ret != 0)
{
mu_error ( "stream_get_fd: %s\n", mu_errstring (ret));
exit (EXIT_FAILURE);
}
FD_ZERO (&fds);
FD_SET (fd, &fds);
select (fd + 1, NULL, &fds, NULL, NULL);
goto connect_again;
}
mu_error ( "stream_open: %s\n", mu_errstring (ret));
exit (EXIT_FAILURE);
}
ret = stream_get_fd (stream, &fd);
if (ret != 0)
{
mu_error ( "stream_get_fd: %s\n", mu_errstring (ret));
exit (EXIT_FAILURE);
}
write_again:
ret = stream_write (stream, wbuf + off, strlen (wbuf), 0, &nb);
if (ret != 0)
{
if (ret == EAGAIN)
{
FD_ZERO (&fds);
FD_SET (fd, &fds);
select (fd + 1, NULL, &fds, NULL, NULL);
off += nb;
goto write_again;
}
mu_error ( "stream_write: %s\n", mu_errstring (ret));
exit (EXIT_FAILURE);
}
if (nb != strlen (wbuf))
{
mu_error ( "stream_write: %s\n", "nb != wbuf length");
exit (EXIT_FAILURE);
}
do
{
ret = stream_read (stream, rbuf, sizeof (rbuf), 0, &nb);
if (ret != 0)
{
if (ret == EAGAIN)
{
FD_ZERO (&fds);
FD_SET (fd, &fds);
select (fd + 1, &fds, NULL, NULL, NULL);
}
else
{
mu_error ( "stream_read: %s\n", mu_errstring (ret));
exit (EXIT_FAILURE);
}
}
write (2, rbuf, nb);
}
while (nb || ret == EAGAIN);
ret = stream_close (stream);
if (ret != 0)
{
mu_error ( "stream_close: %s\n", mu_errstring (ret));
exit (EXIT_FAILURE);
}
stream_destroy (&stream, NULL);
exit (EXIT_SUCCESS);
}
/* Prefix iterator_ is reserved */#include <mailutils/iterator.h>
| int iterator_create (iterator_t *) | Function |
| void iterator_destroy (iterator_t *) | Function |
| int iterator_first (iterator_t) | Function |
| int iterator_next (iterator_t) | Function |
| int iterator_current (iterator_t, void **pitem) | Function |
| int iterator_is_done (iterator_t) | Function |
/* Prefix auth_ is reserved */#include <mailutils/auth.h>
There are many ways to authenticate to a server. To be flexible the
authentication process is provided by two objects auth_t and
ticket_t. The auth_t can implement different protocol like
APOP, MD5-AUTH, One Time Passwd etc .. By default if a mailbox
does not understand or know how to authenticate it falls back to
user/passwd authentication. The ticket_t is a way for
Mailboxes and Mailers provide a way to authenticate when the URL does not
contain enough information. The default action is to call the function
auth_authenticate which will get the user and passwd
if not set, this function can be overridden by a custom method.
| int auth_create (auth_t *pauth, void *owner) | Function |
| void auth_destroy (auth_t *pauth, void *owner) | Function |
| int auth_prologue (auth_t auth) | Function |
| int auth_authenticate (auth_t auth, char **user, char **passwd) | Function |
| int auth_epilogue (auth_t auth) | Function |
A simple example of an authenticate function:
#include <mailutils/auth.h>
#include <stdio.h>
#include <string.h>
int
my_authenticate (auth_t auth, char **user, char **passwd)
{
char u[128] = "";
char p[128] = "";
/* prompt the user name */
printf ("User: ");
fflush (stdout);
fgets (u, sizeof (u), stdin);
u[strlen (u) - 1] = '\0'; /* nuke the trailing NL */
/* prompt the passwd */
printf ("Passwd: "); fflush (stdout);
echo_off ();
fgets (p, sizeof(p), stdin);
echo_on ();
p[strlen (p) - 1] = '\0';
/* duplicate */
*user = strdup (u);
*passwd = strdup (p);
return 0;
}
The Internet address format is defined in RFC 822. RFC 822 has been updated, and is now superceeded by RFC 2822, which makes some corrections and clarifications. References to RFC 822 here apply equally to RFC 2822./* Prefix address_ is reserved */#include <mailutils/address.h>
The RFC 822 format is more flexible than many people realize, here
is a quick summary of the syntax this parser implements, see
RFC 822 for the details. "[]" pairs mean "optional", "/" means "one or
the other", and double-quoted characters are literals.
addr-spec = local-part "¨domain
mailbox = addr-spec ["(" display-name ")"] /
[display-name] "<" [route] addr-spec ">"
mailbox-list = mailbox ["," mailbox-list]
group = display-name ":" [mailbox-list] ";"
address = mailbox / group / unix-mbox
address-list = address ["," address-list]
unix-mbox is a non-standard extension meant to deal with the common practice of using user names as addresses in mail utilities. It allows addresses such as "root" to be parsed correctly. These are NOT valid internet email addresses, they must be qualified before use.
Several address functions have a set of common arguments with consistent semantics, these are described here to avoid repetition.
Since an address-list may contain multiple addresses, they are accessed by a one-based index number, no. The index is one-based because pop, imap, and other message stores commonly use one-based counts to access messages and attributes of messages.
If len is greater than 0 it is the length of the buffer
buf, and as much of the component as possible will be copied
into the buffer. The buffer will be null terminated.
The size of a particular component may be queried by providing 0
for the len of the buffer, in which case the buffer is optional.
In this case, if n is provided *n is assigned the length of
the component string.
| address_t | Data Type |
The address_t object is used to hold information about a parsed
RFC822 address list, and is an opaque
data structure to the user. Functions are provided to retrieve information
about an address in the address list.
|
| int address_create (address_t *addr, const char *string) | Function |
|
This function allocates and initializes addr by parsing the
RFC822 address-list string.
The return value is
|
| int address_createv (address_t *addr, const char *sv, size_t len) | Function |
This function allocates and initializes addr by parsing the
array of pointers to RFC822 address-lists in sv. If len is
-1, then sv must be null-terminated in the fashion of argv,
otherwise len is the length of the array.
The return value is
|
| void address_destroy (address_t *addr) | Function |
| The addr is destroyed. |
| int address_get_email (address_t *addr, size_t no, char* buf, size_t len, size_t* n) | Function |
|
Accesses the noth email address component of the address list. This address is the plain email address, correctly quoted, suitable for using in an smtp dialog, for example, or as the address part of a contact book entry. Note that the entry may be valid, but be a group name. In this case success
is returned, but the length of the address is The return value is
|
| int address_aget_email (address_t *addr, size_t no, char** bufp) | Function |
|
As above, but mallocs the email address, if present, and write a pointer to it into bufp. bufp will be The return value is
|
| int address_get_personal (address_t *addr, size_t no, char* buf, size_t len, size_t* n) | Function |
|
Accesses the display-name describing the noth email address. This display-name is optional, so may not be present. If it is not present, but there is an RFC822 comment after the address, that comment will be returned as the personal phrase, as this is a common usage of the comment even though it is not defined in the internet mail standard. A group is a kind of a special case. It has a display-name, followed by an optional mailbox-list. The display-name will be allocated an address all it's own, but all the other elements (local-part, domain, etc.) will be zero-length. So "a group: ;" is valid, will have a count of 1, but address_get_email(), and all the rest, will return zero-length output. The return value is
|
| int address_get_comments (address_t *addr, size_t no, char* buf, size_t len, size_t* n) | Function |
|
Accesses the comments extracted while parsing the noth email address. These comments have no defined meaning, and are not currently collected. The return value is
|
| int address_get_email (address_t *addr, size_t no, char* buf, size_t len, size_t* n) | Function |
|
Accesses the email addr-spec extracted while
parsing the noth email address. This will be The return value is
|
| int address_get_local_part (address_t *addr, size_t no, char* buf, size_t len, size_t* n) | Function |
|
Accesses the local-part of an email addr-spec extracted while parsing the noth email address. The return value is
|
| int address_get_domain (address_t *addr, size_t no, char* buf, size_t len, size_t* n) | Function |
|
Accesses the domain of an email addr-spec extracted while
parsing the noth email address. This will be The return value is
|
| int address_get_route (address_t *addr, size_t no, char* buf, size_t len, size_t* n) | Function |
|
Accesses the route of an email addr-spec extracted while parsing the noth email address. This is a rarely used RFC822 address syntax, but is legal in SMTP as well. The entire route is returned as a string, those wishing to parse it should look at <mailutils/parse822.h>. The return value is
|
| int address_is_group (address_t *addr, size_t no, size_t len, int* yes) | Function |
|
Sets *yes to yes can be Currently, there is no way to determine the end of the group. The return value is
|
| int address_to_string (address_t *addr, char* buf, size_t len, size_t* n) | Function |
|
Returns the entire address list as a single RFC822 formatted address list. The return value is
|
| int address_get_count (address_t addr, size_t* count) | Function |
|
Returns a count of the addresses in the address list. If addr is The return value is |
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <mailutils/address.h>
#include <mailutils/errno.h>
#include <mailutils/mutil.h>
#define EPARSE ENOENT
static int
parse (const char *str)
{
size_t no = 0;
size_t pcount = 0;
int status;
char buf[BUFSIZ];
address_t address = NULL;
mu_set_user_email_domain ("localhost");
status = address_create (&address, str);
address_get_count (address, &pcount);
if (status)
{
printf ("%s=> error %s\n\n", str, mu_errname (status));
return 0;
}
else
{
printf ("%s=> pcount %lu\n", str, (unsigned long) pcount);
}
for (no = 1; no <= pcount; no++)
{
size_t got = 0;
int isgroup;
address_is_group (address, no, &isgroup);
printf ("%lu ", (unsigned long) no);
if (isgroup)
{
address_get_personal (address, no, buf, sizeof (buf), &got);
printf ("group <%s>\n", buf);
}
else
{
address_get_email (address, no, buf, sizeof (buf), 0);
printf ("email <%s>\n", buf);
}
address_get_personal (address, no, buf, sizeof (buf), &got);
if (got && !isgroup)
printf (" personal <%s>\n", buf);
address_get_comments (address, no, buf, sizeof (buf), &got);
if (got)
printf (" comments <%s>\n", buf);
address_get_local_part (address, no, buf, sizeof (buf), &got);
if (got)
{
printf (" local-part <%s>", buf);
address_get_domain (address, no, buf, sizeof (buf), &got);
if (got)
printf (" domain <%s>", buf);
printf ("\n");
}
address_get_route (address, no, buf, sizeof (buf), &got);
if (got)
printf (" route <%s>\n", buf);
}
address_destroy (&address);
printf ("\n");
return 0;
}
static int
parseinput (void)
{
char buf[BUFSIZ];
while (fgets (buf, sizeof (buf), stdin) != 0)
{
buf[strlen (buf) - 1] = 0;
parse (buf);
}
return 0;
}
int
main (int argc, const char *argv[])
{
argc = 1;
if (!argv[argc])
{
return parseinput ();
}
for (; argv[argc]; argc++)
{
if (strcmp (argv[argc], "-") == 0)
{
parseinput ();
}
else
{
parse (argv[argc]);
}
}
return 0;
}
/* Prefix locker_ is reserved */#include <mailutils/locker.h>
| int locker_create (locker_t * plocker, char *filename, size_t len, int flags) | Function |
| void locker_destroy (locker_t * plocker) | Function |
| int locker_lock (locker_t locker, int flag) | Function |
|
| int locker_touchlock (locker_t locker) | Function |
| int locker_unlock (locker_t locker) | Function |
A mailbox or a mailer can be described in a URL, the string will contain the
necessary information to initialize mailbox_t, or mailer_t
properly.
The POP URL scheme contains a POP server, optional port number
and the authentication mechanism. The general form is
<pop://[<user>[;AUTH=<auth>]@]<host>[:<port>]> or <pop://[<user>[:<passwd>]@]<host>[:<port>]>
If :port is omitted the default value is 110. Different forms of
authentication can be specified with ;AUTH=type.
The special string ;AUTH=* indicates that the client will use
a default scheme base on the capability of the server.
<pop://obelix@gaulois.org> <pop://asterix;AUTH=*@france.com> <pop://falbala;AUTH=+APOP@france.com> <pop://obelix;AUTH=+APOP@village.gaulois.org:2000> <pop://obelix:menhir@village.gaulois.org:2000>
For more complete information see rfc2368.
The IMAP URL scheme contains an IMAP server, optional port number
and the authentication mechanism. The general form is
<imap://[<user>[;AUTH=<type>]]@<host>[:port][/<mailbox>]> or <imap://[<user>[:<passwd>]]@<host>[:port][/<mailbox>]>
If :port is omitted the default value is 220. Different forms of
authentication can be specified with ;AUTH=type.
The special string ;AUTH=* indicates that the client will use
a default scheme base on the capability of the server.
<imap://obelix@imap.gaulois.org> <imap://asterix;AUTH=*@imap.france.com> <imap://asterix:potion@imap.france.com>
For more complete information see rfc2192.
Local folder should be handle by this URL. It is preferable to let
the mailbox recognize the type of mailbox and take the appropriate
action.
<file://path> <file://var/mail/user> <file://home/obelix/Mail>
For MMDF, MH local mailboxes URLs are provided, but it is preferable to
use <file://path> and let the library figure out which one.
<mmdf://path> <mh://path>
After setting a mailer, <mailto:> is used to tell the mailer where
and to whom the message is for.
<mailto://hostname>
Mailto can be used to generate short messages, for example to subscribe
to mailing lists.
<mailto://bug-mailutils@gnu.org?body=subscribe> <mailto://bug-mailutils@gnu.org?Subject=hello&body=subscribe>
For more complete information see rfc2368.
Helper functions are provided to retrieve and set the URL fields.
| int url_create (url_t *url, const char *name) | Function |
| Create and the url data structure, but do not parse it. |
| void url_destroy (url_t *) | Function |
| Destroy the url and free it's resources. |
| int url_parse (url_t url) | Function |
|
Parses the url, after calling this the get functions can be called.
The syntax, condensed from RFC 1738, and extended with the ;auth=
of RFC 2384 (for POP) and RFC 2192 (for IMAP) is:
url =
scheme ":" [ "//"
[ user [ ( ":" password ) | ( ";auth=" auth ) ] "¨]
host [ ":" port ]
[ ( "/" urlpath ) | ( "?" query ) ] ]
This is a generalized URL syntax, and may not be exactly appropriate for any particular scheme. |
| const char* url_to_string (const url_t url) | Function |
| int url_get_scheme (const url_t url, char *schem, size_t len, size_t *n) | Function |
| int url_get_user (const url_t url, char *usr, size_t len, size_t *n) | Function |
| int url_get_passwd (const url_t url, char *passwd, size_t len, size_t *n) | Function |
| int url_get_host (const url_t url, char *host, size_t len, size_t *n) | Function |
| int url_get_port (const url_t url, long *port) | Function |
| int url_get_path (const url_t url, char *path, size_t len, size_t *n) | Function |
| int url_get_query (const url_t url, char *query, size_tlen, size_t *n) | Function |
| char* url_decode (const char* string) | Function |
| Decodes an RFC 1738 % encoded string, returning the decoded string in allocated memory. If the string is not encoded, this degenerates to a strdup(). |
#include <stdio.h>
#include <string.h>
#include <mailutils/errno.h>
#include <mailutils/url.h>
int
main ()
{
char str[1024];
char buffer[1024];
long port = 0;
int len = sizeof (buffer);
url_t u = NULL;
while (fgets (str, sizeof (str), stdin) != NULL)
{
int rc;
str[strlen (str) - 1] = '\0'; /* chop newline */
if (strspn (str, " \t") == strlen (str))
continue; /* skip empty lines */
if ((rc = url_create (&u, str)) != 0)
{
fprintf (stderr, "url_create %s ERROR: [%d] %s",
str, rc, mu_errstring (rc));
exit (1);
}
if ((rc = url_parse (u)) != 0)
{
printf ("%s => FAILED: [%d] %s\n",
str, rc, mu_errstring (rc));
continue;
}
printf ("%s => SUCCESS\n", str);
url_get_scheme (u, buffer, len, NULL);
printf ("\tscheme <%s>\n", buffer);
url_get_user (u, buffer, len, NULL);
printf ("\tuser <%s>\n", buffer);
url_get_passwd (u, buffer, len, NULL);
printf ("\tpasswd <%s>\n", buffer);
url_get_auth (u, buffer, len, NULL);
printf ("\tauth <%s>\n", buffer);
url_get_host (u, buffer, len, NULL);
printf ("\thost <%s>\n", buffer);
url_get_port (u, &port);
printf ("\tport %ld\n", port);
url_get_path (u, buffer, len, NULL);
printf ("\tpath <%s>\n", buffer);
url_get_query (u, buffer, len, NULL);
printf ("\tquery <%s>\n", buffer);
url_destroy (&u);
}
return 0;
}
/* Prefix parse822_ is reserved */#include <mailutils/parse822.h>
Internet Message Format, see Address node for the discussion.
| int parse822_address_list (address_t* a, const char* s) | Function |
| int parse822_mail_box (const char** p, const char* e, address_t* a) | Function |
| int parse822_group (const char** p, const char* e, address_t* a) | Function |
| int parse822_address (const char** p, const char* e, address_t* a) | Function |
| int parse822_route_addr (const char** p, const char* e, address_t* a) | Function |
| int parse822_route (const char** p, const char* e, char** route) | Function |
| int parse822_addr_spec (const char** p, const char* e, address_t* a) | Function |
| int parse822_unix_mbox (const char** p, const char* e, address_t* a) | Function |
| int parse822_local_part (const char** p, const char* e, char** local_part) | Function |
| int parse822_domain (const char** p, const char* e, char** domain) | Function |
| int parse822_sub_domain (const char** p, const char* e, char** sub_domain) | Function |
| int parse822_domain_ref (const char** p, const char* e, char** domain_ref) | Function |
| int parse822_domain_literal (const char** p, const char* e, char** domain_literal) | Function |
| int parse822_quote_string (char** quoted, const char* raw) | Function |
| int parse822_quote_local_part (char** quoted, const char* raw) | Function |
| int parse822_field_body (const char** p, const char *e, char** fieldbody) | Function |
| int parse822_field_name (const char** p, const char *e, char** fieldname) | Function |
The functions from libmailbox library get user information from
the system user database. The library libmuauth extends this
functionality, allowing libmailbox functions to obtain
information about a user from several places, like SQL database,
etc. The method used is described in detail in authentication.
This chapter contains a very succinct description of the underlying
library mechanism.
| mu_auth_fp | Data Type |
|
This is a pointer to authentication or authorization data. It
is defined as follows:
typedef int (*mu_auth_fp) (void *return_data,
void *key,
void *func_data,
void *call_data);
Its arguments are:
|
| mu_auth_data | Data Type |
|
The struct mu_auth_data {
/* These are from struct passwd */
char *name; /* user name */
char *passwd; /* user password */
uid_t uid; /* user id */
gid_t gid; /* group id */
char *gecos; /* real name */
char *dir; /* home directory */
char *shell; /* shell program */
/* */
char *mailbox; /* Path to the user's system mailbox */
int change_uid; /* Should the uid be changed? */
};
|
| mu_auth_module | Data Type |
|
The struct mu_auth_module {
char *name; /* Module name */
struct argp *argp; /* Corresponding argp structure */
mu_auth_fp authenticate; /* Authentication function ... */
void *authenticate_data; /* ... and its specific data */
mu_auth_fp auth_by_name; /* Get user info by user name */
void *auth_by_name_data; /* ... and its specific data */
mu_auth_fp auth_by_uid; /* Get user info by user id */
void *auth_by_uid_data; /* ... and its specific data */
};
|
| void mu_auth_init (void) | Function |
|
This function registers the command line capability "auth". It must be
called after registering |
| void MU_AUTH_REGISTER_ALL_MODULES (void) | Function |
|
This macro registers all default modules and calls |
| int mu_auth_data_alloc (struct mu_auth_data **ptr, const char *name, const char *passwd, uid_t uid, gid_t gid, const char *gecos, const char *dir, const char *shell, const char *mailbox, int change_uid) | Function |
|
Create a |
| void mu_auth_data_free (struct mu_auth_data *ptr) | Function |
|
Free the |
| void mu_auth_register_module (struct mu_auth_module *mod) | Function |
|
Register the module defined by the mod argument. |
| int mu_auth_runlist (list_t flist, void *return_data, void *key, void *call_data); | Function |
|
The list is expected to contain The function returns 0 if none of the functions from |
| struct mu_auth_data * mu_get_auth_by_name (const char *username) | Function |
|
Search the information about given user by its username. Similar to
system's |
| struct mu_auth_data * mu_get_auth_by_uid (uid_t uid) | Function |
Search the information about given user by its uid. Similar to
system's getpwuid call).
|
| int mu_authenticate (struct mu_auth_data *auth_data, char *pass) | Function |
|
Authenticate the user whose data are in auth_data using password pass. Return 0 if the user is authenticated. |
| int mu_auth_nosupport (void *return_data, void *key, void *func_data, void *call_data); | Function |
|
The "not-supported" module. Always returns |
| mu_auth_system_module | Variable |
|
This module is always registered even if |
| mu_auth_generic_module | Variable |
|
This module is always registered even if |
| mu_auth_pam_module | Variable |
|
Implements PAM authentication. Both authorization handlers are
|
| mu_auth_sql_module | Variable |
|
Implements authentication and authorization via MySQL database. The
credentials for accessing the database are taken from global variables
|
| mu_auth_virtual_module | Variable |
|
Implements |
To link your program against libmuauth, obtain loader arguments
by running mailutils-config as follows:
mailutils-config --link auth
See mailutils-config, for more information about this utility.
Here is a sample Makefile fragment:
MU_LDFLAGS=`mailutils-config --link auth`
MU_INCLUDES=`mailutils-config --include`
myprog: myprog.c
$(CC) -omyprog $(CFLAGS) $(MU_INCLUDES) myprog.c $(MU_LDFLAGS)
If your program will be using only default modules provided by the
library, then it will suffice to call
MU_AUTH_REGISTER_ALL_MODULES() somewhere near the start of
your program. As an example, consider the following code fragment
(it is taken from the imap4d daemon):
int
main (int argc, char **argv)
{
struct group *gr;
int status = EXIT_SUCCESS;
state = STATE_NONAUTH; /* Starting state in non-auth. */
MU_AUTH_REGISTER_ALL_MODULES ();
mu_argp_parse (&argp, &argc, &argv, 0, imap4d_capa,
NULL, &daemon_param);
...
Otherwise, if your program will use it's own modules, first register
them with mu_auth_register_module and then call
mu_auth_init(), e.g.:
struct mu_auth_module radius_module = {
...
};
struct mu_auth_module ext_module = {
...
};
int
main (int argc, char **argv)
{
mu_auth_register_module (&radius_module);
mu_auth_register_module (&ext_module);
mu_auth_init ();
...
These two approaches may be combined, allowing you to use both your
modules and the ones provided by Mailutils. Consider the example below:
int
main (int argc, char **argv)
{
mu_auth_register_module (&radius_module);
mu_auth_register_module (&ext_module);
MU_AUTH_REGISTER_ALL_MODULES ();
...
}
The library libmu_scm provides an interface between Mailutils
and Guile, allowing to access the Mailutils functionality from a
Scheme program. For more information about Guile, refer to
Overview. For information
about Scheme programming language, See Top.
Functions Provided by libmu_scm
Using libmu_scm
| mu-address-get-personal ADDRESS NUM | Scheme Function |
| Return personal part of an email address. |
| mu-address-get-comments ADDRESS NUM | Scheme Function |
| mu-address-get-email ADDRESS NUM | Scheme Function |
| Return email part of an email address. |
| mu-address-get-domain ADDRESS NUM | Scheme Function |
| Return domain part of an email address |
| mu-address-get-local ADDRESS NUM | Scheme Function |
| Return local part of an email address. |
| mu-address-get-count ADDRESS | Scheme Function |
| Return number of parts in email address. |
| mu-mailbox-open URL MODE | Scheme Function |
| Opens a mailbox specified by URL. |
| mu-mailbox-close MBOX | Scheme Function |
| Closes mailbox MBOX |
| mu-mailbox-get-url MBOX | Scheme Function |
| Returns the URL of the mailbox. |
| mu-mailbox-get-port MBOX MODE | Scheme Function |
Returns a port associated with the contents of the MBOX.
MODE is a string defining operation mode of the stream. It may
contain any of the two characters: r for reading, w for
writing.
|
| mu-mailbox-get-message MBOX MSGNO | Scheme Function |
| Retrieve from MBOX message # MSGNO. |
| mu-mailbox-messages-count MBOX | Scheme Function |
| Returns number of messages in the mailbox. |
| mu-mailbox-expunge MBOX | Scheme Function |
| Expunges deleted messages from the mailbox. |
| mu-mailbox-url MBOX | Scheme Function |
| Returns the URL of the mailbox |
| mu-mailbox-append-message MBOX MESG | Scheme Function |
| Appends the message to the mailbox |
| mu-message-copy MESG | Scheme Function |
| Creates the copy of the given message. |
| mu-message-set-header MESG HEADER VALUE REPLACE | Scheme Function |
| Sets new VALUE to the header HEADER of the message MESG. If the HEADER is already present in the message its value is replaced with the supplied one if the optional REPLACE is #t. Otherwise new header is created and appended. |
| mu-message-get-size MESG | Scheme Function |
| Returns the size of the given message. |
| mu-message-get-lines MESG | Scheme Function |
| Returns number of lines in the given message. |
| mu-message-get-sender MESG | Scheme Function |
| Returns the sender email address for the message MESG. |
| mu-message-get-header MESG HEADER | Scheme Function |
| Returns the header value of the HEADER in the MESG. |
| mu-message-get-header-fields MESG HEADERS | Scheme Function |
| Returns the list of headers in the MESG. If optional HEADERS is specified it should be a list of header names to restrict return value to. |
| mu-message-set-header-fields MESG LIST REPLACE | Scheme Function |
| Set the headers in the message MESG from LIST LIST is a list of (cons HEADER VALUE) Optional parameter REPLACE specifies whether the new header values should replace the headers already present in the message. |
| mu-message-delete MESG FLAG | Scheme Function |
| Mark given message as deleted. Optional FLAG allows to toggle deleted mark The message is deleted if it is #t and undeleted if it is #f |
| mu-message-get-flag MESG FLAG | Scheme Function |
| Return value of the attribute FLAG. |
| mu-message-set-flag MESG FLAG VALUE | Scheme Function |
| Set the given attribute of the message. If optional VALUE is #f, the attribute is unset. |
| mu-message-get-user-flag MESG FLAG | Scheme Function |
| Returns value of the user attribute FLAG. |
| mu-message-set-user-flag MESG FLAG VALUE | Scheme Function |
| Set the given user attribute of the message. If optional VALUE is #f, the attribute is unset. |
| mu-message-get-port MESG MODE FULL | Scheme Function |
Returns a port associated with the given MESG. MODE is a string
defining operation mode of the stream. It may contain any of the
two characters: r for reading, w for writing.
If optional FULL argument specified, it should be a boolean value.
If it is #t then the returned port will allow access to any
part of the message (including headers). If it is #f then the port
accesses only the message body (the default).
|
| mu-message-get-body MESG | Scheme Function |
| Returns the message body for the message MESG. |
| mu-message-send MESG MAILER | Scheme Function |
| Sends the message MESG. Optional MAILER overrides default mailer settings in mu-mailer. |
| mu-mime-create FLAGS MESG | Scheme Function |
| Creates a new MIME object. |
| mu-mime-multipart? MIME | Scheme Function |
| Returns #t if MIME is a multipart object. |
| mu-mime-get-num-parts MIME | Scheme Function |
| Returns number of parts in a MIME object. |
| mu-mime-get-part MIME PART | Scheme Function |
| Returns part number PART from a MIME object. |
| mu-mime-add-part MIME MESG | Scheme Function |
| Adds MESG to the MIME object. |
| mu-mime-get-message MIME | Scheme Function |
| Converts MIME object to a message. |
| mu-openlog IDENT OPTION FACILITY | Scheme Function |
| Opens a connection to the system logger for Guile program. |
| mu-logger PRIO TEXT | Scheme Function |
| Generates a log message to be distributed via syslogd. |
| mu-closelog | Scheme Function |
| Closes the channel to the system logger open by mu-openlog. |
If you plan to link your program directly to libguile, it will
probably make sense to link libmu_scm directly as well. The
arguments to the program loader may be obtained by running
mailutils-config --link guile
See mailutils-config, for more information about this utility.
Here is a sample Makefile fragment:
MU_LDFLAGS=`mailutils-config --link guile`
MU_INCLUDES=`mailutils-config --include`
myprog: myprog.c
$(CC) -omyprog $(CFLAGS) $(MU_INCLUDES) myprog.c $(MU_LDFLAGS)
Dynamic linking is the preferred method of using libmu_scm. It
uses Guile "use-modules" mechanism. An interface module
mailutils.scm is provided in order to facilitate using this
method. This module is installed in the package data directory (by
default it is prefix/share/mailutils). A sample use of
this module is:
(set! %load-path (list "/usr/local/share/mailutils")) (use-modules (mailutils)) # Now you may use mailutils functions: (let ((mb (mu-mailbox-open "/var/spool/mail/gray" "r"))) ...
Note, that you should explicitly modify the %load-path
before calling use-modules, otherwise Guile will not be able to
find mailutils.scm.
This chapter describes GNU Sieve library.
Libsieve is GNU implementation of the mail filtering
language Sieve.
The library is built around a Sieve Machine -- an abstract computer constructed specially to handle mail filtering tasks. This computer has two registers: program counter and numeric accumulator; a runtime stack of unlimited depth and the code segment. A set of functions is provided for creating and destroying instances of Sieve Machine, manipulating its internal data, compiling and executing a sieve program.
The following is a typical scenario of using libsieve:
sieve_compile function is called to translate
the Sieve source into an equivalent program executable by the
Machine
keep are marked with the delete
flag. Thus, running mailbox_expunge upon the mailbox finishes
the job, leaving in the mailbox only those messages that were preserved
by the filter.
The following sections describe in detail the functions from the Sieve Library.
| sieve_machine_t | Data Type |
|
This is an opaque data type representing a pointer to an instance of
sieve machine. The sieve_machine_t keeps all information necessary
for compiling and executing the script.
It is created by |
| sieve_data_type | Data Type |
This enumeration keeps the possible types of sieve data. These are:
|
| sieve_value_t | Data Type |
The sieve_value_t keeps an instance of sieve data. It is defined
as follows:
typedef struct {
sieve_data_type type; /* Type of the data */
union {
char *string; /* String value or identifier */
size_t number; /* Numeric value */
list_t list; /* List value */
sieve_runtime_tag_t *tag; /* Tag value */
void *ptr; /* Pointer value */
} v;
} sieve_value_t;
Depending on the value of
|
| sieve_tag_def_t | Data Type |
This structure represents a definition of a tagged (optional) argument
to a sieve action or test. It is defined as follows:
typedef struct {
char *name; /* Tag name */
sieve_data_type argtype; /* Type of tag argument. */
} sieve_tag_def_t;
The |
| sieve_runtime_tag_t | Data Type |
This structure represents the tagged (optional) argument at a runtime.
It is defined as:
struct sieve_runtime_tag {
char *tag; /* Tag name */
sieve_value_t *arg; /* Tag argument (if any) */
};
The |
| sieve_handler_t | Data Type |
|
This is a pointer to function handler for a sieve action or test.
It is defined as follows:
typedef int (*sieve_handler_t) (sieve_machine_t mach,
list_t args, list_t tags);
|
The arguments to the handler have the following meaning:
| sieve_printf_t | Data Type |
A pointer to a diagnostic output function. It is defined as follows:
typedef int (*sieve_printf_t) (void *data, const char *fmt, va_list ap); |
sieve_machine_init().
| sieve_parse_error_t | Data Type |
This data type is declared as follows:
typedef int (*sieve_parse_error_t) (void *data,
const char *filename, int lineno,
const char *fmt, va_list ap);
|
It is used to declare error handlers for parsing errors. The application-specific data are passed in the data argument. Arguments filename and line indicate the location of the error in the source text, while fmt and ap give verbose description of the error.
| sieve_action_log_t | Data Type |
A pointer to the application-specific logging function:
typedef void (*sieve_action_log_t) (void *data,
const char *script,
size_t msgno, message_t msg,
const char *action,
const char *fmt, va_list ap);
|
sieve_message(), this argument is zero.
| sieve_comparator_t | Data Type |
typedef int (*sieve_comparator_t) (const char *, const char *); A pointer to the comparator handler function. The function compares
its two operands and returns 1 if they are equal, and 0 otherwise.
Notice, that the sense of the return value is inverted
in comparison with most standard libc functions like |
| sieve_retrieve_t | Data Type |
typedef int (*sieve_retrieve_t) (void *item, void *data, int idx,
char **pval);
A pointer to generic retriever function. See description of
|
| sieve_destructor_t | Data Type |
typedef void (*sieve_destructor_t) (void *data); A pointer to destructor function. The function frees any resources
associated with |
| sieve_tag_checker_t | Data Type |
typedef int (*sieve_tag_checker_t) (const char *name,
list_t tags,
list_t args)
A pointer to tag checker function. The purpose of the function is to perform compilation-time consistency test on tags. Its arguments are:
The function is allowed to make any changes in tags and args. It should return 0 if the syntax is correct and non-zero otherwise. It is responsible for issuing the diagnostics in the latter case. [FIXME: describe how to do that] |
This subsection describes functions used to create an instance of the sieve machine, read or alter its internal fields and destroy it.
| int sieve_machine_init (sieve_machine_t *mach, void *data) | Function |
|
The |
| void sieve_machine_destroy (sieve_machine_t *pmach) | Function |
|
This function destroys the instance of sieve machine pointed to by
mach parameter. After execution of |
| int sieve_machine_add_destructor (sieve_machine_t mach, sieve_destructor_t destr, void *ptr); | Function |
|
This function registers a destructor function dest. The purpose
of the destructor is to free any resources associated with the item
ptr. The destructor function takes a single argument -- a
pointer to the data being destroyed. All registered destructors are
called in reverse order upon execution of
static void
free_regex (void *data)
{
regfree ((regex_t*)data);
}
int
match_part_checker (const char *name, list_t tags, list_t args)
{
regex_t *regex;
/* Initialise the regex: */
regex = sieve_malloc (mach, sizeof (*regex));
/* Make sure it will be freed when necessary */
sieve_machine_add_destructor (sieve_machine, free_regex, regex);
.
.
.
}
|
| void *sieve_get_data (sieve_machine_t mach) | Function |
This function returns the application-specific data associated with
the instance of sieve machine. See sieve_machine_init().
|
| message_t sieve_get_message (sieve_machine_t mach) | Function |
| This function returns the current message. |
| size_t sieve_get_message_num (sieve_machine_t mach); | Function |
This function returns the current message number in the mailbox.
If there are no mailbox, i.e. the execution of the sieve code is started
with sieve_message, this function returns 1.
|
| int sieve_get_debug_level (sieve_machine_t mach) | Function |
| Returns the debug level set for this instance of sieve machine. |
| ticket_t sieve_get_ticket (sieve_machine_t mach) | Function |
| Returns the authentication ticket for this machine. |
| mailer_t sieve_get_mailer (sieve_machine_t mach) | Function |
| Returns the mailer. |
| char * sieve_get_daemon_email __P((sieve_machine_t mach) | Function |
This function returns the daemon email associated with this
instance of sieve machine. The daemon email is an email address used in
envelope from addresses of automatic reply messages. By default its local
part is <MAILER-DAEMON> and the domain part is the machine name.
|
| void sieve_set_error (sieve_machine_t mach, sieve_printf_t error_printer) | Function |
This function sets the error printer function for the machine. If it is
not set, the default error printer will be used. It is defined as
follows:
int
_sieve_default_error_printer (void *unused, const char *fmt,
va_list ap)
{
return mu_verror (fmt, ap);
}
|
| void sieve_set_parse_error (sieve_machine_t mach, sieve_parse_error_t p) | Function |
This function sets the parse error printer function for the machine. If it is
not set, the default parse error printer will be used. It is defined as
follows:
int
_sieve_default_parse_error (void *unused,
const char *filename, int lineno,
const char *fmt, va_list ap)
{
if (filename)
fprintf (stderr, "%s:%d: ", filename, lineno);
vfprintf (stderr, fmt, ap);
fprintf (stderr, "\n");
return 0;
}
|
| void sieve_set_debug (sieve_machine_t mach, sieve_printf_t debug)); | Function |
This function sets the debug printer function for the machine. If it is
not set, the default debug printer is NULL which means no
debugging information will be displayed.
|
| void sieve_set_debug_level (sieve_machine_t mach, mu_debug_t dbg, int level) | Function |
This function sets the debug level for the given instance of sieve
machine. The dbg argument is the mu_debug_t object to be
used with mailutils library, the level argument specifies the
debugging level for the sieve library itself. It is a bitwise or of
the following values:
|
| void sieve_set_logger (sieve_machine_t mach, sieve_action_log_t logger) | Function |
This function sets the logger function. By default the logger function
is NULL, which means that the executed actions are not logged.
|
| void sieve_set_ticket (sieve_machine_t mach, ticket_t ticket) | Function |
| This function sets the authentication ticket to be used with this machine. |
| void sieve_set_mailer (sieve_machine_t mach, mailer_t mailer) | Function |
This function sets the mailer. The default mailer is "sendmail:".
|
| void sieve_set_daemon_email (sieve_machine_t mach, const char *email) | Function |
This functions sets the daemon email for reject and
redirect actions.
|
| int sieve_is_dry_run (sieve_machine_t mach) | Function |
The sieve_is_dry_run() returns 1 if the machine is in dry
run state, i.e. it will only log the actions that would have been
executed without actually executing them. The dry run state is set
by calling sieve_set_debug_level() if its last argument has
the MU_SIEVE_DRY_RUN bit set.
|
| const char * sieve_type_str (sieve_data_type type) | Function |
| Returns the string representation for the given sieve data type. The return value is a pointer to a static constant string. |
| void sieve_error (sieve_machine_t mach, const char *fmt, ...) | Function |
| Format and output an error message using error printer of the machine mach. |
| void sieve_debug (sieve_machine_t mach, const char *fmt, ...) | Function |
| Format and output a debug message using debug printer of the machine mach. |
| void sieve_log_action (sieve_machine_t mach, const char *action, const char *fmt, ...) | Function |
| Log a sieve action using logger function associated with the machine mach. |
| void sieve_abort (sieve_machine_t mach) | Function |
| Immediately abort the execution of the script. |
| sieve_register_t * sieve_test_lookup (sieve_machine_t mach, const char *name) | Function |
Find a register object describing the test name. Returns
NULL if no such test exists.
|
| sieve_register_t * sieve_action_lookup (sieve_machine_t mach, const char *name) | Function |
Find a register object describing the action name. Returns
NULL if no such action exists.
|
| int sieve_register_test (sieve_machine_t mach, const char *name, sieve_handler_t handler, sieve_data_type *arg_types, sieve_tag_group_t *tags, int required) | Function |
| int sieve_register_action (sieve_machine_t mach, const char *name, sieve_handler_t handler, sieve_data_type *arg_types, sieve_tag_group_t *tags, int required) | Function |
| int sieve_register_comparator (sieve_machine_t mach, const char *name, int required, sieve_comparator_t is, sieve_comparator_t contains, sieve_comparator_t matches, sieve_comparator_t regex) | Function |
| int sieve_tag_lookup (list_t taglist, char *name, sieve_value_t **arg) | Function |
| int sieve_load_ext (sieve_machine_t mach, const char *name) | Function |
The following functions act as their libc counterparts. The allocated
memory is associated with the mach argument and is automatically
freed upon the call to sieve_machine_destroy (mach).
| void * sieve_malloc (sieve_machine_t mach, size_t size) | Function |
| Allocates size bytes and returns a pointer to the allocated memory. |
| char * sieve_mstrdup (sieve_machine_t mach, const char *str) | Function |
| This function returns a pointer to a new string which is a duplicate of the string str. |
| void * sieve_mrealloc (sieve_machine_t mach, void *ptr, size_t size) | Function |
Changes the size of the memory block pointed to by ptr to
size bytes. The contents will be unchanged to the minimum of the
old and new sizes; newly allocated memory will be uninitialized. If
ptr is NULL, the call is equivalent to
sieve_malloc(mach, size); if size is equal to
zero, the call is equivalent to sieve_mfree(ptr). Unless
ptr is NULL, it must have been returned by an earlier
call to sieve_malloc() or sieve_mrealloc().
|
| void sieve_mfree (sieve_machine_t mach, void *ptr) | Function |
sieve_mfree() frees the memory space pointed to by ptr and
detaches it from the destructor list of mach. The ptr must
have been returned by a previous call to sieve_malloc() or
sieve_mrealloc(). Otherwise, or if sieve_mfree(ptr)
has already been called before, undefined behaviour occurs.
If ptr is |
| int sieve_compile (sieve_machine_t mach, const char *name) | Function |
| Compile the sieve script from the file name. |
| int sieve_mailbox (sieve_machine_t mach, mailbox_t mbox) | Function |
| Execute the code from the given instance of sieve machine mach over each message in the mailbox mbox. |
| int sieve_message (sieve_machine_t mach, message_t message) | Function |
| Execute the code from the given instance of sieve machine mach over the message. |
| int sieve_disass (sieve_machine_t mach) | Function |
| Dump the disassembled code of the sieve machine mach. |
The input language understood by the GNU Sieve Library is a superset of the Sieve language as described in RFC 3028.
Comments are semantically equivalent to whitespace and can be used anyplace that whitespace is (with one exception in multi-line strings, as described below).
There are two kinds of comments: hash comments, that begin with a
# character that is not contained within a string and continue
until the next newline, and C-style or bracketed comments, that are
delimited by /* and */ tokens. The bracketed comments
may span multiple lines. E.g.:
if size :over 100K
{ # this is a comment
discard;
}
if size :over 100K
{ /* this is a comment
this is still a comment */ discard /* this is a comment again
*/ ;
}
Like in C, bracketed comments do not nest.
The basic lexical entities are identifiers and literals.
An identifier is a sequence of letters, digits and underscores, started
with a letter or underscore. For example, header and
check_822_again are valid identifiers, whereas 1st is not.
A special form of identifier is tag: it is an identifier prefixed
with a colon (:), e.g.: :comparator.
A literal is a data that is not executed, merely evaluated "as is", to be used as arguments to commands. There are four kinds of literals:
Numbers are given as ordinary unsigned decimal numbers. An
optional suffix may be used to indicate a multiple of a power of two.
The suffixes are: K specifying "kibi-", or 1,024 (2^10) times
the value of the number; M specifying "mebi-", or 1,048,576
(2^20) times the value of the number; and G specifying "tebi-",
or 1,073,741,824 (2^30) times the value of the number.
The numbers have 32 bits of magnitude.
A string is any sequence of characters enclosed in double quotes
("). A string cannot contain newlines and double quote
characters. This limitation will disappear in future releases.
A multiline string is used to represent large blocks of text
with embedded newlines and special characters. It starts with the
keyword text: followed by a newline and ends with a dot
(.) on a newline by itself. Any characters between these two
markers are taken verbatim. For example:
text: ** This is an authomatic response from my message ** ** filtering program. ** I can not attend your message right now. However it will be saved, and I will read it as soon as I am back. Regards, Fred .
Notice that a hashed comment or whitespace may occur between
text: and the newline. However, when used inside the multiline
string a hash sign looses its special meaning (except in one case, see
below) and is taken as is, as well as bracketed comment delimiters.
In other words, no comments are allowed within a multiline string. E.g.:
text: # This is a comment Sample text # This line is taken verbatim /* And this line too */ .
The only exception to this rule is that preprocessor include
statement is expanded as usual when found within a multiline string
(see #include), e.g.:
text: #include <myresponse.txt> .
This results in the contents of file myresponse.txt being read
and interpreted as the contents of the multiline string.
A string list is a comma-delimited list of quoted strings, enclosed
in a pair of square brackets, e.g.:
["me@example.com", "me00@landru.example.edu"]
For convenience, in any context where a list of strings is appropriate,
a single string is allowed without being a member of a list: it is
equivalent to a list with a single member. For example, the following
two statements are equivalent:
exists "To"; exists ["To"];
Being designed for the sole purpose of filtering mail, Sieve has a very simple syntax.
The basic syntax element is a command. It is defined as follows:
command-name [tags] args
where command-name is an identifier representing the name of the command, tags is an optional list of optional or tagged arguments and args is a list of required or positional arguments.
Positional arguments are literals delimited with whitespace. They provide the command with the information necessary to its proper functioning. Each command has a fixed number of positional arguments. It is an error to supply more arguments to the command or to give it fewer arguments than it accepts.
Optional arguments allow to modify the behaviour of the command, like command line options in UNIX do. They are a list of tags (see Lexical Structure) separated by whitespace. An optional argument may have at most one parameter.
Each command understands a set of optional arguments. Supplying it tags that it does not understand results in an error.
For example, consider the following command
header :mime :comparator "i;octet" ["to", "from"] "bug-mailutils@gnu.org"
Here, given that header takes two positional arguments:
header is command name, the list ["to", "from"] is first
positional argument and the string "bug-mailutils@gnu.org" is second
positional argument. There are two optional arguments: :mime and
:comparator. The latter has a string "i;octet" as its
parameter.
An action is a Sieve command that performs some operation over
the message. Actions do the main job in any Sieve
program. Syntactically, an action is a command terminated with
semicolon, e.g.:
keep; fileinto "mbox";
GNU Sieve provides the full set of actions described in RFC 3028. It also allows to extend this set using loadable actions. See Actions, for detailed discussion of actions.
The only control flow statement Sieve has is "if" statement. In its
simplest form it is:
if condition { ... }
The effect of this statement is that the sequence of actions between the
curly braces is executed only if the condition evaluates to
true.
A more elaborate form of this statement allows to execute two
different sets of actions depending on whether the condition is
true or not:
if condition { ... } else { ... }
The most advanced form of the "if" statement allows to select an
action depending on what condition from the set of conditions is met.
ifcond1{ ... } elsifcond2{ ... } else { ... }
There may be any number of "elsif" branches in an "if" statement. However it may have at most one "else" branch. Notes for C programmers:
Here's an example of "if" statement:
if header :contains "from" "coyote"
{
discard;
}
elsif header :contains ["subject"] ["$$$"]
{
discard;
}
else
{
fileinto "INBOX";
}
The following section describes in detail conditions used in "if" statements.
Tests are Sieve commands that return boolean value. E.g. the
test
header :contains "from" "coyote"
returns true only if the header "From" of the current message contains substring "coyote".
The tests shipped with the GNU Sieve are described in Tests.
Condition is a Sieve expression that evaluates to true or
false. In its simplest form, condition is just a Sieve test.
To reverse the sense of a condition use keyword not, e.g.:
not header :contains "from" "coyote"
The results of several conditions may be joined together by logical
and and or operations. The special form allof
takes several tests as its arguments and computes the logical and
of their results. Similarly, the form anyof performs logical
or over the results of its arguments. E.g.:
if anyof (not exists ["From", "Date"],
header :contains "from" "fool@example.edu")
{
discard;
}
The preprocessor statements are a GNU extension to the Sieve language.
The syntax for a preprocessor statement is similar to that used in
C programming language, i.e.: a pound character (#)
followed by a preprocessor directive and its arguments. Any amount of
whitespace can be inserted between the # and the directive.
Currently implemented directives are include and searchpath.
The #include directive reads in the contents of the given file.
The contents is "inserted" into the text being parsed starting at the
line where the directive appears. The directive takes two forms:
#include "filename"
#include <filename>"
-I command line options.
If filename starts with a directory separator character
(/) both forms have the same effect.
The #searchpath directive adds its argument to the list of
directories searched for loadable modules. It has the same effect
as -L command line switch used by GNU sieve utility
(see sieve group).
Syntax: require string;
require string-list;
The require statement informs the parser that a script makes use of a certain extension. Multiple capabilities can be declared using the second form of the statement. The actual handling of a capability name depends on its suffix.
If the name starts with comparator-, it is understood
as a request to use the specified comparator. The comparator name
consists of the characters following the suffix.
If the name starts with test-, it means a request to use
the given test. The test name consists of the characters following
the suffix.
Otherwise, the capability is understood as a name of an action to be used.
The require statement, if present, must be used before any other
statement that is using the required capability. As an extension, the GNU
sieve allows the require and any other statements to be
interspersed.
By default the following actions and comparators are always required:
Example:
require ["fileinto", "reject"]; require "fileinto"; require "comparator-i;ascii-numeric";
When processing arguments for require statement, GNU libsieve
uses the following algorithm:
comparator- it is looked up in the comparator table. If it
begins with test-, the test table is used instead. Otherwise
the name is looked up in the action table.
comparator- or
test- prefix is stripped. Then, any character other than
alphanumeric characters, . and , is replaced with
dash (-). The name thus obtained is used as a file name
of an external loadable module.
$prefix/lib/mailutils.
-L options in
the command line
#searchpath directive.
/etc/ld.so.conf and the value of the environment variable
LD_LIBRARY_PATH).
The value of LTDL_LIBRARY_PATH and LD_LIBRARY_PATH must be a
colon-separated list of absolute directories, for example,
"/usr/lib/mypkg:/lib/foo".
In any of these directories, libsieve first attempts to find
and load the given filename. If this fails, it tries to append the
following suffixes to the file name:
.la
.so, .sl, etc.
libsieve executes its
initialization function (see below) and again looks up the name
in the symbol table. If found, search terminates successfully.
libsieve then
issues the following diagnostic message:
source for the required action NAME is not available
GNU libsieve supports the following built-in comparators:
i;octet
i;ascii-casemap
i;ascii-numeric
This section describes the built-in tests supported by GNU libsieve. In the discussion below the following macro-notations are used:
:is
:is match type describes an absolute match; if the contents of
the first string are absolutely the same as the contents of the
second string, they match. Only the string "frobnitzm" is the string
"frobnitzm". The null key ":is" and only ":is" the null value.
This is the default match-type.
:contains
:contains match type describes a substring match. If the value
argument contains the key argument as a substring, the match is true.
For instance, the string "frobnitzm" contains "frob" and "nit", but
not "fbm". The null key "" is contained in all values.
:matches
:matches version specifies a wildcard match using the
characters * and ?. * matches zero or more
characters, and ? matches a single character. ? and
* may be escaped as \\? and \\* in strings to match
against themselves. The first backslash escapes the second backslash;
together, they escape the *.
:regex
:regex version specifies a match using POSIX Extended Regular
Expressions.
:comparator "comparator-name"
It instructs sieve to use the given comparator with the test.
If comparator-name is not one of i;octet,
i;ascii-casemap it must be required prior to using it.
For example:
require "comparator-i;ascii-numeric";
if header :comparator "i;ascii-numeric" :is "X-Num" "10"
{
...
:all
:localpart
:domain
Notice, that match-type modifiers interact with
comparators. Some comparators are not suitable for matching with
:contains or :matches. If this occurs, sieve issues
an appropriate error message. For example, the statement:
if header :matches :comparator "i;ascii-numeric"
would result in the following error message:
comparator `i;ascii-numeric' is incompatible with match type `:matches' in call to `header'
| false | Test |
|
This test always evaluates to "false". |
| true | Test |
|
This test always evaluates to "true". |
| address [address-part][comparator][match-type] header-names key-list | Test |
|
Tagged arguments:
Required arguments:
The This test returns The Example:
if address :is :all "from" "tim@example.com"
{
discard;
}
|
| size [:over|:under] number | Test |
|
The
If the tagged argument is If the argument is Otherwise, the test is true only if the size of the message equals exactly number. This is a GNU extension. The size of a message is defined to be the number of octets from the initial header until the last character in the message body. |
| envelope [address-part][comparator][match-type] envelope-part key-list | Test |
|
Tagged arguments:
Required arguments:
The If the envelope-part strings is (case insensitive) Notice, that due to the limitations imposed by SMTP envelope structure the use of any other values in envelope-parts header is meaningless. |
| exists header-names | Test |
|
Required arguments:
The The following example throws out mail that doesn't have a From header
and a Date header:
if not exists ["From","Date"]
{
discard;
}
|
| header [comparator] [match-type] [:mime] header-names key-list | Test |
|
Tagged arguments:
Required arguments:
The The test returns If a header listed in header-names exists, it contains the null
key ( X-Caffeine: C8H10N4O2
these tests on that header evaluate as follows:
header :is ["X-Caffeine"] [""] => false header :contains ["X-Caffeine"] [""] => true |
| numaddr [:over|:under] header-names number | Test |
|
This test is provided as an example of loadable extension tests. You
must use The If the tagged argument is If the tagged argument is If the tagged argument is not given, |
The GNU libsieve supports the following default actions:
Among them the first three actions do not need to be explicitly required
by a require statement, while the others do.
These actions are described in detail below.
| stop | Action |
|
The |
| keep | Action |
|
The effect of this action is to preserve the current message in the mailbox. This action is executed if no other action has been executed. |
| discard | Action |
|
Example:
if header :contains ["from"] ["idiot@example.edu"]
{
discard;
}
|
| fileinto folder | Action |
|
Required arguments:
The |
| reject reason | Action |
|
The optional Example: If the message contained
Date: Tue, 1 Apr 1997 09:06:31 -0800 (PST) From: coyote@desert.example.org To: roadrunner@acme.example.com Subject: I have a present for you I've got some great birdseed over here at my place. Want to buy it?
and the user's script contained:
if header :contains "from" "coyote@desert.example.org"
{
reject "I am not taking mail from you, and I don't want
your birdseed, either!";
}
then the original sender <coyote@desert.example.org> would receive the
following notification:
To: <coyote@desert.example.org> X-Authentication-Warning: roadrunner set sender using -f flag Content-Type: multipart/mixed; boundary=----- =_aaaaaaaaaa0 MIME-Version: 1.0 ----- =_aaaaaaaaaa0 The original message was received at Tue, 1 Apr 1997 09:07:15 -0800 from coyote@desert.example.org. Message was refused by recipient's mail filtering program. Reason given was as follows: I am not taking mail from you, and I don't want your birdseed, either! ----- =_aaaaaaaaaa0 Content-Type: message/delivery-status Reporting-UA: sieve; GNU Mailutils 0.1.3 Arrival-Date: Tue, 1 Apr 1997 09:07:15 -0800 Final-Recipient: RFC822; roadrunner@acme.example.com Action: deleted Disposition: automatic-action/MDN-sent-automatically;deleted Last-Attempt-Date: Tue, 1 Apr 1997 09:07:15 -0800 ----- =_aaaaaaaaaa0 Content-Type: message/rfc822 From: coyote@desert.example.org To: roadrunner@acme.example.com Subject: I have a present for you I've got some great birdseed over here at my place. Want to buy it? ----- =_aaaaaaaaaa0 If the reason argument is rather long, the common approach is
to use the combination of the if header :mime :matches "Content-Type"
[ "*application/msword;*", "*audio/x-midi*" ]
{
reject text:
#include "nomsword.txt"
.
;
}
|
| redirect address | Action |
|
The The |
This section summarizes the GNU extensions to the sieve language
require statement.
require appears
after a command other than require. The GNU sieve library allows
interspersing the require and other statements. The only
requirement is that require must occur before a statement that is
using the required capability (see Require Statement).
header test
The header takes an optional argument :mime, meaning to
scan the headers from each part of a multipart message.
size test
The size test allows to omit the optional argument
(:over|:under). In this case exact equality is assumed.
envelope test
The only value that can be meaningfully used as the first required
argument of an envelope test is from. This limitation
may disappear from the subsequent releases.
Along with the usual :is, :matches and contains
matching type, GNU sieve library understands :regex type. This
matching type toggles POSIX Extended Regular Expression matching.
This section contains an example of how to write external loadable
commands for GNU libsieve.
/* This is an example on how to write extension tests for GNU sieve.
It provides test "numaddr".
Syntax: numaddr [":over" / ":under"] <header-names: string-list>
<limit: number>
The "numaddr" test counts Internet addresses in structured headers
that contain addresses. It returns true if the total number of
addresses satisfies the requested relation:
If the argument is ":over" and the number of addresses is greater than
the number provided, the test is true; otherwise, it is false.
If the argument is ":under" and the number of addresses is less than
the number provided, the test is true; otherwise, it is false.
If the argument is empty, ":over" is assumed. */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <stdlib.h>
#include <mailutils/libsieve.h>
struct val_ctr { /* Data passed to the counter function */
header_t hdr; /* Headers of the current message */
size_t limit; /* Limit for the number of addresses */
size_t count; /* Number of addresses counted so far */
};
/* Count addresses in a single header value.
Input:
ITEM is the name of the header to scan.
DATA is a pointer to the val_ctr structure
Return value:
non-zero if the limit on the number of addresses has been reached. */
static int
_count_items (void *item, void *data)
{
char *name = item;
struct val_ctr *vp = data;
char *val;
address_t addr;
size_t count = 0;
if (header_aget_value (vp->hdr, name, &val))
return 0;
if (address_create (&addr, val) == 0)
{
address_get_count (addr, &count);
address_destroy (&addr);
vp->count += count;
}
free (val);
return vp->count >= vp->limit;
}
/* Handler for the numaddr test */
static int
numaddr_test (sieve_machine_t mach, list_t args, list_t tags)
{
sieve_value_t *h, *v;
struct val_ctr vc;
int rc;
if (sieve_get_debug_level (mach) & MU_SIEVE_DEBUG_TRACE)
sieve_debug (mach, "NUMADDR\n");
/* Retrieve required arguments: */
/* First argument: list of header names */
h = sieve_value_get (args, 0);
if (!h)
{
sieve_error (mach, "numaddr: can't get argument 1");
sieve_abort (mach);
}
/* Second argument: Limit on the number of addresses */
v = sieve_value_get (args, 1);
if (!v)
{
sieve_error (mach, "numaddr: can't get argument 2");
sieve_abort (mach);
}
/* Fill in the val_ctr structure */
message_get_header (sieve_get_message (mach), &vc.hdr);
vc.count = 0;
vc.limit = v->v.number;
/* Count the addresses */
rc = sieve_vlist_do (h, _count_items, &vc);
/* Here rc >= 1 iff the counted number of addresses is greater or equal
to vc.limit. If `:under' tag was given we reverse the return value */
if (sieve_tag_lookup (tags, "under", NULL))
rc = !rc;
return rc;
}
/* Syntactic definitions for the numaddr test */
/* Required arguments: */
static sieve_data_type numaddr_req_args[] = {
SVT_STRING_LIST,
SVT_NUMBER,
SVT_VOID
};
/* Tagged arguments: */
static sieve_tag_def_t numaddr_tags[] = {
{ "over", SVT_VOID },
{ "under", SVT_VOID },
{ NULL }
};
static sieve_tag_group_t numaddr_tag_groups[] = {
{ numaddr_tags, NULL },
{ NULL }
};
/* Initialization function. It is the only function exported from this
module. */
int
SIEVE_EXPORT(numaddr,init) (sieve_machine_t mach)
{
return sieve_register_test (mach, "numaddr", numaddr_test,
numaddr_req_args, numaddr_tag_groups, 1);
}
GNU Mailutils provides a set of programs for handling the email.
Some mail utilities provide access to their services only after
verifying that the user is actually the person he is claiming
to be. Such programs are, for example, pop3d and
imap4d. The process of the verification is broken
down into two stages: authorization and authentication.
In authorization stage the program retrieves the information
about a particular user. In authentication stage, this information
is compared against the user-supplied credentials. Only if both stages
succeed is the user allowed to use the service.
A set of modules is involved in performing each stage. For example, the authorization stage can retrieve the user description from various sources: system database, sql database, virtual domain table, etc. Each module is responsible for retrieving the description from a particular source of information. The modules are arranged in a module list. The modules from the list are invoked in turn, until either a one of them succeeds or the list is exhausted. In latter case the authorization fails. Otherwise the data returned by the succeeded module are used in authentication.
Similarly, authentication may be performed in several ways. The authentication modules are also grouped in a list. Each module is tried in turn until either a module succeeds, in which case the authentication succeeds, or the end of the list is reached.
We represent the module lists as column-separated lists of module
names. For example, the authorization list
system:sql:virtdomains
means that first the system user database (/etc/password) is
searched for a description of a user in question. If the search fails,
the sql database is searched. Finally, if it also fails, the
search is performed in the virtual domain database.
Note, that some authentication and/or authorization modules may
be disabled when configuring the package before compilation. The names
of the disabled modules are nevertheless available for use in runtime
configuration options, but they represent a "fail-only" functionality,
e.g. if the package was compiled without sql support then the
module sql in the above example will always fail, thus passing
the execution on to the next module.
The modules available for use in authorization list are:
/etc/password).
--sql- options (see auth) is used to configure
access to the database.
The modules available for use in authentication list are:
/etc/shadow file on systems that support it.
--sql-getpass option
(see auth).
--pam-service option (see auth)
Unless overridden by --authentication command line option,
the list of authentication modules is:
generic:system:pam:sql
Unless overridden by --authorization command line option,
the list of authorization modules is:
system:sql:virtdomains
There are some command line options that are used so often that it is inconvenient to specify them in the command line each time you run a Mailutils utility. The configuration files provide a way to add default command line arguments without having to type them in the command line. Upon startup, each Mailutils utility scans and processes the contents of the three startup files, none of which are required to exist:
mailutils.rc, found in your your system configuration directory
(usually /etc or /usr/local/etc).
Usually ~/.mailutils, unless ~/.mailutils is a directory,
in which case ~/.mailutils/mailutils is used.
Usually ~/.mu.programrc, unless ~/.mailutils is a
directory, in which case ~/.mailutils/programrc is used
(where program means the program name).
These files have simple line-oriented syntax. Comments begin with the
pound sign (#) and extend through the end of the line
2.
Very long lines may be split across several lines by escaping final newline
with a backslash (\) character.
In the non-program-specific configuration files, any configuration line must start with a tag. In the program-specific configuration file the tag must not be present, all options are for that specific program.
A tag is either a name of a particular Mailutils utility or option
group, prefixed with colon (:). The command line options common for
several Mailutils programs are divided into option groups or
capabilities, e.g. the options --mail-spool and
--lock-flags form group mailbox. These groups are discussed
in detail below.
When processing the non-program-specific configuration files,
a Mailutils utility selects
those lines whose tag is either the name of that utility or the name
of the option group supported by it. In the program-specific configuration
file, all lines are selected. For each line found, its tag (if present)
is stripped away, and the rest of the line is split up into words.
These words are regarded as command line options and are inserted to
the program arguments before any options from the command line.
Thus the options from .mailutils take precedence over those
from mailutils.rc, and the options from the command line take
precedence over those from all three configuration files.
The word splitting occurs at whitespace characters and is similar to that performed by the shell. If an option must contain embedded whitespace, it should be enclosed in a pair of quotes (either double or single quotes).
Each program also understands the following informational options:
-u
--usage
-h
--help
-L
--license
-v
--version
Option group mailbox consists of options used to specify the
location of the mail spool, and the locking strategy.
-m path
--mail-spool=path
--lock-flags=flags
This option group overrides the default mailer URL (<sendmail:>).
-m url
--mailer url
Option group address consists of options used to specify how to
qualify email addresses.
An unqualified address (one without an @) is qualified by appending @defaultdomain. defaultdomain is the return of gethostname(), or the result of gethostbyname() on the return of gethostname() (if the DNS lookup is successful).
If the email address of the current user is needed, either the address set by -email-addr is returned, or the current uid is looked up in the user database, and qualified with the defaultdomain.
-E email
--email-addr=email
-D domain
--email-domain=domain
-d[number]
--daemon[=number]
-d and its parameter.
-i
--inetd
-p number
--port number
-t number
--timeout number
These options control the authorization and authentication module lists. For a description of authentication concepts, refer to See authentication.
--authorization modlist
/etc/password).
--sql- options (see below) is used to configure
access to the database.
--authentication modlist
/etc/shadow file on systems that support it.
--sql-getpass option
(see below).
--pam-service option (see below)
--pam-service name
The following options exist in this group if the package was configured
with --enable-sql option. They take effect only if the
sql module is used in authentication and/or authorization.
Currently only MySQL is supported.
--sql-getpwnam query
--sql-getpwuid query
--sql-getpass query
--sql-host name
--sql-user name
--sql-passwd string
--sql-db string
--sql-port number
--log-facility facility
syslog facility. The following
facility names are recognized: user, daemon, mail,
auth and local0 through local7. These names are
case-insensitive.
The following options comprise this group:
-I dir
--includedir=dir
-L dir
--libdir=dir
The following configuration file specifies that all Mailutils programs
should use /var/spool/mail as a local mailspool
directory. Programs performing authentication will use pam
service mailutils. All programs, except imap4d will
issue log messages via mail facility, imap4d will use
facility local1.
:mailbox --mail-spool /var/spool/mail :auth --authentication pam --pam-service mailutils :logging --log-facility mail imap4d --daemon=20 --timeout=1800 --log-facility local1
GNU imap4d is a daemon implementing IMAP4 rev1 protocol for
accessing and handling electronic mail messages on a server. It can
be run either as a standalone program or from inetd.conf file.
GNU imap4d supports a notion of namespaces defined in RFC 2342. A namespace is a set of directories upon which the user has certain permissions. It should be understood that these permissions apply only if the underlying filesystem allows them.
The three namespaces supported by imap4d are:
% and *
wildcards with LIST command, that is he can access a
mailbox only if he knows exactly its location.
By default, imap4d starts with the following namespaces:
Note, that this means that by default, a user won't be able to see or otherwise access mailboxes residing in the directories other than his own home.
To change these defaults, use --shared-namespace and
--other-namespace options.
imap4d may run either in standalone or in inetd
operation modes. When run in "standalone" mode, the server disconnects
from the terminal and runs as a daemon, forking a child for each new
connection.
The "inetd" mode allows to start the server from
/etc/inetd.conf file. This is the default operation mode.
imap4 stream tcp nowait root /usr/local/sbin/imap4d imap4d
The program uses following option groups: See mailbox, See daemon, See logging, See auth.
-d[number]
--daemon[=number]
-d and its parameter.
-h
--help
-i
--inetd
-m path
--mail-spool=path
-O pathlist
--other-namespace=pathlist
-p number
--port number
-S pathlist
--shared-namespace=pathlist
-t number
--timeout number
-v
--version
The pop3d daemon implements the Post Office Protocol server.
pop3d has two operation modes:
/etc/inetd.conf file:
pop3 stream tcp nowait root /usr/local/sbin/pop3d pop3d
This is the default operation mode.
-d command line switch.
The program uses following option groups: See mailbox, See daemon, See logging, See auth.
-d[number]
--daemon[=number]
-d and its parameter.
-h
--help
-i
--inetd
-m path
--mail-spool=path
-p number
--port number
-t number
--timeout number
-v
--version
The frm command outputs a header information of
the selected messages in a mailbox. By default, frm reads the
user's system mailbox and outputs the contents of From and
Subject headers for each message. If a folder is specified in
the command line, the program reads that folder rather than the default
mailbox.
The program uses following option groups: See mailbox.
The following command line options alter the behavior of the program:
-f STRING
--field STRING
From Subject pair.
-l
--to
To header to the output. The output field
order is then: To From Subject.
-n
--number
-Q
--Quiet
-q
--query
-S
--summary
-s ATTR
--status ATTR
new, read,
unread. It is sufficient to specify only first letter of
an ATTR. Multiple -s options are allowed.
-t
--align
frm program from Elm package.
Mail is an enhanced version of standard /bin/mail program.
As well as its predecessor, it can be used either in sending mode or
in reading mode. Mail enters sending mode when one or more
email addresses were specified in this command line. In this mode the
program waits until user finishes composing the message, then attempts
to send it to the specified addresses and exits.
See Composing Mail, for a detailed description of this behavior.
If the command line contained no email addresses, mail switches
to reading mode. In this mode it allows to read and manipulate the
contents of a mailbox. The URL of the mailbox to operate upon is
taken from the argument of --file command line option. If it
is not specified, the user's system mailbox is assumed. For more
detail, see Reading Mail.
General usage of mail program is:
mail [OPTION...] [address...]
If [address...] part is present, mail switches to mail sending
mode, otherwise it operates in mail reading mode.
The program uses following option groups: See mailbox.
Mail understands following command line options:
-e
--exist
-f[FILE]
--file[=FILE]
-f), and its parameter. Similarly,
when using long option (--file), its argument must be preceded by
equal sign.
-F
--byname
-H
--headers
-i
--ignore
-m path
--mail-spool=path
-n
--norc
-N
--nosum
-p
--print
-r
--read
mail -N:
print * quit
-q
--quit
-s SUBJ
--subject=SUBJ
-t
--to
-u USER
--user=USER
mail -f/spool_path/USER
with spool_path being the full path to your mailspool directory
(/var/spool/mail or /var/mail on most systems).
-?
--help
--usage
-V
--version
Many mail commands such as print and delete can be given a message list to operate upon. Wherever the message list is omitted, the command operates on the current message.
The message list in its simplest form is one of:
In its complex form, the message list is a comma or whitespace-separated list of message specifiers. A message specifier is one of
:d
:n
:o
:r
:u
:t
:T
[header:]/string/
It selects all messages that contain header field header
matching given regexp. If the variable regexp is set,
the string is assumed to be a POSIX regexp. Otherwise, a
header is considered to match string if the latter constitutes
a substring of the former (comparison is case-insensitive).
If header: part is omitted, it is assumed to be Subject:.
:/string/
It selects all messages whose body matches the string. The matching rules are the same as described under "Header match".
A message specifier can be followed by message part specifier, enclosed in a pair of brackets. A message part specifier controls which part of a message should be operated upon. It is meaningful only for multipart messages. A message part specifier is a comma or whitespace - separated list of part numbers or ranges. Each part number can in turn be message part specifier, thus allowing for operating upon multiply-encoded messages.
The following are the examples of valid message lists:
You can compose the message by simply typing the contents of it, line
by line. But usually this is not enough, you would need to edit
your text, to quote some messages, etc. Mail provides these
capabilities through compose escapes. The compose escapes
are single-character commands, preceded by special escape character,
which defaults to ~. The combination escape character + command
is recognized as a compose escape only if it occurs at the beginning of
a line. If the escape character must appear at the beginning of a
line, enter it twice.
The actual escape character may be changed by setting the value of
escape mail variable (see Mail Variables).
There are several commands allowing you to quit the compose mode.
Typing the end-of-file character (C-D) on a line alone finishes
compose mode and sends the message to its destination. The C-D
character looses its special meaning if ignoreeof mail variable
is set.
If mail variable dot is set, typing dot (.) on a line
alone achieves the same effect as C-D above.
Finally, using ~. escape always quits compose mode and sends
out the composed message.
To abort composing of a message without sending it, type interrupt
character (by default, C-C) twice. This behavior is disabled
when mail variable ignore is set. In this case, you can use
~x escape to achieve the same effect.
The ~? escape prints on screen a brief summary of the available
compose escapes. Please note, that ~h escape prompts
for changing the header values, and does not give help.
If you are not satisfied with the message as it is, you can edit it
using a text editor specified either by EDITOR or by
VISUAL environment variables. The ~e uses the former,
and ~v uses the latter.
By default both escapes allow you to edit only the body of the
message. However, if the editheaders variable is set,
mail will load into the editor the complete text of
the message with headers included, thus allowing you to change
the headers as well.
To add new addresses to the list of message recipients, use ~t
command, e.g.:
~t name1@domain.net name2
To add addresses to Cc or Bcc, use ~c or ~b
escapes respectively.
To change the Subject header, use ~s escape, e.g.:
~s "Re: your message"
Finally, to edit all headers, type ~h escape. This will present
you with the values of To, Cc, Bcc, and
Subject headers allowing to edit them with normal text editing
commands.
If you are sending mail from within mail command mode, you can enclose
the contents of any message sent to you by using ~m or ~M
commands. Typing ~m alone will enclose the contents of the
current message, typing ~m 12 will enclose the contents of
message #12 and so on.
The ~m uses retained and ignored lists when enclosing headers,
the ~M encloses all header fields
(see Controlling Header Display).
In both cases, the contents of indentprefix mail variable is
prepended to each line enclosed.
To append the contents of file filename to the message, type
~r filename
or
~< filename
The ~d escape is a shorthand for
~r dead.letter
The ~p escape types the contents of the message entered so far,
including headers, on your terminal. You can save the message to
an arbitrary file using ~w escape. It takes the filename as its
argument.
To save you the effort of typing your signature at the end of each
message, you can use ~a or ~A escapes. If your signature
occupies one line only, save it to the variable sign and use
~a escape to insert it. Otherwise, if it is longer than one
line, save it to a file, store the name of this file in the
variable Sign, and use ~A escape to insert it into
the message.
Sometimes it is necessary to view the contents of another message,
while composing. These two escapes allow it. Both take the message
list as their argument. If they are used without argument, the
contents of the current message is printed. The difference between
~f and ~F is that the former uses ignored and retained
lists to select headers to be displayed, whereas the latter prints
all headers (see Controlling Header Display).
The ~i escape enters the value of the named mail variable into
the body of the message being composed.
You can execute a mail command from within compose mode using ~:
or ~- escapes. For example, typing
~: from :t
will display the from lines of all tagged messages. Note, that executing
mail-sending commands (see Replying) from within the compose mode is
not allowed. An attempt to execute such a command will result in
diagnostic message "Command not allowed in an escape sequence" being
displayed. Also, when starting compose mode immediately from the shell
(e.g. running mail address@domain), most mail commands are
meaningless, since there is no mailbox to operate upon. In this case,
the only commands that can reasonably be used are: alias,
unalias, alternate, set, and unset.
The ~! escape executes specified command and returns you to
mail compose mode without altering your message. When used without
arguments, it starts your login shell. The ~| escape pipes the
message composed so far through the given shell command and replaces the
message with the output the command produced. If the command produced
no output, mail assumes that something went wrong and retains
the old contents of your message.
To read messages from a given mailbox, use one of the following ways of
invoking mail:
mail
mail --file
mail --file=path_to_mailbox
mail --user=user
Please note, that usual mailbox permissions won't allow you to use the last variant of invocation, unless you are a super-user. Similarly, the last but one variant is also greatly affected by the permissions the target mailbox has.
Unless you have started mail with --norc command line option,
it will read the contents of the system-wide configuration file.
Then it reads the contents of user configuration file, if any.
For detailed description of these files, see Mail Configuration Files.
After this initial setup, mail displays the first page of header
lines and enters interactive mode. In interactive mode, mail
displays its prompt (?, if not set otherwise) and executes the
commands the user enters.
Following commands quit the program:
quit
mail was operating upon user's system
mailbox, then all undeleted and unsaved messages that have been read and
are not marked with hold flag are saved to the user's mbox file
($HOME/mbox). The messages, marked with delete are removed.
The program exits to the Shell, unless saving the mailbox fails, in
which case user can escape with the exit command.
exit
ex
xit
Typing EOF (C-D) alone is equivalent to quit.
Following commands can be used during the session to request online help:
help [command]
hel [command]
? [command]
list
*
version
ve
warranty
wa
next
n
previous
prev
cd [dir]
chdir [dir]
ch [dir]
file [mailbox]
fi [mailbox]
folder [mailbox]
fold [mailbox]
quit command has been issued.
If mailbox is omitted, the command prints the current mailbox
name followed by the summary information regarding it, e.g.:
& fold "/var/spool/mail/gray": 23 messages 22 unread
To control which headers in the message should be displayed, mail
keeps two lists: a retained header list and an ignored
header list. If retained header list is not empty, only the
header fields listed in it are displayed when printing the message.
Otherwise, if ignored header list is not empty, only the headers
not listed in this list are displayed. The uppercase variants
of message-displaying commands can be used to print all the headers.
The following commands modify and display the contents of both lists.
discard [header-field-list]
di [header-field-list]
ignore [header-field-list]
ig [header-field-list]
retain [header-field-list]
ret [header-field-list]
=
headers [msglist]
h [msglist]
from [msglist]
f [msglist]
From headers for a given set of messages.
z [arg]
headers
command. When arg is ., it is generally equivalent to
headers. When arg is omitted or is +, the next
pageful of headers is displayed. If arg is -, the
previous pageful of headers is displayed. The latter two forms
of z command may also take a numerical argument meaning the
number of pages to skip before displaying the headers. For
example:
& z +2
will skip two pages of messages before displaying the header summary.
size [msglist]
si [msglist]
folders
folder variable.
summary
su
& summary "/var/spool/mail/gray": 23 messages 22 unread
print [msglist]
p [msglist]
type [msglist]
t [msglist]
crt
determines the minimum number of lines the body of the message must
contain in order to be piped through pager command specified
by environment variable PAGER. If crt is set to a numeric
value, this value is taken as the minimum number of lines. Otherwise,
if crt is set without a value then the height of the terminal
screen is used to compute the threshold. The number of lines on
screen is controlled by screen variable.
Print [msglist]
P [msglist]
Type [msglist]
T [msglist]
decode [msglist]
dec [msglist]
decode command decodes and prints
out specified message parts. E.g.
& decode 15[2] +--------------------------------------- | Message=15[2] | Type=message/delivery-status | encoding=7bit +--------------------------------------- Content-Type: message/delivery-status ...
top [msglist]
to [msglist]
toplines and
defaults to five.
pipe [msglist] [shell-command]
| [msglist] [shell-command]
cmd is set,
the value of this variable is used as a command name.
tag [msglist]
ta [msglist]
:t notation.
untag [msglist]
unt [msglist]
& untag :t
hold [msglist]
ho [msglist]
preserve [msglist]
pre [msglist]
delete command.
delete [msglist]
d [msglist]
quit command these
messages will be deleted from the mailbox. Until the end of current
session the deleted messages can be referred to in message lists using
:d notation.
undelete [msglist]
u [msglist]
dp [msglist]
dt [msglist]
save [[msglist] file]
s [[msglist] file]
delete command, unless the variable
keepsave is set.
Save [msglist]
S [msglist]
save, but the file to append messages to is named after the
sender of the first message in msglist. For example:
& from 14 15 U 14 smith@noldor.org Fri Jun 30 18:11 14/358 The Save c U 15 gray@noldor.org Fri Jun 30 18:30 8/245 Re: The Sa & Save 14 15 "smith" 22/603
i.e., 22 lines (603 characters) have been appended to the file "smith".
If the file does not exist, it is created.
write [[msglist] file]
w [[msglist] file]
save, except that only message body (without the
header) is saved.
Write [msglist]
W [msglist]
Save, except that only message body (without the
header) is saved.
mbox [msglist]
mb [msglist]
touch [msglist]
tou [msglist]
quit command. This is the default action for
all read messages, unless you have variable hold set.
copy [[msglist] file]
c [[msglist] file]
save, except that saved messages are not marked for
deletion.
Copy [msglist]
C [msglist]
Save, except that saved messages are not marked for
deletion.
These command allow to edit messages in a mailbox. Please note,
that modified messages currently do not replace original ones. i.e.
you have to save them explicitly using your editor's save
command if you do not want the effects of your editing to be lost.
edit [msglist]
e [msglist]
EDITOR environment variable.
visual [msglist]
v [msglist]
VISUAL environment variable.
The # character introduces an end-of-line comment. All characters
until and including the end of line are ignored.
The echo (ec) command prints its arguments to stdout.
The command source filename reads commands from the named
file. Its minimal abbreviation is so.
The mail variables may be set using set (se) command. The
command takes a list of assignments. The syntax of an assignment is
name=string
")
name=number
name
True value.
noname
False value.
Example:
& set askcc nocrt indentprefix="> "
This statement sets askcc to True, crt to
False, and indentprefix to "> ".
To unset mail variables use unset(uns) command. The
command takes a list of variable names to unset.
Example:
To undo the effect of the previous example, do:
& unset askcc crt indentprefix
Shell environment may be modified using setenv (sete)
command. The command takes a list of assignments. The syntax of an
assignment is:
name=value
name
The conditional statement allows to execute a set of mail commands
depending on the mode the mail program is in. The conditional
statement is:
if cond ... else ... endif
where ... represents the set of commands to be executed in each
branch of the statement. cond can be one of the following:
s
mail is operating in mail sending mode.
r
mail is operating in mail reading mode.
t
The conditional statements can be nested to arbitrary depth. The minimal
abbreviations for if, else and endif commands are
i, el and en.
Example:
if t set crt prompt="& " else unset prompt endif if s alt gray@farlep.net gray@mirddin.farlep.net set
alias [alias [address...]]
a [alias [address...]]
group [alias [address...]]
g [alias [address...]]
unalias [alias...]
una [alias...]
alternates name...
alt name...
mail [address...]
m [address...]
reply [msglist]
respond [msglist]
r [msglist]
Reply [msglist]
Respond [msglist]
R [msglist]
reply, except that the composed message is sent only to
originators of the specified messages.
followup [msglist]
fo [msglist]
Followup [msglist]
F [msglist]
followup, but reply message is sent only to
originators of messages in msglist.
The incorporate (inc) command incorporates newly arrived
messages to the displayed list of messages. This is done automatically
before returning to mail command prompt if the variable
autoinc is set.
To run arbitrary shell command from mail command prompt, use
shell (sh) command. If no arguments are specified, the
command starts the user login shell. Otherwise, it uses its first
argument as a file name to execute and all subsequent arguments are
passed as positional parameters to this command. The shell
command can also be spelled as !.
Following variables control the behavior of GNU mail:
Sign
Contains the filename holding users signature. The contents of this
file is appended to the end of a message being composed by ~A
escape.
appenddeadletter
If this variable is True, the contents of canceled letter is
appended to the user's dead.letter file. Otherwise it overwrites
its contents.
askbcc
When set to True the user will be prompted to enter Bcc
field before composing the message.
askcc
When set to True the user will be prompted to enter Cc
field before composing the message.
asksub
When set to True the user will be prompted to enter Subject
field before composing the message.
autoinc
Automatically incorporate newly arrived messages.
autoprint
Causes the delete command to behave like dp - thus, after deleting a
message, the next one will be typed automatically.
cmd
Contains default shell command for pipe.
columns
COLUMNS is used.
This variable contains the number of columns on terminal screen.
crt
The variable crt determines the minimum number of lines the body
of the message must contain in order to be piped through pager command
specified by environment variable PAGER. If crt is set
to a numeric value, this value is taken as the threshold. Otherwise,
if crt is set without a value, then the height of the terminal
screen is used to compute the threshold. The number of lines on
screen is controlled by screen variable.
dot
If True, causes mail to interpret a period alone on a line as the
terminator of a message you are sending.
editheaders
When set, mail will include message headers in the text to
be the ~e and ~v escapes, thus allowing you to customize
the headers.
escape
If defined, the first character of this option gives the character to
denoting escapes.
folder
The name of the directory to use for storing folders of messages. If
unset, $HOME is assumed.
header
--nosum (-N) option.
Whether to run headers command automatically after entering
interactive mode.
hold
When set to True, the read or saved messages will be stored in
user's mailbox ($HOME/mbox). Otherwise, they will be held in
system mailbox also. This option is in effect only when operating
upon user's system mailbox.
ignore
When set to True, mail will ignore keyboard interrupts
when composing messages. Otherwise an interrupt will be taken as a
signal to abort composing.
ignoreeof
Controls whether typing EOF character terminates the letter being
composed.
indentprefix
String used by the ~m tilde escape for indenting quoted messages.
keepsave
Controls whether saved messages should be kept in system mailbox too.
This variable is in effect only when operating upon a user's system
mailbox.
metoo
Usually, when an alias is expanded that contains the sender, the sender
is removed from the expansion. Setting this option causes the sender to
be included in the group.
mode
Setting this variable does not affect the operation mode of the program.
noregex
Setting this to True enables use of regular expressions in
/.../ message specifications.
outfolder
Contains the directory in which files created by save,
write, etc. commands will be stored. When unset, current
directory is assumed.
page
If set to True, the pipe command will emit a linefeed
character after printing each message.
prompt
Contains the command prompt sequence.
quiet
When set, suppresses the output of the startup banner.
quit
--quit (-q) option.
When set, causes keyboard interrupts to terminate the program.
rc
--norc (-N) option.
When this variable is set, mail will read the system-wide
configuration file upon startup. See Mail Configuration Files.
record
When set, any outgoing message will be saved to the named file.
save
When set, the aborted messages will be stored in the user's
dead.file. See also appenddeadletter.
screen
LINES is used.
This variable contains the number of lines on terminal screen.
sendmail
Contains the URL of mail transport agent.
sign
Contains the user's signature. The contents of this variable is appended
to the end of a message being composed by ~a escape. Use
Sign variable, if your signature occupies more than one line.
subject
Contains default subject line. This will be used when asksub is
off.
toplines
Number of lines to be displayed by top and Top commands.
verbose
When set, the actual delivery of messages is displayed on the user's terminal.
Upon startup, mail reads the contents of the two command files:
the system-wide configuration file, and the user's configuration
file. Each line read from these files is processed like a usual
mail command.
When run with --norc (-N) option, mail does
not read the contents of system-wide configuration file. The user's
file, if it exists, is always processed.
The user's configuration file is located in the user's home
directory and is named .mailrc. The location and name of
the system-wide configuration file is determined when configuring the
package via --with-mail-rc option. It defaults to
sysconfdir/mail.rc.
mail.local reads the standard input up to an end-of-file
and appends the received data to the local mailboxes.
The program uses following option groups: See mailbox, See auth, See logging, See sieve.
-f addr
--from addr
mail.local to
add From envelope to the beginning of the message. If it is
not specified, mail.local first looks into the first line
from the standard input. If it starts with From , it is assumed
to contain a valid envelope. If it does not, mail.local
creates the envelope by using current user name and date.
-h
--help
-L
--license
-m path
--mail-spool path
-q
--quota-db file
-s pattern
--source pattern
%u and %h in the pattern are expanded to
the current recipient user name and home directory correspondingly.
This option is available only if the package has been configured to
use Guile extension language.
-S pattern
--sieve pattern
%u and %h in the pattern are expanded to
the current recipient user name and home directory correspondingly.
-t number
--timeout number
-x flags
--debug flags
g
T
P
t
l
The digits in the range 0 - 9 used in flags set
mail.local debugging level.
-v
--version
--ex-multiple-delivery-success
--ex-quota-tempfail
This section explains how to invoke mail.local from
configuration files of various Mail Transport Agents.
All examples in this section suppose that mail.local
must receive following command line switches:
-s %h/.filter.scm -q /etc/mail/userquota
The mail.local must be invoked from the local mailer
definition in the sendmail.cf file. It must have the
following flags set lswS, meaning the mailer is local,
the quote characters should be stripped off the address before
invoking the mailer, the user must have a valid account on this
machine and the userid should not be reset before calling the
mailer. Additionally, fn flags may be specified to allow
mail.local to generate usual From envelope
instead of the one supplied by sendmail.
Here is an example of mailer definition in sendmail.cf
Mlocal, P=/usr/local/libexec/mail.local,
F=lsDFMAw5:/|@qSPfhn9,
S=EnvFromL/HdrFromL, R=EnvToL/HdrToL,
T=DNS/RFC822/X-Unix,
A=mail -s %h/.filter.scm -q /etc/mail/userquota $u
To define local mailer in mc source file, it will suffice to
set:
define(`LOCAL_MAILER_PATH', `/usr/local/libexec/mail.local')
define(`LOCAL_MAILER_ARGS',
`mail -s %h/.filter.scm -q /etc/mail/userquota $u')
Using mail.local with exim is quite straightforward. The
following example illustrates the definition of appropriate transport
and director in exim.conf:
# transport
mail_local_pipe:
driver = pipe
command = /usr/local/libexec/mail.local -s %h/.filter.scm \
-q /etc/mail/userquota $local_part
return_path_add
delivery_date_add
envelope_to_add
# director
mail_local:
driver = localuser
transport = mail_local_pipe
Messages prints on standard output the number of messages
contained in each folder specified in command line. If no folders
are specified, it operates upon user's system mailbox. For each
folder, the following output line is produced:
Number of messages in folder: number
where folder represents the folder name, number represents the number of messages.
The program uses following option groups: See mailbox.
The program accepts following command line options:
-q
--quite
-s
--silent
-?
--help
--usage
-V
--version
The program, readmsg, extracts with the selection argument messages from a mailbox. Selection can be specify by:
readmsg 1 3 0extracts three messages from the folder: the first, the third, and the last.
readmsg staff meetingextracts the message which contains the words "staff meeting." Note that it will not match a message containing "Staff Meeting" - the matching is case sensitive. Normally only the first message which matches the pattern will be printed.
-a
--show-all
-d
--debug
-f MAILBOX
--folder=MAILBOX
-h
--header
-n
--no-header
-p
--form-feed
-w weedlist
--weedlist=weedlist
Sieve is a language for filtering e-mail messages at time of final delivery, described in RFC 3028. GNU Mailutils provides two implementations of this language: a stand-alone sieve interpreter and a sieve translator and filter. The following sections describe these utilities in detail.
Sieve interpreter sieve allows to apply Sieve scripts to an
arbitrary number of mailboxes. GNU sieve implements a superset
of the Sieve language as described in RFC 3028. See Input Language,
for a description of the Sieve language. See Extensions, for a
discussion of differences between the GNU implementation of Sieve and
its standard.
The sieve invocation syntax is:
sieve [options] script
where script denotes the filename of the sieve program to parse, and options is one or more of the following:
-c
--compile-only
-d[flags]
--debug[=flags]
g | Enable main parser traces
|
T | Enable mailutil traces
|
P | Trace network protocols
|
t | Enable sieve trace
|
i | Trace the program instructions
|
See Logging and Debugging, for detailed discussion of these.
-D
--dump
-e address
--email address
reject and
redirect actions. By default, the user email address is deduced
from the user name and the full name of the machine where sieve is
executed.
-f
--mbox-url=mbox
-k
--keep-going
-n
--no-actions
-t ticket
--ticket=ticket
-v
--verbose
Apart from these, sieve understands the options from the
following groups: sieve, mailbox, mailer,
logging.
The default behavior of sieve is to remain silent about
anything except errors. However, it is sometimes necessary to see
which actions are executed and on which messages. This is particularly
useful when debugging the sieve scripts. The --verbose
(-v) option outputs log of every action executed.
Option --debug allows to produce even more detailed debugging
information. This option takes an argument specifying the
debugging level to be enabled. The argument can consist of the
following letters:
tTmailutils library.
PgiNote, that there should be no whitespace
between the short variant of the option (-d), and its
argument. Similarly, when using long option (--debug),
its argument must be preceded by equal sign.
If the argument to --debug is omitted, it defaults to
TPt.
Option --dump produces the disassembled dump of the compiled
sieve program.
By default sieve output all diagnostics on standard error and verbose
logs on standard output. This behaviour is changed when
--log-facility is given in the command line (see logging).
This option causes sieve to output its diagnostics to
the given syslog facility.
The basic set of sieve actions, tests and comparators may be extended
using loadable extensions. Usual require mechanism is used for
that.
When processing arguments for require statement, sieve
uses the following algorithm:
comparator- it is looked up in the comparator table. If it
begins with test-, the test table is used instead. Otherwise
the name is looked up in the action table.
comparator- or
test- prefix is stripped. Then, any character other than
alphanumeric characters, . and , is replaced with
dash (-). The name thus obtained is used as a file name
of an external loadable module.
$prefix/lib/mailutils.
#searchpath directive.
/etc/ld.so.conf and the value of the environment variable
LD_LIBRARY_PATH).
The value of LTDL_LIBRARY_PATH and LD_LIBRARY_PATH must be a
colon-separated list of absolute directories, for example,
"/usr/lib/mypkg:/lib/foo".
In any of these directories, sieve first attempts to find
and load the given filename. If this fails, it tries to append the
following suffixes to the file name:
.la
.so, .sl, etc.
sieve executes its
initialization function (see below) and again looks up the name
in the symbol table. If found, search terminates successfully.
sieve then displays
the following diagnostic message:
source for the required action NAME is not available
A Sieve to Scheme Translator sieve.scm translates a given
Sieve script into an equivalent Scheme program and optionally executes
it. The program itself is written in Scheme and requires presence of
Guile 1.4 on the system. For more information on Guile refer to
Overview.
-f filename
--file filename
-o filename
--output filename
-L dirname
--lib-dir dirname
-d level
--debug level
The Scheme programs produced by sieve.scm can be used with
guimb or mail.local.
Guimb is for mailboxes what awk is for text files.
It processes mailboxes, applying the user-supplied scheme procedures
to each of them in turn and saves the resulting output in mailbox
format.
The program uses following option groups: See mailbox.
The Scheme program or expression to be executed is passed to
guimb via the following options:
-s file
--source file
-c expr
--code expr
The above switches stop further argument processing, and pass all
remaining arguments as the value of (command-line).
If the remaining arguments must be processed by guimb itself,
use following options:
-e expr
--expression expr
-f file
--file file
You can specify both of them. In this case, the file is read
first, then expr is executed. You may still pass any additional
arguments to the script using --guile-arg option
(see Passing Options to Scheme).
There are four basic ways of passing mailboxes to guimb.
guimb [options] [mailbox...]
guimb [options] --mailbox defmbox
guimb [options] --mailbox defmbox mailbox [mailbox...]
guimb [options] --user username [mailbox...]
guimb as a mail delivery agent.
If no mailboxes are specified in the command line, guimb reads
and processes the system mailbox of the current user.
Sometimes it is necessary to pass some command line options to the scheme procedure. There are three ways of doing so.
When using --source (-s) or --code
(-c) options, all the rest of the command line following
the option's argument is passed to Scheme program verbatim. This
allows for making guimb scripts executable by the shell. If your system
supports #! magic at the start of scripts, add the following two
lines to the beginning of your script to allow for its immediate execution:
#! /usr/local/bin/guimb -s !#
(replace /usr/local/bin/ with the actual path to the guimb).
Otherwise, if you use --file or --expression options,
the additional arguments may be passed to the Scheme program -g
(--guile-arg) command line option. For example:
guimb --guile-arg -opt --guile-arg 24 --file progfile
In this example, the scheme procedure will see the following command line:
progfile -opt 24
Finally, if there are many arguments to be passed to Scheme, it is more
convenient to enclose them in -{ and -} escapes:
guimb -{ -opt 24 -} --file progfile
This is a short summary of the command line options available to
guimb.
-d
--debug
-e EXPR
--expression EXPR
-m path
--mail-spool=path
-f PROGFILE
--file PROGFILE
-g ARG
--guile-command ARG
-{ ... -}
-{ and -}
to Scheme program.
-m
--mailbox MBOX
-u
--user NAME
-h
--help
-v
--version
Comsatd is the server which receives reports of incoming mail and
notifies users, wishing to get this service. It can be started
either from inetd.conf or as a standalone daemon.
Comsatd uses following option groups: See mailbox,
See daemon, See logging.
-c file
--config file
-d
--daemon
-i
--inetd
/etc/inetd.conf file:
comsat dgram udp wait root /usr/sbin/comsatd \ comsatd -c /etc/comsat.conf
This is the default operation mode.
-m path
--mail-spool=path
-p number
--port number
-v
--version
-h
--help
The configuration parameters for comsatd are kept in a single
configuration file. The file uses line-oriented format: each line
contains a single statement. Comments are introduced with the #
sign and empty lines are ignored. You can specify the configuration
file to use by using -c or --config command line switch.
The configuration file statements can logically be subdivided into General Settings, Security Settings and Access Control Lists. The following sections address each of these statement group in detail.
These statements control the general behavior of the comsat daemon:
.biffrc file. By default,
it is enabled.
These statements control the way comsatd fights possible
flooding attacks.
request-control-interval.
Access control lists determine from which addresses comsatd
will receive mail notification messages.
The access control lists are introduced in configuration file using
keyword acl. General format for an ACL rule is
acl action netlist
Here, action specifies the action to be taken when a request
arrives from one of the networks, listed in netlist. There are
two possible actions: allow and deny.
The netlist is a whitespace-separated list of network numbers. Each network number may be specified in one of the following forms:
any
0.0.0.0/0.
Upon receiving a notification message, comsatd compares its
source address against each ACL rule in the order of their appearance
in the configuration file. The first rule that matches the packet
determines whether the message will be processed or rejected. If
no matching rule was found, the default rule applies. Currently, default
rule is
acl allow any
If you don't need such behavior, specify the default rule explicitly.
For example, the common use would be:
acl allow 127.0.0.1 acl deny any
which makes comsatd receive the notification messages from
localhost only.
By default, when a notification arrives, comsatd prints subject,
from headers and the first five lines from the new message to the user's
tty. The user is allowed to change this behavior by using his own
configuration file. This file should be located in the user's home
directory and should be named .biffrc. It must be owned by the
user and have its permissions bits set to 0600. (Please note,
that the use of per-user configuration files may be disabled, by
specifying allow-biffrc no in the main configuration file, see
see Configuring comsatd).
The .biffrc file consists of a series of statements. Each
statement occupies one line and defines an action to be taken upon
arrival of a new mail. Very long lines may be split using \ as
the last character on the line. As usual, comments may be introduced with
# character.
The actions specified in .biffrc file are executed in turn.
The following actions are defined:
In the description above, string denotes any sequence of
characters. This sequence must be enclosed in a pair of double-quotes,
if it contains whitespace characters. The \ character inside a
string starts a C escape sequence. Following meta-characters may be
used in strings:
name.
Dump to the user's terminal the contents of From and
Subject headers followed by at most 5 lines of message body.
echo "Mail to \a$u@$h\a\n---\n\
From: $H{from}\n\
Subject: $H{Subject}\n\
---\n\
$B(,5)\
---\n"
Produce a bell, then pop up the xmessage window on display :0.0 with
the text formatted in the same manner as in the previous example.
beep
exec /usr/X11R6/bin/xmessage \
-display :0.0 -timeout 10 "Mail to $u@$h \n---\n\
From: $H{from}\n\
Subject: $H{Subject}\n\
---\n\
$B(,5)\
---\n"
This program is designed for developers wishing to link their programs against libmailbox. It allows to examine the particulars of the current build of Mailutils and to get the command line parameters necessary for compiling and linking an application with Mailutils libraries.
When invoked with the option --compile, or its short form
-c, mailutils-config prints the flags
that must be given to the compiler for compiling the program using
Mailutils functions. An example usage:
cc -omyprog.o `mailutils-config --compile` myprog.c
The --link, or its short form -l prints to the
standard output the loader flags necessary to link a program against
Mailutils libraries.
When invoked without arguments, it produces the flags necessary to
link against the basic library of Mailutils: libmailbox.
Up to two arguments may be given that alter this behavior. These
are:
auth
libmuauth, the library adding new
authentication methods to libmailbox.
guile
libmu_scm, the Guile interface
library.
Both arguments may be given simultaneously, e.g.:
cc -omyprog myprog.o `mailutils-config --link auth guile`
The --info, or -i retrieves the options (flags) used
when building Mailutils. It may be used with or without
arguments.
When used without arguments, it prints the list of all
build flags, e.g.:
$ mailutils-config --info VERSION=0.1.3 USE_LIBPAM HAVE_LIBLTDL WITH_GUILE WITH_READLINE HAVE_MYSQL ENABLE_VIRTUAL_DOMAINS ENABLE_IMAP ENABLE_POP ENABLE_MH ENABLE_SMTP ENABLE_SENDMAIL
This option also accepts any number of arguments. When these are
given, each argument is treated as a name of a build flag.
Mailutils-config checks if such a flag was defined and
prints its full name if so. It exits with zero code if all the
flags given on the command line are defined. Otherwise, it
exits with code of 1.
The comparison of the flag names is case-insensitive. The arguments given need not include the leading prefix (i.e. the characters up to and including the first underscore character).
Given the previous example, the invocation
$ mailutils --info readline use_libpam pop
will produce the following output:
WITH_READLINE USE_LIBPAM ENABLE_POP
and will exit with a zero status.
The following command:
$ mailutils --info readline gssapi pop
will exit with status 1, and will print:
WITH_READLINE ENABLE_POP
since WITH_GSSAPI flag is not defined.
The flags and their meanings are:
libltdl is present and is used
by Mailutils. See Using libltdl, for
more information on libltdl library.
--with-db2 option).
--with-ndbm option).
--with-dbm option).
--with-gdbm option). See Introduction, for
information about this library.
--with-gssapi option).
--with-guile option).
See Overview, for information
about Guile.
--with-readline option).
See Top, for more information.
--enable-mysql option).
--enable-virtual-domains option).
Email bug reports to bug-mailutils@gnu.org. Be sure to include the word "mailutils" somewhere in the "Subject:" field.
As the purpose of bug reporting is to improve software, please be sure to include maximum information when reporting a bug. The information needed is:
The archives of bug-mailutils mailing list are available from
<http://mail.gnu.org/mailman/listinfo/bug-mailutils>.
The two places to look for any news regarding GNU Mailutils are the
Mailutils homepage at <http://www.gnu.org/software/mailutils>, and the
project page at <http://savannah.gnu.org/projects/mailutils>.
The updated versions of this manual are available online from
<http://www.gnu.org/software/mailutils/manual>.
In no particular order,
This is an alphabetical list of all Mailutils functions.
*sieve_get_data: Manipulating the Sieve Machine
address: Tests
address_aget_email: Address
address_create: Address
address_createv: Address
address_destroy: Address
address_get_comments: Address
address_get_count: Address
address_get_domain: Address
address_get_email: Address
address_get_local_part: Address
address_get_personal: Address
address_get_route: Address
address_is_group: Address
address_t: Address
address_to_string: Address
attribute_copy: Attribute
attribute_create: Attribute
attribute_destroy: Attribute
attribute_is_answered: Attribute
attribute_is_deleted: Attribute
attribute_is_draft: Attribute
attribute_is_equal: Attribute
attribute_is_flagged: Attribute
attribute_is_read: Attribute
attribute_is_recent: Attribute
attribute_is_seen: Attribute
attribute_set_answered: Attribute
attribute_set_deleted: Attribute
attribute_set_draft: Attribute
attribute_set_flagged: Attribute
attribute_set_read: Attribute
attribute_set_recent: Attribute
attribute_set_seen: Attribute
attribute_to_string: Attribute
attribute_unset_answered: Attribute
attribute_unset_deleted: Attribute
attribute_unset_draft: Attribute
attribute_unset_flagged: Attribute
attribute_unset_read: Attribute
attribute_unset_recent: Attribute
attribute_unset_seen: Attribute
auth_authenticate: Authenticator
auth_create: Authenticator
auth_destroy: Authenticator
auth_epilogue: Authenticator
auth_prologue: Authenticator
body_create: Body
body_destroy: Body
body_get_filename: Body
body_get_stream: Body
body_lines: Body
body_set_filename: Body
body_set_stream: Body
body_size: Body
char*: URL
decoder_stream_create: Stream
discard: Actions
encoder_stream_create: Stream
envelope: Tests
envelope_create: Envelope
envelope_date: Envelope
envelope_destroy: Envelope
envelope_get_message: Envelope
envelope_sender: Envelope
envelope_set_date: Envelope
envelope_set_sender: Envelope
exists: Tests
false: Tests
file_stream_create: Stream
fileinto: Actions
folder_close: Folder
folder_create: Folder
folder_delete: Folder
folder_destroy: Folder
folder_get_authority: Folder
folder_get_debug: Folder
folder_get_observable: Folder
folder_get_stream: Folder
folder_get_url: Folder
folder_list: Folder
folder_lsub: Folder
folder_open: Folder
folder_rename: Folder
folder_set_authority: Folder
folder_set_debug: Folder
folder_set_stream: Folder
folder_set_url: Folder
folder_subscribe: Folder
folder_unsubscribe: Folder
header: Tests
header_aget_value: Headers
header_create: Headers
header_destroy: Headers
header_get_stream: Headers
header_get_value: Headers
header_set_lines: Headers
header_set_size: Headers
header_set_value: Headers
iterator_create: Iterator
iterator_current: Iterator
iterator_destroy: Iterator
iterator_first: Iterator
iterator_is_done: Iterator
iterator_next: Iterator
keep: Actions
locker_create: Locker
locker_destroy: Locker
locker_lock: Locker
locker_touchlock: Locker
locker_unlock: Locker
mailbox_append_message: Mailbox
mailbox_close: Mailbox
mailbox_create: Mailbox
mailbox_create_default: Mailbox
mailbox_destroy: Mailbox
mailbox_expunge: Mailbox
mailbox_get_debug: Mailbox
mailbox_get_folder: Mailbox
mailbox_get_locker: Mailbox
mailbox_get_message: Mailbox
mailbox_get_observable: Mailbox
mailbox_get_property: Mailbox
mailbox_get_size: Mailbox
mailbox_get_stream: Mailbox
mailbox_get_ticket: Mailbox
mailbox_get_url: Mailbox
mailbox_is_modified: Mailbox
mailbox_message_unseen: Mailbox
mailbox_messages_count: Mailbox
mailbox_messages_recent: Mailbox
mailbox_open: Mailbox
mailbox_scan: Mailbox
mailbox_set_locker: Mailbox
mailbox_set_stream: Mailbox
mailbox_set_ticket: Mailbox
mailbox_t: Mailbox
mailbox_uidnext: Mailbox
mailbox_uidvalidity: Mailbox
mailer_close: Mailer
mailer_create: Mailer
mailer_destroy: Mailer
mailer_get_debug: Mailer
mailer_get_observable: Mailer
mailer_get_property: Mailer
mailer_get_stream: Mailer
mailer_get_url: Mailer
mailer_open: Mailer
mailer_send_message: Mailer
mailer_set_debug: Mailer
mailer_set_stream: Mailer
mapfile_stream_create: Stream
memory_stream_create: Stream
message_create: Message
message_create_attachment: Message
message_destroy: Message
message_encapsulate: Message
message_get_attribute: Message
message_get_body: Message
message_get_envelope: Message
message_get_header: Message
message_get_num_parts: Message
message_get_observable: Message
message_get_part: Message
message_get_stream: Message
message_get_uid: Message
message_get_uidl: Message
message_is_multipart: Message
message_save_attachment: Message
message_set_attribute: Message
message_set_body: Message
message_set_envelope: Message
message_set_header: Message
message_set_stream: Message
message_set_uidl: Message
message_unencapsulate: Message
mu-address-get-comments: Address Functions
mu-address-get-count: Address Functions
mu-address-get-domain: Address Functions
mu-address-get-email: Address Functions
mu-address-get-local: Address Functions
mu-address-get-personal: Address Functions
mu-closelog: Log Functions
mu-logger: Log Functions
mu-mailbox-append-message: Mailbox Functions
mu-mailbox-close: Mailbox Functions
mu-mailbox-expunge: Mailbox Functions
mu-mailbox-get-message: Mailbox Functions
mu-mailbox-get-port: Mailbox Functions
mu-mailbox-get-url: Mailbox Functions
mu-mailbox-messages-count: Mailbox Functions
mu-mailbox-open: Mailbox Functions
mu-mailbox-url: Mailbox Functions
mu-message-copy: Message Functions
mu-message-delete: Message Functions
mu-message-get-body: Message Functions
mu-message-get-flag: Message Functions
mu-message-get-header: Message Functions
mu-message-get-header-fields: Message Functions
mu-message-get-lines: Message Functions
mu-message-get-port: Message Functions
mu-message-get-sender: Message Functions
mu-message-get-size: Message Functions
mu-message-get-user-flag: Message Functions
mu-message-send: Message Functions
mu-message-set-flag: Message Functions
mu-message-set-header: Message Functions
mu-message-set-header-fields: Message Functions
mu-message-set-user-flag: Message Functions
mu-mime-add-part: MIME Functions
mu-mime-create: MIME Functions
mu-mime-get-message: MIME Functions
mu-mime-get-num-parts: MIME Functions
mu-mime-get-part: MIME Functions
mu-mime-multipart?: MIME Functions
mu-openlog: Log Functions
mu_auth_data: Data Types
mu_auth_data_alloc: Module Creation and Destruction
mu_auth_data_free: Module Creation and Destruction
mu_auth_fp: Data Types
mu_auth_generic_module: Existing Modules
mu_auth_init: Initializing the libmuauth
mu_auth_module: Data Types
mu_auth_nosupport: Existing Modules
mu_auth_pam_module: Existing Modules
MU_AUTH_REGISTER_ALL_MODULES: Initializing the libmuauth
mu_auth_register_module: Module Creation and Destruction
mu_auth_runlist: Obtaining Authorization Information
mu_auth_sql_module: Existing Modules
mu_auth_system_module: Existing Modules
mu_auth_virtual_module: Existing Modules
mu_authenticate: Obtaining Authorization Information
mu_get_auth_by_name: Obtaining Authorization Information
mu_get_auth_by_uid: Obtaining Authorization Information
MU_STREAM_APPEND: Stream
MU_STREAM_CREAT: Stream
MU_STREAM_NO_CHECK: Stream
MU_STREAM_NO_CLOSE: Stream
MU_STREAM_NONBLOCK: Stream
MU_STREAM_RDWR: Stream
MU_STREAM_READ: Stream
MU_STREAM_WRITE: Stream
numaddr: Tests
parse822_addr_spec: Parse822
parse822_address: Parse822
parse822_address_list: Parse822
parse822_domain: Parse822
parse822_domain_literal: Parse822
parse822_domain_ref: Parse822
parse822_field_body: Parse822
parse822_field_name: Parse822
parse822_group: Parse822
parse822_local_part: Parse822
parse822_mail_box: Parse822
parse822_quote_local_part: Parse822
parse822_quote_string: Parse822
parse822_route: Parse822
parse822_route_addr: Parse822
parse822_sub_domain: Parse822
parse822_unix_mbox: Parse822
redirect: Actions
reject: Actions
sieve_abort: Logging and Diagnostic Functions
sieve_action_log_t: Sieve Data Types
sieve_action_lookup: Symbol Space Functions
sieve_comparator_t: Sieve Data Types
sieve_compile: Compiling and Executing the Script
sieve_data_type: Sieve Data Types
sieve_debug: Logging and Diagnostic Functions
sieve_destructor_t: Sieve Data Types
sieve_disass: Compiling and Executing the Script
sieve_error: Logging and Diagnostic Functions
sieve_get_daemon_email: Manipulating the Sieve Machine
sieve_get_debug_level: Manipulating the Sieve Machine
sieve_get_mailer: Manipulating the Sieve Machine
sieve_get_message: Manipulating the Sieve Machine
sieve_get_message_num: Manipulating the Sieve Machine
sieve_get_ticket: Manipulating the Sieve Machine
sieve_handler_t: Sieve Data Types
sieve_is_dry_run: Manipulating the Sieve Machine
sieve_load_ext: Symbol Space Functions
sieve_log_action: Logging and Diagnostic Functions
sieve_machine_add_destructor: Manipulating the Sieve Machine
sieve_machine_destroy: Manipulating the Sieve Machine
sieve_machine_init: Manipulating the Sieve Machine
sieve_machine_t: Sieve Data Types
sieve_mailbox: Compiling and Executing the Script
sieve_malloc: Memory Allocation
sieve_message: Compiling and Executing the Script
sieve_mfree: Memory Allocation
sieve_mrealloc: Memory Allocation
sieve_mstrdup: Memory Allocation
sieve_parse_error_t: Sieve Data Types
sieve_printf_t: Sieve Data Types
sieve_register_action: Symbol Space Functions
sieve_register_comparator: Symbol Space Functions
sieve_register_test: Symbol Space Functions
sieve_retrieve_t: Sieve Data Types
sieve_runtime_tag_t: Sieve Data Types
sieve_set_daemon_email: Manipulating the Sieve Machine
sieve_set_debug: Manipulating the Sieve Machine
sieve_set_debug_level: Manipulating the Sieve Machine
sieve_set_error: Manipulating the Sieve Machine
sieve_set_logger: Manipulating the Sieve Machine
sieve_set_mailer: Manipulating the Sieve Machine
sieve_set_parse_error: Manipulating the Sieve Machine
sieve_set_ticket: Manipulating the Sieve Machine
sieve_tag_checker_t: Sieve Data Types
sieve_tag_def_t: Sieve Data Types
sieve_tag_lookup: Symbol Space Functions
sieve_test_lookup: Symbol Space Functions
sieve_type_str: Manipulating the Sieve Machine
sieve_value_t: Sieve Data Types
size: Tests
stdio_stream_create: Stream
stop: Actions
stream_close: Stream
stream_create: Stream
stream_destroy: Stream
stream_flush: Stream
stream_get_fd: Stream
stream_get_flags: Stream
stream_get_state: Stream
stream_is_seekable: Stream
stream_open: Stream
stream_read: Stream
stream_readline: Stream
stream_setbufsiz: Stream
stream_size: Stream
stream_truncate: Stream
stream_write: Stream
string_to_attribute: Attribute
tcp_stream_create: Stream
true: Tests
url_create: URL
url_decode: URL
url_destroy: URL
url_get_host: URL
url_get_passwd: URL
url_get_path: URL
url_get_port: URL
url_get_query: URL
url_get_scheme: URL
url_get_user: URL
url_parse: URL
comsatd: comsatd
frm: frm
guimb: guimb
imap4d: imap4d
mail: mail
mail.local: mail.local
mailutils-config: mailutils-config
messages: messages
pop3d: pop3d
readmsg: readmsg
sieve: sieve
This is a general index of all issues discussed in this manual
Actually it shoud have been struct mu_auth_data** return_data.
This will be fixed in the next release
If # is not the first character on the line, it
should be separated from the previous word by any amount of whitespace.