Net::IMAP

An IMAP client connects to a server, and then
authenticates itself using either authenticate() or login(). Having authenticated itself,
there is a range of commands available to it. Most work with mailboxes,
which may be arranged in an hierarchical namespace, and each of which
contains zero or more messages. How this is implemented on the server is
implementation-dependent; on a UNIX server, it will frequently be
implemented as a files in mailbox format within a hierarchy of directories.

To work on the messages within a mailbox, the client must first select that
mailbox, using either select() or
(for read-only access) examine().
Once the client has successfully selected a mailbox, they enter
selected state, and that mailbox becomes the current
mailbox, on which mail-item related commands implicitly operate.

Messages have two sorts of identifiers: message sequence numbers, and UIDs.

Message sequence numbers number messages within a mail box from 1 up to the
number of items in the mail box. If new message arrives during a session,
it receives a sequence number equal to the new size of the mail box. If
messages are expunged from the mailbox, remaining messages have their
sequence numbers “shuffled down” to fill the gaps.

UIDs, on the other hand, are permanently guaranteed not to identify another
message within the same mailbox, even if the existing message is deleted.
UIDs are required to be assigned in ascending (but not necessarily
sequential) order within a mailbox; this means that if a non-IMAP client
rearranges the order of mailitems within a mailbox, the UIDs have to be
reassigned. An IMAP client cannot thus rearrange
message orders.

An IMAP server can send three different types of
responses to indicate failure:

NO

the attempted command could not be successfully completed. For instance,
the username/password used for logging in are incorrect; the selected
mailbox does not exists; etc.

BAD

the request from the client does not follow the server’s understanding of
the IMAP protocol. This includes attempting
commands from the wrong client state; for instance, attempting to perform a
SEARCH command without having SELECTed a current mailbox. It can also
signal an internal server failure (such as a disk crash) has occurred.

BYE

the server is saying goodbye. This can be part of a normal logout
sequence, and can be used as part of a login sequence to indicate that the
server is (for some reason) unwilling to accept our connection. As a
response to any other command, it indicates either that the server is
shutting down, or that the server is timing out the client connection due
to inactivity.

Because the IMAP class uses Sockets for
communication, its methods are also susceptible to the various errors that
can occur when working with sockets. These are generally represented as
Errno errors. For instance, any method that involves sending a request to
the server and/or receiving a response from it could raise an Errno::EPIPE
error if the network connection unexpectedly goes down. See the socket(7),
ip(7), tcp(7), socket(2), connect(2), and associated man pages.

The command continuation request response is indicated by a “+” token
instead of a tag. This form of response indicates that the server is ready
to accept the continuation of a command from the client. The remainder of
this response is a line of text.

Net::IMAP::MailboxQuota represents contents of GETQUOTA response. This
object can also be a response to GETQUOTAROOT. In the syntax specification
below, the delimiter used with the “#” construct is a single space (SPACE).

if options is true, then an attempt will be made to use
SSL (now TLS) to connect to the server. For this to work OpenSSL [OSSL]
and the Ruby OpenSSL [RSSL] extensions need to be installed. if options is a hash, it’s passed to
OpenSSL::SSL::SSLContext#set_params as parameters.

The most common errors are:

Errno::ECONNREFUSED

connection refused by host or an intervening firewall.

Errno::ETIMEDOUT

connection timed out (possibly due to packets being dropped by an
intervening firewall).

Public Instance Methods

add_response_handler(handler = Proc.new)click to toggle source

Adds a response handler. For example, to detect when the server sends us a
new EXISTS response (which normally indicates new messages being added to
the mail box), you could add the following handler after selecting the
mailbox.

Sends a APPEND command to append the message to the end of the
mailbox. The optional flags argument is an array
of flags to initially passing to the new message. The optional
date_time argument specifies the creation time to assign to
the new message; it defaults to the current time. For example:

Sends an AUTHENTICATE command to authenticate the client. The
auth_type parameter is a string that represents the
authentication mechanism to be used. Currently Net::IMAP supports authentication mechanisms:

LOGIN:: login using cleartext user and password.
CRAM-MD5:: login with cleartext user and encrypted password
(see [RFC-2195] for a full description). This
mechanism requires that the server have the user's
password stored in clear-text password.

For both these mechanisms, there should be two args: username
and (cleartext) password. A server may not support one or other of these
mechanisms; check capability()
for a capability of the form “AUTH=LOGIN” or “AUTH=CRAM-MD5”.

Authentication is done using the appropriate authenticator object: see
@@authenticators for more information on plugging in your own
authenticator.

Sends a CAPABILITY command, and returns an array of capabilities that the
server supports. Each capability is a string. See [IMAP] for a list of
possible capabilities.

Note that the Net::IMAP class does not modify its
behaviour according to the capabilities of the server; it is up to the user
of the class to ensure that a certain capability is supported by a server
before using it.

Sends a CHECK command to request a checkpoint of the currently selected
mailbox. This performs implementation-specific housekeeping, for instance,
reconciling the mailbox’s in-memory and on-disk state.

# File net/imap.rb, line 659defchecksend_command("CHECK")
end

close()click to toggle source

Sends a CLOSE command to close the currently selected mailbox. The CLOSE
command permanently removes from the mailbox all messages that have the
Deleted flag set.

# File net/imap.rb, line 666defclosesend_command("CLOSE")
end

