class Net::IMAP
Net::IMAP implements Internet Message Access Protocol (IMAP) client functionality. The protocol is described in [IMAP].
IMAP Overview¶ ↑
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.
Examples of Usage¶ ↑
List sender and subject of all recent messages in the default mailbox¶ ↑
imap = Net::IMAP.new('mail.example.com') imap.authenticate('LOGIN', 'joe_user', 'joes_password') imap.examine('INBOX') imap.search(["RECENT"]).each do |message_id| envelope = imap.fetch(message_id, "ENVELOPE")[0].attr["ENVELOPE"] puts "#{envelope.from[0].name}: \t#{envelope.subject}" end
Move all messages from April 2003 from “Mail/sent-mail” to “Mail/sent-apr03”¶ ↑
imap = Net::IMAP.new('mail.example.com') imap.authenticate('LOGIN', 'joe_user', 'joes_password') imap.select('Mail/sent-mail') if not imap.list('Mail/', 'sent-apr03') imap.create('Mail/sent-apr03') end imap.search(["BEFORE", "30-Apr-2003", "SINCE", "1-Apr-2003"]).each do |message_id| imap.copy(message_id, "Mail/sent-apr03") imap.store(message_id, "+FLAGS", [:Deleted]) end imap.expunge
Thread Safety¶ ↑
Net::IMAP supports concurrent threads. For example,
imap = Net::IMAP.new("imap.foo.net", "imap2") imap.authenticate("cram-md5", "bar", "password") imap.select("inbox") fetch_thread = Thread.start { imap.fetch(1..-1, "UID") } search_result = imap.search(["BODY", "hello"]) fetch_result = fetch_thread.value imap.disconnect
This script invokes the FETCH command and the SEARCH command concurrently.
Errors¶ ↑
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.
These three error response are represented by the errors Net::IMAP::NoResponseError, Net::IMAP::BadResponseError, and Net::IMAP::ByeResponseError, all of which are subclasses of Net::IMAP::ResponseError. Essentially, all methods that involve sending a request to the server can generate one of these errors. Only the most pertinent instances have been documented below.
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.
Finally, a Net::IMAP::DataFormatError is thrown if low-level data is found to be in an incorrect format (for instance, when converting between UTF-8 and UTF-16), and Net::IMAP::ResponseParseError is thrown if a server response is non-parseable.
References¶ ↑
- [IMAP]
-
Crispin, “INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1”,
RFC 2060, December 1996. (Note: since obsoleted by RFC 3501)
-
- [LANGUAGE-TAGS]
-
Alvestrand, H., “Tags for the Identification of Languages”, RFC 1766, March 1995.
- [MD5]
-
Myers, J., and M. Rose, “The Content-MD5 Header Field”, RFC 1864, October 1995.
- [MIME-IMB]
-
Freed, N., and N. Borenstein, “MIME (Multipurpose Internet Mail Extensions) Part One: Format of Internet Message Bodies”, RFC 2045, November 1996.
- [RFC-822]
-
Crocker, D., “Standard for the Format of ARPA Internet Text Messages”, STD 11, RFC 822, University of Delaware, August 1982.
- [RFC-2087]
-
Myers, J., “IMAP4 QUOTA extension”, RFC 2087, January 1997.
- [RFC-2086]
-
Myers, J., “IMAP4 ACL extension”, RFC 2086, January 1997.
- [RFC-2195]
-
Klensin, J., Catoe, R., and Krumviede, P., “IMAP/POP AUTHorize Extension for Simple Challenge/Response”, RFC 2195, September 1997.
- [SORT-THREAD-EXT]
-
Crispin, M., “INTERNET MESSAGE ACCESS PROTOCOL - SORT and THREAD Extensions”, draft-ietf-imapext-sort, May 2003.
- [OSSL]
- [RSSL]
- [UTF7]
-
Goldsmith, D. and Davis, M., “UTF-7: A Mail-Safe Transformation Format of Unicode”, RFC 2152, May 1997.
Constants
- ANSWERED
Flag indicating a message has been answered
- Address
Net::IMAP::Address represents electronic mail addresses.
Fields:¶ ↑
- name
-
Returns the phrase from [RFC-822] mailbox.
- route
-
Returns the route from [RFC-822] route-addr.
- mailbox
-
nil indicates end of [RFC-822] group. If non-nil and host is nil, returns [RFC-822] group name. Otherwise, returns [RFC-822] local-part
- host
-
nil indicates [RFC-822] group syntax. Otherwise, returns [RFC-822] domain name.
- ContentDisposition
Net::IMAP::ContentDisposition represents Content-Disposition fields.
Fields:¶ ↑
- dsp_type
-
Returns the disposition type.
- param
-
Returns a hash that represents parameters of the Content-Disposition field.
- ContinuationRequest
Net::IMAP::ContinuationRequest represents command continuation requests.
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.
continue_req ::= "+" SPACE (resp_text / base64)
Fields:¶ ↑
- data
-
Returns the data (Net::IMAP::ResponseText).
- raw_data
-
Returns the raw data string.
- DATE_MONTH
- DELETED
Flag indicating a message has been marked for deletion. This will occur when the mailbox is closed or expunged.
- DRAFT
Flag indicating a message is only a draft or work-in-progress version.
- Envelope
Net::IMAP::Envelope represents envelope structures of messages.
Fields:¶ ↑
- date
-
Returns a string that represents the date.
- subject
-
Returns a string that represents the subject.
- from
-
Returns an array of Net::IMAP::Address that represents the from.
- sender
-
Returns an array of Net::IMAP::Address that represents the sender.
- reply_to
-
Returns an array of Net::IMAP::Address that represents the reply-to.
- to
-
Returns an array of Net::IMAP::Address that represents the to.
- cc
-
Returns an array of Net::IMAP::Address that represents the cc.
- bcc
-
Returns an array of Net::IMAP::Address that represents the bcc.
- in_reply_to
-
Returns a string that represents the in-reply-to.
- message_id
-
Returns a string that represents the message-id.
- FLAGGED
Flag indicating a message has been flagged for special or urgent attention
- FetchData
Net::IMAP::FetchData represents contents of the FETCH response.
Fields:¶ ↑
- seqno
-
Returns the message sequence number. (Note: not the unique identifier, even for the UID command response.)
- attr
-
Returns a hash. Each key is a data item name, and each value is its value.
The current data items are:
- BODY
-
A form of BODYSTRUCTURE without extension data.
- Net::IMAP::BodyTypeBasic, Net::IMAP::BodyTypeText, Net::IMAP::BodyTypeMessage, Net::IMAP::BodyTypeMultipart.
- ENVELOPE
-
A Net::IMAP::Envelope object that describes the envelope structure of a message.
- FLAGS
-
A array of flag symbols that are set for this message. flag symbols are capitalized by String#capitalize.
- INTERNALDATE
-
A string representing the internal date of the message.
- RFC822
-
Equivalent to BODY[].
- RFC822.HEADER
-
Equivalent to BODY.PEEK.
- RFC822.SIZE
-
A number expressing the [RFC-822] size of the message.
- RFC822.TEXT
-
Equivalent to BODY.
- UID
-
A number expressing the unique identifier of the message.
Flag indicating that a mailbox has been marked “interesting” by the server; this commonly indicates that the mailbox contains new messages.
Net::IMAP::MailboxACLItem represents response from GETACL.
acl_data ::= "ACL" SPACE mailbox *(SPACE identifier SPACE rights) identifier ::= astring rights ::= astring
Fields:¶ ↑
- user
-
Login name that has certain rights to the mailbox that was specified with the getacl command.
- rights
-
The access rights the indicated user has to the mailbox.
Net::IMAP::MailboxList represents contents of the LIST response.
mailbox_list ::= "(" #("\Marked" / "\Noinferiors" / "\Noselect" / "\Unmarked" / flag_extension) ")" SPACE (<"> QUOTED_CHAR <"> / nil) SPACE mailbox
Fields:¶ ↑
- attr
-
Returns the name attributes. Each name attribute is a symbol capitalized by String#capitalize, such as :Noselect (not :NoSelect).
- delim
-
Returns the hierarchy delimiter
- name
-
Returns the mailbox name.
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).
quota_list ::= "(" #quota_resource ")" quota_resource ::= atom SPACE number SPACE number quota_response ::= "QUOTA" SPACE astring SPACE quota_list
Fields:¶ ↑
- mailbox
-
The mailbox with the associated quota.
- usage
-
Current storage usage of mailbox.
- quota
-
Quota limit imposed on mailbox.
Net::IMAP::MailboxQuotaRoot represents part of the GETQUOTAROOT response. (GETQUOTAROOT can also return Net::IMAP::MailboxQuota.)
quotaroot_response ::= "QUOTAROOT" SPACE astring *(SPACE astring)
Fields:¶ ↑
- mailbox
-
The mailbox with the associated quota.
- quotaroots
-
Zero or more quotaroots that effect the quota on the specified mailbox.
Flag indicating that a mailbox context name cannot contain children.
Flag indicating that a mailbox is not selected.
Flag indicating that the message is “recent”, meaning that this session is the first session in which the client has been notified of this message.
Net::IMAP::ResponseCode represents response codes.
resp_text_code ::= "ALERT" / "PARSE" / "PERMANENTFLAGS" SPACE "(" #(flag / "\*") ")" / "READ-ONLY" / "READ-WRITE" / "TRYCREATE" / "UIDVALIDITY" SPACE nz_number / "UNSEEN" SPACE nz_number / atom [SPACE 1*<any TEXT_CHAR except "]">]
Fields:¶ ↑
- name
-
Returns the name such as “ALERT”, “PERMANENTFLAGS”, “UIDVALIDITY”.…
- data
-
Returns the data if it exists.
Net::IMAP::ResponseText represents texts of responses. The text may be prefixed by the response code.
resp_text ::= ["[" resp_text_code "]" SPACE] (text_mime2 / text) ;; text SHOULD NOT begin with "[" or "="
Fields:¶ ↑
- code
-
Returns the response code. See ((<Net::IMAP::ResponseCode>)).
- text
-
Returns the text.
Flag indicating a message has been seen
Net::IMAP::StatusData represents contents of the STATUS response.
Fields:¶ ↑
- mailbox
-
Returns the mailbox name.
- attr
-
Returns a hash. Each key is one of “MESSAGES”, “RECENT”, “UIDNEXT”, “UIDVALIDITY”, “UNSEEN”. Each value is a number.
Net::IMAP::TaggedResponse represents tagged responses.
The server completion result response indicates the success or failure of the operation. It is tagged with the same tag as the client command which began the operation.
response_tagged ::= tag SPACE resp_cond_state CRLF tag ::= 1*<any ATOM_CHAR except "+"> resp_cond_state ::= ("OK" / "NO" / "BAD") SPACE resp_text
Fields:¶ ↑
- tag
-
Returns the tag.
- name
-
Returns the name. the name is one of “OK”, “NO”, “BAD”.
- data
-
Returns the data. See ((<Net::IMAP::ResponseText>)).
- raw_data
-
Returns the raw data string.
Net::IMAP::ThreadMember represents a thread-node returned by #thread
Fields:¶ ↑
- seqno
-
The sequence number of this message.
- children
-
an array of Net::IMAP::ThreadMember objects for mail
items that are children of this in the thread.
Flag indicating that the mailbox does not contains new messages.
Net::IMAP::UntaggedResponse represents untagged responses.
Data transmitted by the server to the client and status responses that do not indicate command completion are prefixed with the token “*”, and are called untagged responses.
response_data ::= "*" SPACE (resp_cond_state / resp_cond_bye / mailbox_data / message_data / capability_data)
Fields:¶ ↑
- name
-
Returns the name such as “FLAGS”, “LIST”, “FETCH”.…
- data
-
Returns the data such as an array of flag symbols,
a ((<Net::IMAP::MailboxList>)) object....
- raw_data
-
Returns the raw data string.
Attributes
The thread to receive exceptions.
Returns an initial greeting response from the server.
Returns all response handlers.
Returns recorded untagged responses. For example:
imap.select("inbox") p imap.responses["EXISTS"][-1] #=> 2 p imap.responses["UIDVALIDITY"][-1] #=> 968263756
Public Class Methods
Adds an authenticator for #authenticate.
auth_type
is the type of authentication this authenticator
supports (for instance, “LOGIN”). The authenticator
is an
object which defines a process() method to handle authentication with the
server. See Net::IMAP::LoginAuthenticator, Net::IMAP::CramMD5Authenticator,
and Net::IMAP::DigestMD5Authenticator
for examples.
If auth_type
refers to an existing authenticator, it will be
replaced by the new one.
# File lib/net/imap.rb, line 294 def self.add_authenticator(auth_type, authenticator) @@authenticators[auth_type] = authenticator end
Returns the debug mode.
# File lib/net/imap.rb, line 264 def self.debug return @@debug end
Sets the debug mode.
# File lib/net/imap.rb, line 269 def self.debug=(val) return @@debug = val end
Decode a string from modified UTF-7 format to UTF-8.
UTF-7 is a 7-bit encoding of Unicode [UTF7]. IMAP uses a slightly modified version of this to encode mailbox names containing non-ASCII characters; see [IMAP] section 5.1.3.
Net::IMAP does not automatically encode and decode mailbox names to and from utf7.
# File lib/net/imap.rb, line 957 def self.decode_utf7(s) return s.gsub(/&([^-]+)?-/n) { if $1 ($1.tr(",", "/") + "===").unpack("m")[0].encode(Encoding::UTF_8, Encoding::UTF_16BE) else "&" end } end
The default port for IMAP connections, port 143
# File lib/net/imap.rb, line 299 def self.default_port return PORT end
The default port for IMAPS connections, port 993
# File lib/net/imap.rb, line 304 def self.default_tls_port return SSL_PORT end
Encode a string from UTF-8 format to modified UTF-7.
# File lib/net/imap.rb, line 968 def self.encode_utf7(s) return s.gsub(/(&)|[^\x20-\x7e]+/) { if $1 "&-" else base64 = [$&.encode(Encoding::UTF_16BE)].pack("m") "&" + base64.delete("=\n").tr("/", ",") + "-" end }.force_encoding("ASCII-8BIT") end
Formats time
as an IMAP-style date.
# File lib/net/imap.rb, line 980 def self.format_date(time) return time.strftime('%d-%b-%Y') end
Formats time
as an IMAP-style date-time.
# File lib/net/imap.rb, line 985 def self.format_datetime(time) return time.strftime('%d-%b-%Y %H:%M %z') end
Returns the max number of flags interned to symbols.
# File lib/net/imap.rb, line 274 def self.max_flag_count return @@max_flag_count end
Sets the max number of flags interned to symbols.
# File lib/net/imap.rb, line 279 def self.max_flag_count=(count) @@max_flag_count = count end
Creates a new Net::IMAP object and connects it to
the specified host
.
options
is an option hash, each key of which is a symbol.
The available options are:
- port
-
port number (default value is 143 for imap, or 993 for imaps)
- ssl
-
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).
- Errno::ENETUNREACH
-
there is no route to that network.
- SocketError
-
hostname not known or other socket error.
- Net::IMAP::ByeResponseError
-
we connected to the host, but they immediately said goodbye to us.
# File lib/net/imap.rb, line 1027 def initialize(host, port_or_options = {}, usessl = false, certs = nil, verify = true) super() @host = host begin options = port_or_options.to_hash rescue NoMethodError # for backward compatibility options = {} options[:port] = port_or_options if usessl options[:ssl] = create_ssl_params(certs, verify) end end @port = options[:port] || (options[:ssl] ? SSL_PORT : PORT) @tag_prefix = "RUBY" @tagno = 0 @parser = ResponseParser.new @sock = TCPSocket.open(@host, @port) if options[:ssl] start_tls_session(options[:ssl]) @usessl = true else @usessl = false end @responses = Hash.new([].freeze) @tagged_responses = {} @response_handlers = [] @tagged_response_arrival = new_cond @continuation_request_arrival = new_cond @idle_done_cond = nil @logout_command_tag = nil @debug_output_bol = true @exception = nil @greeting = get_response if @greeting.nil? @sock.close raise Error, "connection closed" end if @greeting.name == "BYE" @sock.close raise ByeResponseError, @greeting end @client_thread = Thread.current @receiver_thread = Thread.start { begin receive_responses rescue Exception end } @receiver_thread_terminating = false end
Public Instance Methods
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.
imap.add_response_handler { |resp| if resp.kind_of?(Net::IMAP::UntaggedResponse) and resp.name == "EXISTS" puts "Mailbox now has #{resp.data} messages" end }
# File lib/net/imap.rb, line 874 def add_response_handler(handler = Proc.new) @response_handlers.push(handler) end
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:
imap.append("inbox", "Subject: hello From: shugo@ruby-lang.org To: shugo@ruby-lang.org hello world ".gsub(/\n/, "\r\n"), [:Seen], Time.now)
A Net::IMAP::NoResponseError is raised if the mailbox does not exist (it is not created automatically), or if the flags, date_time, or message arguments contain errors.
# File lib/net/imap.rb, line 693 def append(mailbox, message, flags = nil, date_time = nil) args = [] if flags args.push(flags) end args.push(date_time) if date_time args.push(Literal.new(message)) send_command("APPEND", mailbox, *args) end
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.
For example:
imap.authenticate('LOGIN', user, password)
A Net::IMAP::NoResponseError is raised if authentication fails.
# File lib/net/imap.rb, line 411 def authenticate(auth_type, *args) auth_type = auth_type.upcase unless @@authenticators.has_key?(auth_type) raise ArgumentError, format('unknown auth type - "%s"', auth_type) end authenticator = @@authenticators[auth_type].new(*args) send_command("AUTHENTICATE", auth_type) do |resp| if resp.instance_of?(ContinuationRequest) data = authenticator.process(resp.data.text.unpack("m")[0]) s = [data].pack("m").gsub(/\n/, "") send_string_data(s) put_string(CRLF) end end end
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.
# File lib/net/imap.rb, line 353 def capability synchronize do send_command("CAPABILITY") return @responses.delete("CAPABILITY")[-1] end end
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 lib/net/imap.rb, line 707 def check send_command("CHECK") end
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 lib/net/imap.rb, line 714 def close send_command("CLOSE") end
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 lib/net/imap.rb, line 835 def copy(set, mailbox) copy_internal("COPY", set, mailbox) end
Sends a CREATE command to create a new mailbox
.
A Net::IMAP::NoResponseError is raised if a mailbox with that name cannot be created.
# File lib/net/imap.rb, line 474 def create(mailbox) send_command("CREATE", mailbox) end
Sends a DELETE command to remove the mailbox
.
A Net::IMAP::NoResponseError is raised if a mailbox with that name cannot be deleted, either because it does not exist or because the client does not have permission to delete it.
# File lib/net/imap.rb, line 483 def delete(mailbox) send_command("DELETE", mailbox) end
Disconnects from the server.
# File lib/net/imap.rb, line 315 def disconnect begin begin # try to call SSL::SSLSocket#io. @sock.io.shutdown rescue NoMethodError # @sock is not an SSL::SSLSocket. @sock.shutdown end rescue Errno::ENOTCONN # ignore `Errno::ENOTCONN: Socket is not connected' on some platforms. rescue Exception => e @receiver_thread.raise(e) end @receiver_thread.join synchronize do unless @sock.closed? @sock.close end end raise e if e end
Returns true if disconnected from the server.
# File lib/net/imap.rb, line 339 def disconnected? return @sock.closed? end
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.
A Net::IMAP::NoResponseError is raised if the mailbox does not exist or is for some reason non-examinable.
# File lib/net/imap.rb, line 463 def examine(mailbox) synchronize do @responses.clear send_command("EXAMINE", mailbox) end end
Sends a EXPUNGE command to permanently remove from the currently selected mailbox all messages that have the Deleted flag set.
# File lib/net/imap.rb, line 720 def expunge synchronize do send_command("EXPUNGE") return @responses.delete("EXPUNGE") end end
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:
p imap.fetch(6..8, "UID") #=> [#<Net::IMAP::FetchData seqno=6, attr={"UID"=>98}>, \\ #<Net::IMAP::FetchData seqno=7, attr={"UID"=>99}>, \\ #<Net::IMAP::FetchData seqno=8, attr={"UID"=>100}>] p imap.fetch(6, "BODY[HEADER.FIELDS (SUBJECT)]") #=> [#<Net::IMAP::FetchData seqno=6, attr={"BODY[HEADER.FIELDS (SUBJECT)]"=>"Subject: test\r\n\r\n"}>] data = imap.uid_fetch(98, ["RFC822.SIZE", "INTERNALDATE"])[0] p data.seqno #=> 6 p data.attr["RFC822.SIZE"] #=> 611 p data.attr["INTERNALDATE"] #=> "12-Oct-2000 22:40:59 +0900" p data.attr["UID"] #=> 98
# File lib/net/imap.rb, line 799 def fetch(set, attr) return fetch_internal("FETCH", set, attr) end
Send the GETACL command along with specified mailbox
. If this
mailbox exists, an array containing objects of Net::IMAP::MailboxACLItem will be
returned.
# File lib/net/imap.rb, line 633 def getacl(mailbox) synchronize do send_command("GETACL", mailbox) return @responses.delete("ACL")[-1] end end
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.
# File lib/net/imap.rb, line 597 def getquota(mailbox) synchronize do send_command("GETQUOTA", mailbox) return @responses.delete("QUOTA") end end
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.
# File lib/net/imap.rb, line 583 def getquotaroot(mailbox) synchronize do send_command("GETQUOTAROOT", mailbox) result = [] result.concat(@responses.delete("QUOTAROOT")) result.concat(@responses.delete("QUOTA")) return result end end
Sends an IDLE command that waits for notifications of new or expunged messages. Yields responses from the server during the IDLE.
Use idle_done() to leave IDLE.
# File lib/net/imap.rb, line 910 def idle(&response_handler) raise LocalJumpError, "no block given" unless response_handler response = nil synchronize do tag = Thread.current[:net_imap_tag] = generate_tag put_string("#{tag} IDLE#{CRLF}") begin add_response_handler(response_handler) @idle_done_cond = new_cond @idle_done_cond.wait @idle_done_cond = nil if @receiver_thread_terminating raise Net::IMAP::Error, "connection closed" end ensure unless @receiver_thread_terminating remove_response_handler(response_handler) put_string("DONE#{CRLF}") response = get_tagged_response(tag, "IDLE") end end end return response end
Leaves IDLE.
# File lib/net/imap.rb, line 940 def idle_done synchronize do if @idle_done_cond.nil? raise Net::IMAP::Error, "not during IDLE" end @idle_done_cond.signal end end
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.
The return value is an array of Net::IMAP::MailboxList
. For
example:
imap.create("foo/bar") imap.create("foo/baz") p imap.list("", "foo/%") #=> [#<Net::IMAP::MailboxList attr=[:Noselect], delim="/", name="foo/">, \\ #<Net::IMAP::MailboxList attr=[:Noinferiors, :Marked], delim="/", name="foo/bar">, \\ #<Net::IMAP::MailboxList attr=[:Noinferiors], delim="/", name="foo/baz">]
# File lib/net/imap.rb, line 540 def list(refname, mailbox) synchronize do send_command("LIST", refname, mailbox) return @responses.delete("LIST") end end
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.
A Net::IMAP::NoResponseError is raised if authentication fails.
# File lib/net/imap.rb, line 434 def login(user, password) send_command("LOGIN", user, password) end
Sends a LOGOUT command to inform the server that the client is done with the connection.
# File lib/net/imap.rb, line 367 def logout send_command("LOGOUT") end
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
.
# File lib/net/imap.rb, line 645 def lsub(refname, mailbox) synchronize do send_command("LSUB", refname, mailbox) return @responses.delete("LSUB") end end
Sends a NOOP command to the server. It does nothing.
# File lib/net/imap.rb, line 361 def noop send_command("NOOP") end
Removes the response handler.
# File lib/net/imap.rb, line 879 def remove_response_handler(handler) @response_handlers.delete(handler) end
Sends a RENAME command to change the name of the mailbox
to
newname
.
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
.
# File lib/net/imap.rb, line 494 def rename(mailbox, newname) send_command("RENAME", mailbox, newname) end
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.
- SINCE <date>
-
messages with an internal date on or after <date>.
- SUBJECT <string>
-
messages with <string> in their subject.
- TO <string>
-
messages with <string> in their TO field.
For example:
p imap.search(["SUBJECT", "hello", "NOT", "NEW"]) #=> [1, 6, 7, 8]
# File lib/net/imap.rb, line 767 def search(keys, charset = nil) return search_internal("SEARCH", keys, charset) end
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.
A Net::IMAP::NoResponseError is raised if the mailbox does not exist or is for some reason non-selectable.
# File lib/net/imap.rb, line 450 def select(mailbox) synchronize do @responses.clear send_command("SELECT", mailbox) end end
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].
# File lib/net/imap.rb, line 622 def setacl(mailbox, user, rights) if rights.nil? send_command("SETACL", mailbox, user, "") else send_command("SETACL", mailbox, user, rights) end end
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].
# File lib/net/imap.rb, line 609 def setquota(mailbox, quota) if quota.nil? data = '()' else data = '(STORAGE ' + quota.to_s + ')' end send_command("SETQUOTA", mailbox, RawData.new(data)) end
Sends a SORT command to sort messages in the mailbox. Returns an array of message sequence numbers. For example:
p imap.sort(["FROM"], ["ALL"], "US-ASCII") #=> [1, 2, 3, 5, 6, 7, 8, 4, 9] p imap.sort(["DATE"], ["SUBJECT", "hello"], "US-ASCII") #=> [6, 7, 8, 1]
See [SORT-THREAD-EXT] for more details.
# File lib/net/imap.rb, line 853 def sort(sort_keys, search_keys, charset) return sort_internal("SORT", sort_keys, search_keys, charset) end
Sends a STARTTLS command to start TLS session.
# File lib/net/imap.rb, line 372 def starttls(options = {}, verify = true) send_command("STARTTLS") do |resp| if resp.kind_of?(TaggedResponse) && resp.name == "OK" begin # for backward compatibility certs = options.to_str options = create_ssl_params(certs, verify) rescue NoMethodError end start_tls_session(options) end end end
Sends a STATUS command, and returns the status of the indicated
mailbox
. attr
is a list of one or more attributes
that we are request the status of. Supported attributes include:
MESSAGES:: the number of messages in the mailbox. RECENT:: the number of recent messages in the mailbox. UNSEEN:: the number of unseen messages in the mailbox.
The return value is a hash of attributes. For example:
p imap.status("inbox", ["MESSAGES", "RECENT"]) #=> {"RECENT"=>0, "MESSAGES"=>44}
A Net::IMAP::NoResponseError is
raised if status values for mailbox
cannot be returned, for
instance because it does not exist.
# File lib/net/imap.rb, line 668 def status(mailbox, attr) synchronize do send_command("STATUS", mailbox, attr) return @responses.delete("STATUS")[-1].attr end end
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.
The return value is an array of Net::IMAP::FetchData. For example:
p imap.store(6..8, "+FLAGS", [:Deleted]) #=> [#<Net::IMAP::FetchData seqno=6, attr={"FLAGS"=>[:Seen, :Deleted]}>, \\ #<Net::IMAP::FetchData seqno=7, attr={"FLAGS"=>[:Seen, :Deleted]}>, \\ #<Net::IMAP::FetchData seqno=8, attr={"FLAGS"=>[:Seen, :Deleted]}>]
# File lib/net/imap.rb, line 822 def store(set, attr, flags) return store_internal("STORE", set, attr, flags) end
Sends a SUBSCRIBE command to add the specified mailbox
name to
the server's set of “active” or “subscribed” mailboxes as returned by
lsub().
A Net::IMAP::NoResponseError is
raised if mailbox
cannot be subscribed to, for instance
because it does not exist.
# File lib/net/imap.rb, line 504 def subscribe(mailbox) send_command("SUBSCRIBE", mailbox) end
As for search(), but returns message sequence numbers in threaded format, as a Net::IMAP::ThreadMember tree. The supported algorithms are:
- ORDEREDSUBJECT
-
split into single-level threads according to subject, ordered by date.
- REFERENCES
-
split into threads by parent/child relationships determined by which message is a reply to which.
Unlike search(),
charset
is a required argument. US-ASCII and UTF-8 are sample
values.
See [SORT-THREAD-EXT] for more details.
# File lib/net/imap.rb, line 896 def thread(algorithm, search_keys, charset) return thread_internal("THREAD", algorithm, search_keys, charset) end
As for copy(), but set
contains unique identifiers.
# File lib/net/imap.rb, line 840 def uid_copy(set, mailbox) copy_internal("UID COPY", set, mailbox) end
As for fetch(), but set
contains unique identifiers.
# File lib/net/imap.rb, line 804 def uid_fetch(set, attr) return fetch_internal("UID FETCH", set, attr) end
As for search(), but returns unique identifiers.
# File lib/net/imap.rb, line 772 def uid_search(keys, charset = nil) return search_internal("UID SEARCH", keys, charset) end
As for sort(), but returns an array of unique identifiers.
# File lib/net/imap.rb, line 858 def uid_sort(sort_keys, search_keys, charset) return sort_internal("UID SORT", sort_keys, search_keys, charset) end
As for store(), but set
contains unique identifiers.
# File lib/net/imap.rb, line 827 def uid_store(set, attr, flags) return store_internal("UID STORE", set, attr, flags) end
As for thread(), but returns unique identifiers instead of message sequence numbers.
# File lib/net/imap.rb, line 902 def uid_thread(algorithm, search_keys, charset) return thread_internal("UID THREAD", algorithm, search_keys, charset) end
Sends a UNSUBSCRIBE command to remove the specified mailbox
name from the server's set of “active” or “subscribed” mailboxes.
A Net::IMAP::NoResponseError is
raised if mailbox
cannot be unsubscribed from, for instance
because the client is not currently subscribed to it.
# File lib/net/imap.rb, line 514 def unsubscribe(mailbox) send_command("UNSUBSCRIBE", mailbox) end
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
The return value is an array of Net::IMAP::MailboxList
. For
example:
imap.create("foo/bar") imap.create("foo/baz") p imap.xlist("", "foo/%") #=> [#<Net::IMAP::MailboxList attr=[:Noselect], delim="/", name="foo/">, \\ #<Net::IMAP::MailboxList attr=[:Noinferiors, :Marked], delim="/", name="foo/bar">, \\ #<Net::IMAP::MailboxList attr=[:Noinferiors], delim="/", name="foo/baz">]
# File lib/net/imap.rb, line 572 def xlist(refname, mailbox) synchronize do send_command("XLIST", refname, mailbox) return @responses.delete("XLIST") end end
Private Instance Methods
# File lib/net/imap.rb, line 1379 def copy_internal(cmd, set, mailbox) send_command(cmd, MessageSet.new(set), mailbox) end
# File lib/net/imap.rb, line 1418 def create_ssl_params(certs = nil, verify = true) params = {} if certs if File.file?(certs) params[:ca_file] = certs elsif File.directory?(certs) params[:ca_path] = certs end end if verify params[:verify_mode] = VERIFY_PEER else params[:verify_mode] = VERIFY_NONE end return params end
# File lib/net/imap.rb, line 1351 def fetch_internal(cmd, set, attr) case attr when String then attr = RawData.new(attr) when Array then attr = attr.map { |arg| arg.is_a?(String) ? RawData.new(arg) : arg } end synchronize do @responses.delete("FETCH") send_command(cmd, MessageSet.new(set), attr) return @responses.delete("FETCH") end end
# File lib/net/imap.rb, line 1219 def generate_tag @tagno += 1 return format("%s%04d", @tag_prefix, @tagno) end
# File lib/net/imap.rb, line 1164 def get_response buff = "" while true s = @sock.gets(CRLF) break unless s buff.concat(s) if /\{(\d+)\}\r\n/n =~ s s = @sock.read($1.to_i) buff.concat(s) else break end end return nil if buff.length == 0 if @@debug $stderr.print(buff.gsub(/^/n, "S: ")) end return @parser.parse(buff) end
# File lib/net/imap.rb, line 1148 def get_tagged_response(tag, cmd) until @tagged_responses.key?(tag) raise @exception if @exception @tagged_response_arrival.wait end resp = @tagged_responses.delete(tag) case resp.name when /\A(?:NO)\z/ni raise NoResponseError, resp when /\A(?:BAD)\z/ni raise BadResponseError, resp else return resp end end
# File lib/net/imap.rb, line 1407 def normalize_searching_criteria(keys) keys.collect! do |i| case i when -1, Range, Array MessageSet.new(i) else i end end end
# File lib/net/imap.rb, line 1224 def put_string(str) @sock.print(str) if @@debug if @debug_output_bol $stderr.print("C: ") end $stderr.print(str.gsub(/\n(?!\z)/n, "\nC: ")) if /\r\n\z/n.match(str) @debug_output_bol = true else @debug_output_bol = false end end end
# File lib/net/imap.rb, line 1082 def receive_responses connection_closed = false until connection_closed synchronize do @exception = nil end begin resp = get_response rescue Exception => e synchronize do @sock.close @exception = e end break end unless resp synchronize do @exception = EOFError.new("end of file reached") end break end begin synchronize do case resp when TaggedResponse @tagged_responses[resp.tag] = resp @tagged_response_arrival.broadcast if resp.tag == @logout_command_tag return end when UntaggedResponse record_response(resp.name, resp.data) if resp.data.instance_of?(ResponseText) && (code = resp.data.code) record_response(code.name, code.data) end if resp.name == "BYE" && @logout_command_tag.nil? @sock.close @exception = ByeResponseError.new(resp) connection_closed = true end when ContinuationRequest @continuation_request_arrival.signal end @response_handlers.each do |handler| handler.call(resp) end end rescue Exception => e @exception = e synchronize do @tagged_response_arrival.broadcast @continuation_request_arrival.broadcast end end end synchronize do @receiver_thread_terminating = true @tagged_response_arrival.broadcast @continuation_request_arrival.broadcast if @idle_done_cond @idle_done_cond.signal end end end
# File lib/net/imap.rb, line 1184 def record_response(name, data) unless @responses.has_key?(name) @responses[name] = [] end @responses[name].push(data) end
# File lib/net/imap.rb, line 1335 def search_internal(cmd, keys, charset) if keys.instance_of?(String) keys = [RawData.new(keys)] else normalize_searching_criteria(keys) end synchronize do if charset send_command(cmd, "CHARSET", charset, *keys) else send_command(cmd, *keys) end return @responses.delete("SEARCH")[-1] end end
# File lib/net/imap.rb, line 1191 def send_command(cmd, *args, &block) synchronize do args.each do |i| validate_data(i) end tag = generate_tag put_string(tag + " " + cmd) args.each do |i| put_string(" ") send_data(i) end put_string(CRLF) if cmd == "LOGOUT" @logout_command_tag = tag end if block add_response_handler(block) end begin return get_tagged_response(tag, cmd) ensure if block remove_response_handler(block) end end end end
# File lib/net/imap.rb, line 1258 def send_data(data) case data when nil put_string("NIL") when String send_string_data(data) when Integer send_number_data(data) when Array send_list_data(data) when Time send_time_data(data) when Symbol send_symbol_data(data) else data.send_data(self) end end
# File lib/net/imap.rb, line 1307 def send_list_data(list) put_string("(") first = true list.each do |i| if first first = false else put_string(" ") end send_data(i) end put_string(")") end
# File lib/net/imap.rb, line 1296 def send_literal(str) put_string("{" + str.bytesize.to_s + "}" + CRLF) @continuation_request_arrival.wait raise @exception if @exception put_string(str) end
# File lib/net/imap.rb, line 1303 def send_number_data(num) put_string(num.to_s) end
# File lib/net/imap.rb, line 1292 def send_quoted_string(str) put_string('"' + str.gsub(/["\]/n, "\\\\\\&") + '"') end
# File lib/net/imap.rb, line 1277 def send_string_data(str) case str when "" put_string('""') when /[\x80-\xff\r\n]/n # literal send_literal(str) when /[(){ \x00-\x1f\x7f%*"\]/n # quoted string send_quoted_string(str) else put_string(str) end end
# File lib/net/imap.rb, line 1331 def send_symbol_data(symbol) put_string("\\" + symbol.to_s) end
# File lib/net/imap.rb, line 1323 def send_time_data(time) t = time.dup.gmtime s = format('"%2d-%3s-%4d %02d:%02d:%02d +0000"', t.day, DATE_MONTH[t.month - 1], t.year, t.hour, t.min, t.sec) put_string(s) end
# File lib/net/imap.rb, line 1383 def sort_internal(cmd, sort_keys, search_keys, charset) if search_keys.instance_of?(String) search_keys = [RawData.new(search_keys)] else normalize_searching_criteria(search_keys) end normalize_searching_criteria(search_keys) synchronize do send_command(cmd, sort_keys, charset, *search_keys) return @responses.delete("SORT")[-1] end end
# File lib/net/imap.rb, line 1435 def start_tls_session(params = {}) unless defined?(OpenSSL::SSL) raise "SSL extension not installed" end if @sock.kind_of?(OpenSSL::SSL::SSLSocket) raise RuntimeError, "already using SSL" end begin params = params.to_hash rescue NoMethodError params = {} end context = SSLContext.new context.set_params(params) if defined?(VerifyCallbackProc) context.verify_callback = VerifyCallbackProc end @sock = SSLSocket.new(@sock, context) @sock.sync_close = true @sock.connect if context.verify_mode != VERIFY_NONE @sock.post_connection_check(@host) end end
# File lib/net/imap.rb, line 1368 def store_internal(cmd, set, attr, flags) if attr.instance_of?(String) attr = RawData.new(attr) end synchronize do @responses.delete("FETCH") send_command(cmd, MessageSet.new(set), attr, flags) return @responses.delete("FETCH") end end
# File lib/net/imap.rb, line 1396 def thread_internal(cmd, algorithm, search_keys, charset) if search_keys.instance_of?(String) search_keys = [RawData.new(search_keys)] else normalize_searching_criteria(search_keys) end normalize_searching_criteria(search_keys) send_command(cmd, algorithm, charset, *search_keys) return @responses.delete("THREAD")[-1] end
# File lib/net/imap.rb, line 1239 def validate_data(data) case data when nil when String when Integer if data < 0 || data >= 4294967296 raise DataFormatError, num.to_s end when Array data.each do |i| validate_data(i) end when Time when Symbol else data.validate end end