SYNOPSIS

$HOME/.imapfilter/config.lua

DESCRIPTION

imapfilter(1) uses the Lua programming language as a configuration and extension language, therefore the configuration file is a Lua script.

Although knowledge of Lua is not required to use imapfilter(1), it is nonetheless recommended, especially if one wants to extend it. For more information on Lua see http://www.lua.org/docs.html

CONVENTIONS

A brief description of the Lua values and types mentioned hereafter in the manual page follows:

The

Vt nil is the type of the value ``nil'' whose main property is to be different from any other value; usually it represents the absence of a useful value.

The

Vt boolean is the type of the values ``true'' and ``false'' Both ``nil'' and ``false'' make a condition false; any other value makes it true.

The type

Vt number represents real numbers.

The type

Vt string represents a sequence of characters and can be defined using single quotes, double quotes or double square brackets.

The type

Vt table implements associative arrays, that is, arrays that can be indexed not only with numbers, but with any value.

A

Vt function is a first-class value; it can be stored in variables, passed as argument to other functions, and returned as a result.

OPTIONS

Program's options are set using an already initialised Vt table named ``options'' in the following manner:

options.timeout = 120
options.namespace = false
options.charset = 'ISO-8859-1'

Available options are:

cache

When this option is enabled, parts of messages are cached locally in memory to avoid being downloaded more than once. The cache is preserved for the current session only. This variable takes a Vt boolean as a value. Default is ``true''

certificates

When this option is enabled, the server certificate can be accepted and stored, in order to validate the authenticity of the server in future connections. This variable takes a Vt boolean as a value. Default is ``true''

charset

Indicates to the server the character set of the strings for the searching methods. This variable takes a Vt string as a value. By default no character set is set, and thus plain ASCII should be assumed by the server.

create

According to the IMAP specification, when trying to write a message to a non-existent mailbox, the server must send a hint to the client, whether it should create the mailbox and try again or not. However some IMAP servers don't follow the specification and don't send the correct response code to the client. By enabling this option the client tries to create the mailbox, despite of the server's response. This variable takes a Vt boolean as a value. Default is ``false''

close

This option controls whether the currently selected mailbox is implicitly closed at the end of each performed operation, thus removing all messages that are marked deleted. This variable takes a Vt boolean as a value. Default is ``false''

crammd5

When this option is enabled and the server supports the Challenge-Response Authentication Mechanism (specifically CRAM-MD5), this method will be used for user authentication instead of a plaintext password LOGIN. This variable takes a Vt boolean as a value. Default is ``true''

expunge

Normally, messages are marked for deletion and are actually deleted when the mailbox is closed. When this option is enabled, messages are expunged immediately after being marked deleted. This variable takes a Vt boolean as a value. Default is ``true''

info

When this options is enabled, a summary of the program's actions is printed, while processing mailboxes. This variable takes a Vt boolean as a value. Default is ``true''

keepalive

The time in minutes before terminating and re-issuing the IDLE command, in order to keep alive the connection, by resetting the inactivity timeout of the server. A standards compliant server must have an inactivity timeout of at least 30 minutes. But it may happen that some IMAP servers don't respect that, or some intermediary network device has a shorter timeout. By setting this option the above problem can be worked around. This variable takes a Vt number as a value. Default is ``29'' minutes.

limit

Some servers have problems handling very long requests, but some of the requests that need to be sent can become quite long, because they apply an action for many messages at once. When this option is set, the client will try to break up these requests into smaller requests, that each operates on fewer messages at a time. A good value for this would be ``50,'' This variable takes a Vt number as a value. Default is ``0 . ''

namespace

