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 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 mailbox from 1 up to the
number of items in the mailbox. If a new message arrives during a session,
it receives a sequence number equal to the new size of the mailbox. 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 thus cannot 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 exist; 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 your 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.

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 a new
EXISTS response (which normally indicates new messages being added to the
mailbox), 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 initially passed 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 the 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 of these mechanisms, there should be two args:
username and (cleartext) password. A server may not support one or the
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 712defchecksend_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 719defclosesend_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, an array of numbers, or a Range object. The number is a
message sequence number.

# File net/imap.rb, line 321defdisconnectreturnifdisconnected?beginbegin# 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.joinsynchronizedo@sock.closeendraiseeifeend

disconnected?()click to toggle source

Returns true if disconnected from the server.

# File net/imap.rb, line 344defdisconnected?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 a range between two numbers,
or an array of those. The number is a message sequence number, where -1
represents a '*' for use in range notation like 100..-1 being
interpreted as '100:*'. Beware that the exclude_end?
property of a Range object is ignored, and the contents of a range are
independent of the order of the range endpoints as per the protocol
specification, so 1…5, 5..1 and 5…1 are all equivalent to 1..5.

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 or nil (instead of an
empty array) if there is no matching message.

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 is generally only available to server admin.

Sends the GETQUOTAROOT command along with the specified
mailbox. This command is generally available to both admin and
user. If this mailbox exists, it returns an array containing objects of
type 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 372deflogoutsend_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.

Sends a MOVE command to move the specified message(s) to the end of the
specified destination mailbox. The set parameter
is a number, an array of numbers, or a Range object. The number is a
message sequence number. The IMAP MOVE extension is
described in [RFC-6851].

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 a
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, 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' will replace the message's flag list with the provided
one, '+FLAGS' will add the provided flags, and '-FLAGS'
will remove them. flags is a list of flags.

Sends a XLIST 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.

The XLIST command is like the LIST command except that the flags returned
refer to the function of the folder/mailbox, e.g. :Sent