copy(set, mailbox)click to toggle source

Sends a COPY command to copy the specified message(s) to the end of the
specified destination mailbox. The set parameter
is a number or an array of numbers or a Range object. The number is a
message sequence number.

# File net/imap.rb, line 299defdisconnectbeginbegin# try to call SSL::SSLSocket#io.@sock.io.shutdownrescueNoMethodError# @sock is not an SSL::SSLSocket.@sock.shutdownendrescueErrno::ENOTCONN# ignore `Errno::ENOTCONN: Socket is not connected' on some platforms.rescueException =>e@receiver_thread.raise(e)
end@receiver_thread.joinsynchronizedounless@sock.closed?@sock.closeendendraiseeifeend

disconnected?()click to toggle source

Returns true if disconnected from the server.

# File net/imap.rb, line 323defdisconnected?return@sock.closed?end

examine(mailbox)click to toggle source

Sends a EXAMINE command to select a mailbox so that messages
in the mailbox can be accessed. Behaves the same as select(), except that the selected
mailbox is identified as read-only.

Sends a FETCH command to retrieve data associated with a message in the
mailbox. The set parameter is a number or an array of numbers
or a Range object. The number is a message sequence number.
attr is a list of attributes to fetch; see the documentation
for Net::IMAP::FetchData for a list of valid attributes. The return value
is an array of Net::IMAP::FetchData. For example:

Sends the GETQUOTA command along with specified mailbox. If
this mailbox exists, then an array containing a Net::IMAP::MailboxQuota
object is returned. This command generally is only available to server
admin.

Sends the GETQUOTAROOT command along with specified mailbox.
This command is generally available to both admin and user. If mailbox
exists, returns an array containing objects of Net::IMAP::MailboxQuotaRoot
and Net::IMAP::MailboxQuota.

Sends a LIST command, and returns a subset of names from the complete set
of all names available to the client. refname provides a
context (for instance, a base directory in a directory-based mailbox
hierarchy). mailbox specifies a mailbox or (via wildcards)
mailboxes under that context. Two wildcards may be used in
mailbox: ‘*’, which matches all characters
including the hierarchy delimiter (for instance, ‘/’ on a
UNIX-hosted directory-based mailbox hierarchy); and ‘%’, which matches all
characters except the hierarchy delimiter.

If refname is empty, mailbox is used directly to
determine which mailboxes to match. If mailbox is empty, the
root name of refname and the hierarchy delimiter are returned.

Sends a LOGIN command to identify the client and carries the plaintext
password authenticating this user. Note that,
unlike calling authenticate()
with an auth_type of “LOGIN”, login() does not use
the login authenticator.

Sends a LOGOUT command to inform the server that the client is done with
the connection.

# File net/imap.rb, line 351deflogoutsend_command("LOGOUT")
end

lsub(refname, mailbox)click to toggle source

Sends a LSUB command, and returns a subset of names from the set of names
that the user has declared as being “active” or “subscribed”.
refname and mailbox are interpreted as for list(). The return value is an array of
Net::IMAP::MailboxList.

A Net::IMAP::NoResponseError is
raised if a mailbox with the name mailbox cannot be renamed to
newname for whatever reason; for instance, because
mailbox does not exist, or because there is already a mailbox
with the name newname.

Sends a SEARCH command to search the mailbox for messages that match the
given searching criteria, and returns message sequence numbers.
keys can either be a string holding the entire search string,
or a single-dimension array of search keywords and arguments. The
following are some common search criteria; see [IMAP] section 6.4.4 for a
full list.

<message set>

a set of message sequence numbers. ‘,’ indicates an interval, ‘:’
indicates a range. For instance, ‘2,10:12,15’ means “2,10,11,12,15”.

BEFORE <date>

messages with an internal date strictly before <date>. The date
argument has a format similar to 8-Aug-2002.

BODY <string>

messages that contain <string> within their body.

CC <string>

messages containing <string> in their CC field.

FROM <string>

messages that contain <string> in their FROM field.

NEW

messages with the Recent, but not the Seen, flag set.

NOT <search-key>

negate the following search key.

OR <search-key> <search-key>

“or” two search keys together.

ON <date>

messages with an internal date exactly equal to <date>, which has a
format similar to 8-Aug-2002.

Sends a SELECT command to select a mailbox so that messages in
the mailbox can be accessed.

After you have selected a mailbox, you may retrieve the number of items in
that mailbox from @responses[-1], and the number of
recent messages from @responses[-1]. Note that these
values can change if new messages arrive during a session; see add_response_handler()
for a way of detecting this event.

Sends the SETACL command along with mailbox, user
and the rights that user is to have on that mailbox. If
rights is nil, then that user will be stripped of any rights
to that mailbox. The IMAP ACL commands are
described in [RFC-2086].

Sends a SETQUOTA command along with the specified mailbox and
quota. If quota is nil, then quota will be unset
for that mailbox. Typically one needs to be logged in as server admin for
this to work. The IMAP quota commands are
described in [RFC-2087].

Sends a STORE command to alter data associated with messages in the
mailbox, in particular their flags. The set parameter is a
number or an array of numbers or a Range object. Each number is a message
sequence number. attr is the name of a data item to store:
‘FLAGS’ means to replace the message’s flag list with the provided one;
‘+FLAGS’ means to add the provided flags; and ‘-FLAGS’ means to remove
them. flags is a list of flags.