When enabled, the program gets the namespace of the user's personal mailboxes, and applies automatically the prefix and hierarchy delimiter to any mailboxes residing on the mail server; the user must use the `/' character as the delimiter and ``(ie. nothing) as the prefix, regardless of the folder'' format of the mail server. This must be disabled, if the user wants to manually specify mailbox names (eg. because they are not part of the user's personal namespace mailboxes). This variable takes Vt boolean as a value. Default is ``true''

recover

With this option it is possible to control the recovery functionality, which restores a session (the connection to the server and the IMAP state at the time), after some unexpected event takes place. Currently there are two types of events that can end abnormally a session, and finally cause the program to terminate: network errors, and the IMAP BYE response which a server can send anytime. When this option is set to ``all'' the recovery function is triggered by both types of events, when set to ``errors'' only in the case of network errors, and when set to ``none'' the mechanism is completely disabled. Default is ``all''

reenter

When this option is enabled and the connection is recovered after some unexpected event while in IDLE mode (see also the recover option), the client will re-enter IDLE mode. But when this option is disabled, and after the connection is recovered, the client will not re-enter IDLE mode, and instead will continue to execute the next line in the configuration file, ie. the one after Fn enter_idle . Default is ``true''

starttls

When this option is enabled and the server supports the IMAP STARTTLS extension, a TLS connection will be negotiated with the mail server in the beginning of the session. This variable takes a Vt boolean as value. Default is ``true''

subscribe

By enabling this option new mailboxes that were automatically created, get also subscribed; they are set active in order for IMAP clients to recognize them. This variable takes a Vt boolean as a value. Default is ``false''

timeout

The time in seconds for the program to wait for a mail server's response. If set to 0, the client will block indefinitely. This variable takes a Vt number as a value. Default is ``60'' seconds.

wakeonany

By enabling this option the IDLE command will return on any event that is received from the server, and not just on the ``RECENT'' and ``EXISTS'' events, that normally indicate the arrival of a new message. Examples of other events are ``FETCH'' which indicates that the details of a message (eg. its flags) have been modified, or ``EXPUNGE'' which indicates that a message has been deleted. This variable takes a Vt boolean as a value. Default is ``false''

ACCOUNTS

Accounts are initialized using the Fn IMAP function, and the details of the connection are defined using an account Vt table :

myaccount = IMAP {
    server = 'imap.mail.server',
    username = 'me',
    password = 'secret',
    ssl = 'ssl23'
}

An account Vt table must have the following elements:

server

The hostname of the IMAP server to connect to. It takes a Vt string as a value.

username

User's name. It takes a Vt string as a value.

An account Vt table can also have the following optional elements:

password

User's secret keyword. If a password wasn't supplied the user will be asked to enter one interactively the first time it will be needed (unless Vt oauth2 has been set). It takes a Vt string as a value.

oauth2

The OAuth2 string to use to authenticate if the server supports the XOAUTH2 authentication mechanism. If the server does not support it and a Vt password has been also set, authentication will be attempted using the Vt password . It takes a Vt string as a value.

Note that this requires that an OAuth client ID and client secret have been obtained, an OAuth2 token has been generated and authorized, a new access token has been generated using the refresh token if the last access token has expired, and an OAuth2 string has been generated from the access token. The aforementioned OAuth2 string is a Base64 encoded string that should be set here. For more information see https://developers.google.com/gmail/xoauth2_protocol

port

The port to connect to. It takes a Vt number as a value. Default is ``143'' for imap and ``993'' for imaps.

ssl

Forces an imaps connection and specifies the SSL/TLS protocol/version to be used. It takes a Vt string as a value, specifically one of: ``ssl3'' ``ssl23'' ``tls1'' ``tls1.1'' ``tls1.2''

LISTING

The following methods can be used on an account to list mailboxes in a folder of an account:

Fn list_all folder

Lists all the available mailboxes in the Fa folder (Vt string ) and returns a Vt table that contains Vt strings , the available mailboxes, and a Vt table that contains Vt strings , the available folders.

Fn list_subscribed folder

Lists all the subscribed mailboxes in the Fa folder (Vt string ) and returns a Vt table that contains Vt strings , the subscribed mailboxes, and a Vt table that contains Vt strings , the subscribed folders.

The following methods can be used on an account to list mailboxes, using wildcards, in a folder of an account. The `*' wildcard, matches any character and the `%' matches any character except the folder delimiter, ie. non-recursively:

Fn list_all folder mailbox

Lists all the available mailboxes in the Fa folder (Vt string ) with the name Fa mailbox (Vt string , ) and returns a Vt table that contains Vt strings , the available mailboxes, and a Vt table that contains Vt strings , the available folders. Wildcards may only be used in the Fa mailbox argument.

Fn list_subscribed folder mailbox

Lists all the subscribed mailboxes in the Fa folder (Vt string ) with the name Fa mailbox (Vt string ) and returns a Vt table that contains Vt strings , the subscribed mailboxes, and a Vt table that contains Vt strings , the subscribed folders. Wildcards may only be used in the Fa mailbox argument.

Examples:

mailboxes, folders = myaccount:list_subscribed('myfolder')
mailboxes, folders = myaccount:list_all('myfolder/mysubfolder', '*')

MANIPULATING

The following methods can be used to manipulate mailboxes in an account:

Fn create_mailbox name

Creates the Fa name (Vt string ) mailbox.

Fn delete_mailbox name

Deletes the Fa name (Vt string ) mailbox.

Fn rename_mailbox oldname newname

Renames the Fa oldname (Vt string ) mailbox to Fa newname (Vt string )

Fn subscribe_mailbox name

Subscribes the Fa name (Vt string ) mailbox.

Fn unsubscribe_mailbox name

Unsubscribes the Fa name (Vt string ) mailbox.

Examples:

myaccount:create_mailbox('mymailbox')
myaccount:subscribe_mailbox('mymailbox')
myaccount:unsubscribe_mailbox('myfolder/mymailbox')
myaccount:delete_mailbox('myfolder/mymailbox')

MAILBOXES

After an IMAP account has been initialized, mailboxes residing in that account can be accessed simply as elements of the account Vt table :

myaccount.mymailbox

If mailbox names don't only include letters, digits and underscores, or begin with a digit, an alternative form must be used:

myaccount['mymailbox']

A mailbox inside a folder can be only accessed by using the alternative form:

myaccount['myfolder/mymailbox']

The methods that are available for an account (eg. Fn list_all , Fn create_mailbox , etc.) , are considered keywords and must not be used as mailbox names, and the same also applies for any string starting with an underscore, as they are considered reserved.

CHECKING

The following methods can be used to check the status of a mailbox:

Fn check_status

The Fn check_status method gets the current status of a mailbox, and returns four values of Vt number type: the total number of messages, the number of recent messages, the number of unseen messages in the mailbox, and the next UID to be assigned to a new message in the mailbox.

Fn enter_idle

The Fn enter_idle method implements the IMAP IDLE (RFC 2177) extension. By using this extension it's not necessary to poll the server for changes to the selected mailbox (ie. using the Fn check_status method), but instead the server sends an update when there is a change in the mailbox (eg. in case of new mail). When the Fn enter_idle method has been called no more commands in the configuration file are executed until an update is received, at which point the Fn enter_idle method returns. For the Fn enter_idle to work, the IDLE extension has to be supported by the IMAP server.

The Fn enter_idle method returns a value of type Vt boolean : ``true'' if the IDLE extension is supported and there was a update in the mailbox, and ``false'' if the IDLE extension is not supported, in which case the method returns immediately. When the aforementioned return value was ``true'' an additional second value of type Vt string is also returned, indicating the event received from the server, which is useful when the wakeonany option has been enabled.

Examples:

exist, unread, unseen, uidnext = myaccount.mymailbox:check_status()
update = myaccount.mymailbox:enter_idle()
update, event = myaccount.mymailbox:enter_idle()

SEARCHING

The searching methods in this subsection can be applied to any mailbox. They return a special form of Vt table , that contains the messages that match the searching method. This Vt table can be combined with other Vt tables using logic theory. There are three available operations, that implement logical ``or'' logical ``and'' and logical ``not''

The logical ``or'' is implemented using the `+' operator:

results = myaccount.mymailbox:is_unseen() +
          myaccount.mymailbox:is_larger(100000)

The logical ``and'' is implemented using the `*' operator:

results = myaccount.mymailbox:is_unseen() *
          myaccount.mymailbox:is_larger(100000)

The logical ``not'' is implemented using the `-' operator:

results = myaccount.mymailbox:is_unseen() -
          myaccount.mymailbox:is_larger(100000)

The three logical operators can be combined in the same expression. The logical ``and'' has higher precedence than the logical ``or'' and the logical ``not'' with the latter two having the same precedence, and parentheses may be used to change this behaviour:

results = myaccount.mymailbox:is_unseen() +
          myaccount.mymailbox:is_larger(100000) *
          myaccount.mymailbox:contain_subject('test')
results = ( myaccount.mymailbox:is_unseen() +
            myaccount.mymailbox:is_larger(100000) ) *
            myaccount.mymailbox:contain_subject('test')

The returned Vt tables of the searching methods can also be stored in variables and then further processed:

unseen = myaccount.myaccount:is_unseen()
larger = myaccount.mymailbox:is_larger(100000)
subject = myaccount.mymailbox:contain_subject('test')
results = unseen + larger * subject

A composite filter that includes one or more simple rules can be defined:

myfilter = function ()
               return myaccount.mymailbox:is_unseen() +
                      myaccount.mymailbox:is_larger(100000) *
                      myaccount.mymailbox:contain_subject('test')
           end
results = myfilter()

Composite filters can may be more dynamic by adding arguments:

myfilter = function (mailbox, size, subject)
               return mailbox:is_unseen() +
                      mailbox:is_larger(size) *
                      mailbox:contain_subject(subject)
           end
results = myfilter(myaccount.mailbox, 100000, 'test')

It is also possible to combine the searching methods in different mailboxes, either at the same or different accounts, for example when the same actions will be executed on messages residing in different mailboxes or accounts.

results = myaccount.mymailbox:is_unseen() +
          myaccount.myothermailbox:is_larger(100000) +
          myotheraccount.myothermailbox:contain_subject('test')

The following method can be used to get all messages in a mailbox:

Fn select_all

All messages.

The following methods can be used to search for messages that are in a specific state:

Fn is_answered

Messages that have been answered.

Fn is_deleted

Messages that are marked for later removal.

Fn is_draft

Messages that have not completed composition.

Fn is_flagged

Messages that are flagged for urgent/special attention.

Fn is_new

Messages that are recently arrived (this session is the first to have been notified about these messages) and have not been read.

Fn is_old

Messages that are not recently arrived (this session is not the first to have been notified about these messages) and have not been read.

Fn is_recent

Messages that are recently arrived (this session is the first to have been notified about these messages).

Fn is_seen

Messages that have been read.

Fn is_unanswered

Messages that have not been answered.

Fn is_undeleted

Messages that are not marked for later removal.

Fn is_undraft

Messages that have completed composition.

Fn is_unflagged

Messages that are not flagged for urgent/special attention.

Fn is_unseen

Messages that have not been read.

The following method can be used to search for messages that have a specific keyword flag set:

Fn has_keyword flag

Messages with the specified keyword flag (Vt string ) set.

Fn has_unkeyword flag

Messages without the specified keyword flag (Vt string ) set.

The following methods can be used to search for messages based on their size:

Fn is_larger size

Messages that are larger than the size (Vt number ) in octets (bytes).

Fn is_smaller size

Messages that are smaller than the size (Vt number ) in octets (bytes).

The following methods can be used to search for messages based on their age:

Fn is_newer age

Messages that are newer than the Fa age (Vt number ) in days.

Fn is_older age

Messages that are older than the Fa age (Vt number ) in days.

The following methods can be used to search for messages based on their arrival or sent date, in the ``day-month-year'' form, where day is the day of the month as a decimal number (01-31), month is the abbreviated month ( ``Jan'' ``Feb'' ``Mar'' ``Apr'' ``May'' ``Jun'' ``Jul'' ``Aug'' ``Sep'' ``Oct'' ``Nov'' ``Dec'' and year is the year as decimal number including the century (eg. 2007):

Fn arrived_before date

messages that have arrived earlier than the Fa date (Vt string ) where Fa date is in the ``day-month-year'' form.

Fn arrived_on date

Messages that have arrived within the Fa date (Vt string ) where Fa date is in the ``day-month-year'' form.

Fn arrived_since date

Messages that have arrived within or later than the Fa date (Vt string ) where Fa date is in the ``day-month-year'' form.

Fn sent_before date

Messages that have been sent earlier than the Fa date (Vt string ) where Fa date is in the ``day-month-year'' form.

Fn sent_on date

Messages that have been sent within the Fa date (Vt string ) where Fa date is in the ``day-month-year'' form.

Fn sent_since date

Messages that have been sent within or later than the Fa date (Vt string ) where Fa date is in the ``day-month-year'' form.

The following methods can be used to do case-insensitive searching, for messages that contain a specific word or phrase:

Fn contain_bcc string

Messages that contain the Fa string (Vt string ) in the ``Bcc'' header field.

Fn contain_cc string

Messages that contain the Fa string (Vt string ) in the ``Cc header field. ''

Fn contain_from string

Messages that contain the Fa string (Vt string ) in the ``From'' header field.

Fn contain_subject string

Messages that contain the Fa string (Vt string ) in the ``Subject'' header field.

Fn contain_to string

Messages that contain the Fa string (Vt string ) in the ``To header field. ''

Fn contain_field field string

Messages that contain the Fa string (Vt string ) in the Fa field (Vt string ) header field.

Fn contain_body string

Messages that contain the Fa string (Vt string ) in the message body.

Fn contain_message string

Messages that contain the Fa string (Vt string ) in the message.

The following methods can be used to do case-sensitive searching, for messages that match a specific regular expression pattern. The matching mechanism that is used to support this is based on the Perl-compatible regular expressions (PCRE), and more information about the patterns and modifiers that can be used, is available in the relevant documentation at http://pcre.org/original/doc/html/

This way of searching is not supported by the IMAP protocol, and this means that what actually happens under the hood, is that the relevant parts of all the messages are downloaded and matched locally. It is therefore recommended to use these methods with meta-searching (see following section), in order to narrow down the set of messages that should be searched, and thus minimize what will be downloaded.

Note that due to Lua using backslash `\' as an escape character for its strings, one has to double backslashes in order to insert a single backslash inside a regular expression pattern:

Fn match_bcc pattern

Messages that match the regular expression Fa pattern (Vt string ) in the ``Bcc'' header field.

Fn match_cc pattern

Messages that match the regular expression Fa pattern (Vt string ) in the ``Cc header field. ''

Fn match_from pattern

Messages that match the regular expression Fa pattern (Vt string ) in the ``From'' header field.

Fn match_subject pattern

Messages that match the regular expression Fa pattern (Vt string ) in the ``Subject'' header field.

Fn match_to pattern

Messages that match the regular expression Fa pattern (Vt string ) in the ``To header field. ''

Fn match_field field pattern

Messages that match the regular expression Fa pattern (Vt string ) in the Fa field (Vt string ) header field.

Fn match_header pattern

Messages that match the regular expression Fa pattern (Vt string ) in the message header.

Fn match_body pattern

Messages that match the regular expression Fa pattern (Vt string ) in the message body.

Fn match_message pattern

Messages that match the regular expression Fa pattern (Vt string ) in the message.

The following method can be used to search for messages using user queries based on the IMAP specification (RFC 3501 Section 6.4.4):

Fn send_query criteria

Searches messages by sending an IMAP search query as described in the search Fa criteria (Vt string )

Examples:

results = myaccount.mymailbox:select_all()
results = myaccount.mymailbox:is_new()
results = myaccount.mymailbox:is_recent()
results = myaccount.mymailbox:is_larger(100000)
results = myaccount.mymailbox:is_older(10)
results = myaccount.mymailbox:has_keyword('MyFlag')
results = myaccount.mymailbox:arrived_before('01-Jan-2007')
results = myaccount.mymailbox:sent_since('01-Jan-2007')
results = myaccount.mymailbox:contain_subject('test')
results = myaccount.mymailbox:contain_field('Sender', 'user@host')
results = myaccount.mymailbox:contain_body('hello world')
results = myaccount.mymailbox:match_from('.*(user1|user2)@host')
results = myaccount.mymailbox:send_query('ALL')
results = myaccount['mymailbox']:is_new()
results = myaccount['myfolder/mymailbox']:is_recent()

RESULTS

After one of more searching methods have been applied to one or more mailboxes, the result contains all the necessary information, such as which messages matched in which mailboxes. Using this result these messages can be either searched further or processed in various way.

META-SEARCHING

The results of the searching methods can be searched further on in the same way as searching is done in mailboxes. The difference is that instead of doing the search in the whole mailbox, ie. in all the messages, it is instead done only to those messages that were returned in a previous search.

Examples:

results:match_message('^[Hh]ello world!?$')
myaccount.mymailbox:is_new():match_body('^[Ww]orld, hello!?$')

PROCESSING

The processing methods are applied to the results that searching returned.

The following method can be used to delete messages in a mailbox:

Fn delete_messages

Deletes the messages that matched.

The following methods can be used to copy and move messages in a mailbox at the same or different accounts. If the destination mailbox is in a different account than the source mailbox, then the messages are downloaded and then uploaded to the destination:

Fn copy_messages destination

Copies the messages to the Fa destination , which is a mailbox at an account.

Fn move_messages destination

Moves the messages to the Fa destination , which is a mailbox at an account.

The following methods can be used to mark messages in a mailbox:

Fn mark_answered

Marks the messages as answered.

Fn mark_deleted

Marks the messages for later removal.

Fn mark_draft

Marks the messages as draft.

Fn mark_flagged

Marks the messages for urgent/special attention.

Fn mark_seen

Marks the messages as read.

Fn unmark_answered

Unmarks the messages that have been marked as answered.

Fn unmark_deleted

Unmarks the messages that have been marked for later removal.

Fn unmark_draft

Unmarks the messages that have been marked as draft.

Fn unmark_flagged

Unmarks the messages that have been marked for urgent/special attention.

Fn unmark_seen

Unmarks the messages that have been marked as read.

The following methods can be used to flag messages in a mailbox. The standard system flags are ``\Answered'' ``\Deleted'' ``\Draft'' ``\Flagged'' ``\Seen'' while if the server supports it, new user keywords may be defined:

Fn add_flags flags

Adds the Fa flags Po Vt table that contains Vt strings Pc to the messages.

Fn remove_flags flags

Removes the Fa flags Po Vt table that contains Vt strings Pc from the messages.

Fn replace_flags flags

Replaces the Fa flags Po Vt table that contains Vt strings Pc of the messages.

Examples:

results:delete_messages()
results:copy_messages(myaccount.myothermailbox)
results:move_messages(myotheraccount.mymailbox)
results:mark_seen()
results:unmark_flagged()
results:add_flags({ 'MyFlag', '\\Seen' })
results:remove_flags({ '\\Seen' })
results:move_messages(myotheraccount['myfolder/mymailbox'])

MESSAGES

The messages that are residing in any mailbox can be also accessed, as a whole or in parts. Messages can be accessed using their unique identifier (UID):

myaccount.mymailbox[22]

The UIDs of messages the user is interested in, are gained from the results of searching:

results = account.INBOX:is_unseen()
for _, message in ipairs(results) do
    mailbox, uid = table.unpack(message)
    header = mailbox[uid]:fetch_header()
end

FETCHING

The following methods can be used to fetch parts of messages. The methods return a Vt string . The downloaded message parts are cached locally, so they can be reused inside the same program session:

Fn fetch_message

Fetches the header and body of the message.

Fn fetch_header

Fetches the header of the message.

Fn fetch_body

Fetches the body of the messages.

Fn fetch_field field

Fetches the specified header Fa field (Vt string ) of the message.

Fn fetch_part part

Fetches the specified Fa part (Vt string ) of the message.

The following methods can be used to fetch details about the state of a message:

Fn fetch_flags

Fetches the flags of the message. Returns a Vt table of Vt strings .

Fn fetch_date

Fetches the internal date of the message. Returns a Vt string .

Fn fetch_size

Fetches the size of the message. Returns a Vt number .

Fn fetch_structure

Fetches the body structure of the message. Returns a Vt table that has as keys the parts of the message, and as values a Vt table that has one mandatory element, the type (Vt string ) of the part, and two optional elements, the size (Vt number ) and name (Vt string ) of the part.

APPENDING

The following methods can be used to append a message to a mailbox:

Fn append_message message

Appends the Fa message (Vt string ) to the mailbox.

Fn append_message message flags date

Appends the Fa message (Vt string ) to the mailbox, setting the specified Fa flags Po Vt table of Vt strings Pc , as returned by Fn fetch_flags , and Fa date (Vt string ) as returned by Fn fetch_date .

Examples:

myaccount.mymailbox[2]:fetch_message()
myaccount.mymailbox[3]:fetch_field('subject')
myaccount.mymailbox[5]:fetch_part('1.1')
myaccount['mymailbox'][7]:fetch_message()
myaccount['myfolder/mymailbox'][11]:fetch_message()
myaccount.mymailbox:append_message(message)

FUNCTIONS

The following auxiliary functions are also available for convenience:

Fn form_date days

Forms a date in ``day-month-year'' format that the system had before the number of Fa days (Vt number ) and returns it as a Vt string .

Fn get_password prompt

Displays the specified Fa prompt (Vt string ) and reads a password, while character echoing is turned off. Returns that password as a Vt string .

Fn become_daemon interval commands

Detaches the program from the controlling terminal and runs it in the background as system daemon. The program will then repeatedly poll at the specified Fa interval (Vt number ) in seconds. Each time the program wakes up, the Fa commands (Vt function ) are executed.

Fn become_daemon interval commands nochdir noclose

Detaches the program from the controlling terminal and runs it in the background as system daemon. The program will then repeatedly poll at the specified Fa interval (Vt number ) in seconds. Each time the program wakes up, the Fa commands (Vt function ) are executed.

If Fa nochdir (Vt boolean ) is ``true'' the current working directory is not changed to the root directory (/ ) If Fa noclose (Vt boolean ) is ``true'' the standard input, standard output and standard error are not redirected to /dev/null

Fn pipe_to command data

Executes the system's Fa command (Vt string ) and sends the Fa data (Vt string ) to the standard input channel of the subprocess. Returns a Vt number , the exit status of the child process.

Fn pipe_from command

Executes the system's Fa command (Vt string ) and retrieves the data from the standard output channel of the subprocess. Returns a Vt number , the exit status of the child process, and a Vt string , the output of the child process.

Fn regex_search pattern string

Implements Perl-compatible regular expressions (PCRE). The Fa pattern (Vt string ) is a PCRE pattern. The Vt string (Vt string ) is the subject string in which the pattern is matched against. Returns at least a Vt boolean , that denotes if the match was successful, and any captures which are of Vt string type. Note that due to Lua using backslash `\' as an escape character for its strings, one has to double backslashes in order to insert a single backslash inside a regular expression pattern. For more information on PCRE see http://pcre.org/original/doc/html/

Examples:

date = form_date(14)
password = get_password('Enter password: ')
become_daemon(600, myfunction)
status = pipe_to('mycommandline', 'mydata')
status, data = pipe_from('mycommandline')
success, capture = regex_search('^(?i)pcre: (\\w)$', 'mystring')

EXAMPLES

See samples/config.lua and samples/extend.lua in the source code distribution.