Class: Net::IMAP
- Inherits:
-
Object
- Object
- Net::IMAP
- Includes:
- MonitorMixin, OpenSSL, SSL
- Defined in:
- lib/net/imap.rb
Overview
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 ||
envelope = imap.fetch(, "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 ||
imap.copy(, "Mail/sent-apr03")
imap.store(, "+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.
Defined Under Namespace
Classes: Address, Atom, BadResponseError, BodyTypeBasic, BodyTypeMessage, BodyTypeMultipart, BodyTypeText, ByeResponseError, ContentDisposition, ContinuationRequest, CramMD5Authenticator, DataFormatError, Envelope, Error, FetchData, Literal, LoginAuthenticator, MailboxACLItem, MailboxList, MailboxQuota, MailboxQuotaRoot, MessageSet, NoResponseError, QuotedString, RawData, ResponseCode, ResponseError, ResponseParseError, ResponseParser, ResponseText, StatusData, TaggedResponse, ThreadMember, UntaggedResponse
Constant Summary collapse
- SEEN =
Flag indicating a message has been seen
:Seen
- ANSWERED =
Flag indicating a message has been answered
:Answered
- FLAGGED =
Flag indicating a message has been flagged for special or urgent attention
:Flagged
- DELETED =
Flag indicating a message has been marked for deletion. This will occur when the mailbox is closed or expunged.
:Deleted
- DRAFT =
Flag indicating a message is only a draft or work-in-progress version.
:Draft
- RECENT =
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.
:Recent
- NOINFERIORS =
Flag indicating that a mailbox context name cannot contain children.
:Noinferiors
- NOSELECT =
Flag indicating that a mailbox is not selected.
:Noselect
- MARKED =
Flag indicating that a mailbox has been marked "interesting" by the server; this commonly indicates that the mailbox contains new messages.
:Marked
- UNMARKED =
Flag indicating that the mailbox does not contains new messages.
:Unmarked
- CRLF =
"\r\n"
- PORT =
:nodoc: :nodoc:
143
- DATE_MONTH =
%w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)
- @@debug =
false
- @@authenticators =
{}
Instance Attribute Summary collapse
-
#client_thread ⇒ Object
The thread to receive exceptions.
-
#greeting ⇒ Object
readonly
Returns an initial greeting response from the server.
-
#response_handlers ⇒ Object
readonly
Returns all response handlers.
-
#responses ⇒ Object
readonly
Returns recorded untagged responses.
Class Method Summary collapse
-
.add_authenticator(auth_type, authenticator) ⇒ Object
Adds an authenticator for Net::IMAP#authenticate.
-
.debug ⇒ Object
Returns the debug mode.
-
.debug=(val) ⇒ Object
Sets the debug mode.
-
.decode_utf7(s) ⇒ Object
Decode a string from modified UTF-7 format to UTF-8.
-
.encode_utf7(s) ⇒ Object
Encode a string from UTF-8 format to modified UTF-7.
Instance Method Summary collapse
-
#add_response_handler(handler = Proc.new) ⇒ Object
Adds a response handler.
-
#append(mailbox, message, flags = nil, date_time = nil) ⇒ Object
Sends a APPEND command to append the
message
to the end of themailbox
. -
#authenticate(auth_type, *args) ⇒ Object
Sends an AUTHENTICATE command to authenticate the client.
-
#capability ⇒ Object
Sends a CAPABILITY command, and returns an array of capabilities that the server supports.
-
#check ⇒ Object
Sends a CHECK command to request a checkpoint of the currently selected mailbox.
-
#close ⇒ Object
Sends a CLOSE command to close the currently selected mailbox.
-
#copy(set, mailbox) ⇒ Object
Sends a COPY command to copy the specified message(s) to the end of the specified destination
mailbox
. -
#create(mailbox) ⇒ Object
Sends a CREATE command to create a new
mailbox
. -
#delete(mailbox) ⇒ Object
Sends a DELETE command to remove the
mailbox
. -
#disconnect ⇒ Object
Disconnects from the server.
-
#disconnected? ⇒ Boolean
Returns true if disconnected from the server.
-
#examine(mailbox) ⇒ Object
Sends a EXAMINE command to select a
mailbox
so that messages in themailbox
can be accessed. -
#expunge ⇒ Object
Sends a EXPUNGE command to permanently remove from the currently selected mailbox all messages that have the Deleted flag set.
-
#fetch(set, attr) ⇒ Object
Sends a FETCH command to retrieve data associated with a message in the mailbox.
-
#getacl(mailbox) ⇒ Object
Send the GETACL command along with specified
mailbox
. -
#getquota(mailbox) ⇒ Object
Sends the GETQUOTA command along with specified
mailbox
. -
#getquotaroot(mailbox) ⇒ Object
Sends the GETQUOTAROOT command along with specified
mailbox
. -
#list(refname, mailbox) ⇒ Object
Sends a LIST command, and returns a subset of names from the complete set of all names available to the client.
-
#login(user, password) ⇒ Object
Sends a LOGIN command to identify the client and carries the plaintext
password
authenticating thisuser
. -
#logout ⇒ Object
Sends a LOGOUT command to inform the server that the client is done with the connection.
-
#lsub(refname, mailbox) ⇒ Object
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".
-
#noop ⇒ Object
Sends a NOOP command to the server.
-
#remove_response_handler(handler) ⇒ Object
Removes the response handler.
-
#rename(mailbox, newname) ⇒ Object
Sends a RENAME command to change the name of the
mailbox
tonewname
. -
#search(keys, charset = nil) ⇒ Object
Sends a SEARCH command to search the mailbox for messages that match the given searching criteria, and returns message sequence numbers.
-
#select(mailbox) ⇒ Object
Sends a SELECT command to select a
mailbox
so that messages in themailbox
can be accessed. -
#setacl(mailbox, user, rights) ⇒ Object
Sends the SETACL command along with
mailbox
,user
and therights
that user is to have on that mailbox. -
#setquota(mailbox, quota) ⇒ Object
Sends a SETQUOTA command along with the specified
mailbox
andquota
. -
#sort(sort_keys, search_keys, charset) ⇒ Object
Sends a SORT command to sort messages in the mailbox.
-
#status(mailbox, attr) ⇒ Object
Sends a STATUS command, and returns the status of the indicated
mailbox
. -
#store(set, attr, flags) ⇒ Object
Sends a STORE command to alter data associated with messages in the mailbox, in particular their flags.
-
#subscribe(mailbox) ⇒ Object
Sends a SUBSCRIBE command to add the specified
mailbox
name to the server's set of "active" or "subscribed" mailboxes as returned by #lsub(). -
#thread(algorithm, search_keys, charset) ⇒ Object
As for #search(), but returns message sequence numbers in threaded format, as a Net::IMAP::ThreadMember tree.
-
#uid_copy(set, mailbox) ⇒ Object
As for #copy(), but
set
contains unique identifiers. -
#uid_fetch(set, attr) ⇒ Object
As for #fetch(), but
set
contains unique identifiers. -
#uid_search(keys, charset = nil) ⇒ Object
As for #search(), but returns unique identifiers.
-
#uid_sort(sort_keys, search_keys, charset) ⇒ Object
As for #sort(), but returns an array of unique identifiers.
-
#uid_store(set, attr, flags) ⇒ Object
As for #store(), but
set
contains unique identifiers. -
#uid_thread(algorithm, search_keys, charset) ⇒ Object
As for #thread(), but returns unique identifiers instead of message sequence numbers.
-
#unsubscribe(mailbox) ⇒ Object
Sends a UNSUBSCRIBE command to remove the specified
mailbox
name from the server's set of "active" or "subscribed" mailboxes.
Instance Attribute Details
#client_thread ⇒ Object
The thread to receive exceptions.
223 224 225 |
# File 'lib/net/imap.rb', line 223 def client_thread @client_thread end |
#greeting ⇒ Object (readonly)
Returns an initial greeting response from the server.
208 209 210 |
# File 'lib/net/imap.rb', line 208 def greeting @greeting end |
#response_handlers ⇒ Object (readonly)
Returns all response handlers.
220 221 222 |
# File 'lib/net/imap.rb', line 220 def response_handlers @response_handlers end |
#responses ⇒ Object (readonly)
Returns recorded untagged responses. For example:
imap.select("inbox")
p imap.responses["EXISTS"][-1]
#=> 2
p imap.responses["UIDVALIDITY"][-1]
#=> 968263756
217 218 219 |
# File 'lib/net/imap.rb', line 217 def responses @responses end |
Class Method Details
.add_authenticator(auth_type, authenticator) ⇒ Object
Adds an authenticator for Net::IMAP#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 and Net::IMAP::CramMD5Authenticator for examples.
If auth_type
refers to an existing authenticator, it will be replaced by the new one.
281 282 283 |
# File 'lib/net/imap.rb', line 281 def self.add_authenticator(auth_type, authenticator) @@authenticators[auth_type] = authenticator end |
.debug ⇒ Object
Returns the debug mode.
263 264 265 |
# File 'lib/net/imap.rb', line 263 def self.debug return @@debug end |
.debug=(val) ⇒ Object
Sets the debug mode.
268 269 270 |
# File 'lib/net/imap.rb', line 268 def self.debug=(val) return @@debug = val end |
.decode_utf7(s) ⇒ Object
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.
827 828 829 830 831 832 833 834 835 836 837 838 839 840 |
# File 'lib/net/imap.rb', line 827 def self.decode_utf7(s) return s.gsub(/&(.*?)-/n) { if $1.empty? "&" else base64 = $1.tr(",", "/") x = base64.length % 4 if x > 0 base64.concat("=" * (4 - x)) end u16tou8(base64.unpack("m")[0]) end } end |
.encode_utf7(s) ⇒ Object
Encode a string from UTF-8 format to modified UTF-7.
843 844 845 846 847 848 849 850 851 852 |
# File 'lib/net/imap.rb', line 843 def self.encode_utf7(s) return s.gsub(/(&)|([^\x20-\x25\x27-\x7e]+)/n) { |x| if $1 "&-" else base64 = [u8tou16(x)].pack("m") "&" + base64.delete("=\n").tr("/", ",") + "-" end } end |
Instance Method Details
#add_response_handler(handler = Proc.new) ⇒ Object
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
}
787 788 789 |
# File 'lib/net/imap.rb', line 787 def add_response_handler(handler = Proc.new) @response_handlers.push(handler) end |
#append(mailbox, message, flags = nil, date_time = nil) ⇒ Object
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", <<EOF.gsub(/\n/, "\r\n"), [:Seen], Time.now)
Subject: hello
From: [email protected]
To: [email protected]
hello world
EOF
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.
606 607 608 609 610 611 612 613 614 |
# File 'lib/net/imap.rb', line 606 def append(mailbox, , flags = nil, date_time = nil) args = [] if flags args.push(flags) end args.push(date_time) if date_time args.push(Literal.new()) send_command("APPEND", mailbox, *args) end |
#authenticate(auth_type, *args) ⇒ Object
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.
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 |
# File 'lib/net/imap.rb', line 356 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 |
#capability ⇒ Object
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.
313 314 315 316 317 318 |
# File 'lib/net/imap.rb', line 313 def capability synchronize do send_command("CAPABILITY") return @responses.delete("CAPABILITY")[-1] end end |
#check ⇒ Object
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.
620 621 622 |
# File 'lib/net/imap.rb', line 620 def check send_command("CHECK") end |
#close ⇒ Object
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.
627 628 629 |
# File 'lib/net/imap.rb', line 627 def close send_command("CLOSE") end |
#copy(set, mailbox) ⇒ Object
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.
748 749 750 |
# File 'lib/net/imap.rb', line 748 def copy(set, mailbox) copy_internal("COPY", set, mailbox) end |
#create(mailbox) ⇒ Object
Sends a CREATE command to create a new mailbox
.
A Net::IMAP::NoResponseError is raised if a mailbox with that name cannot be created.
419 420 421 |
# File 'lib/net/imap.rb', line 419 def create(mailbox) send_command("CREATE", mailbox) end |
#delete(mailbox) ⇒ Object
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.
428 429 430 |
# File 'lib/net/imap.rb', line 428 def delete(mailbox) send_command("DELETE", mailbox) end |
#disconnect ⇒ Object
Disconnects from the server.
286 287 288 289 290 291 292 293 294 295 296 |
# File 'lib/net/imap.rb', line 286 def disconnect begin # try to call SSL::SSLSocket#io. @sock.io.shutdown rescue NoMethodError # @sock is not an SSL::SSLSocket. @sock.shutdown end @receiver_thread.join @sock.close end |
#disconnected? ⇒ Boolean
Returns true if disconnected from the server.
299 300 301 |
# File 'lib/net/imap.rb', line 299 def disconnected? return @sock.closed? end |
#examine(mailbox) ⇒ Object
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.
408 409 410 411 412 413 |
# File 'lib/net/imap.rb', line 408 def examine(mailbox) synchronize do @responses.clear send_command("EXAMINE", mailbox) end end |
#expunge ⇒ Object
Sends a EXPUNGE command to permanently remove from the currently selected mailbox all messages that have the Deleted flag set.
633 634 635 636 637 638 |
# File 'lib/net/imap.rb', line 633 def expunge synchronize do send_command("EXPUNGE") return @responses.delete("EXPUNGE") end end |
#fetch(set, attr) ⇒ Object
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
712 713 714 |
# File 'lib/net/imap.rb', line 712 def fetch(set, attr) return fetch_internal("FETCH", set, attr) end |
#getacl(mailbox) ⇒ Object
Send the GETACL command along with specified mailbox
. If this mailbox exists, an array containing objects of Net::IMAP::MailboxACLItem will be returned.
546 547 548 549 550 551 |
# File 'lib/net/imap.rb', line 546 def getacl(mailbox) synchronize do send_command("GETACL", mailbox) return @responses.delete("ACL")[-1] end end |
#getquota(mailbox) ⇒ Object
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.
510 511 512 513 514 515 |
# File 'lib/net/imap.rb', line 510 def getquota(mailbox) synchronize do send_command("GETQUOTA", mailbox) return @responses.delete("QUOTA") end end |
#getquotaroot(mailbox) ⇒ Object
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.
496 497 498 499 500 501 502 503 504 |
# File 'lib/net/imap.rb', line 496 def getquotaroot(mailbox) synchronize do send_command("GETQUOTAROOT", mailbox) result = [] result.concat(@responses.delete("QUOTAROOT")) result.concat(@responses.delete("QUOTA")) return result end end |
#list(refname, mailbox) ⇒ Object
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">]
485 486 487 488 489 490 |
# File 'lib/net/imap.rb', line 485 def list(refname, mailbox) synchronize do send_command("LIST", refname, mailbox) return @responses.delete("LIST") end end |
#login(user, password) ⇒ Object
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.
379 380 381 |
# File 'lib/net/imap.rb', line 379 def login(user, password) send_command("LOGIN", user, password) end |
#logout ⇒ Object
Sends a LOGOUT command to inform the server that the client is done with the connection.
327 328 329 |
# File 'lib/net/imap.rb', line 327 def logout send_command("LOGOUT") end |
#lsub(refname, mailbox) ⇒ Object
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
.
558 559 560 561 562 563 |
# File 'lib/net/imap.rb', line 558 def lsub(refname, mailbox) synchronize do send_command("LSUB", refname, mailbox) return @responses.delete("LSUB") end end |
#noop ⇒ Object
Sends a NOOP command to the server. It does nothing.
321 322 323 |
# File 'lib/net/imap.rb', line 321 def noop send_command("NOOP") end |
#remove_response_handler(handler) ⇒ Object
Removes the response handler.
792 793 794 |
# File 'lib/net/imap.rb', line 792 def remove_response_handler(handler) @response_handlers.delete(handler) end |
#rename(mailbox, newname) ⇒ Object
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
.
439 440 441 |
# File 'lib/net/imap.rb', line 439 def rename(mailbox, newname) send_command("RENAME", mailbox, newname) end |
#search(keys, charset = nil) ⇒ Object
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]
680 681 682 |
# File 'lib/net/imap.rb', line 680 def search(keys, charset = nil) return search_internal("SEARCH", keys, charset) end |
#select(mailbox) ⇒ Object
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.
395 396 397 398 399 400 |
# File 'lib/net/imap.rb', line 395 def select(mailbox) synchronize do @responses.clear send_command("SELECT", mailbox) end end |
#setacl(mailbox, user, rights) ⇒ Object
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].
535 536 537 538 539 540 541 |
# File 'lib/net/imap.rb', line 535 def setacl(mailbox, user, rights) if rights.nil? send_command("SETACL", mailbox, user, "") else send_command("SETACL", mailbox, user, rights) end end |
#setquota(mailbox, quota) ⇒ Object
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].
522 523 524 525 526 527 528 529 |
# File 'lib/net/imap.rb', line 522 def setquota(mailbox, quota) if quota.nil? data = '()' else data = '(STORAGE ' + quota.to_s + ')' end send_command("SETQUOTA", mailbox, RawData.new(data)) end |
#sort(sort_keys, search_keys, charset) ⇒ Object
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.
766 767 768 |
# File 'lib/net/imap.rb', line 766 def sort(sort_keys, search_keys, charset) return sort_internal("SORT", sort_keys, search_keys, charset) end |
#status(mailbox, attr) ⇒ Object
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.
581 582 583 584 585 586 |
# File 'lib/net/imap.rb', line 581 def status(mailbox, attr) synchronize do send_command("STATUS", mailbox, attr) return @responses.delete("STATUS")[-1].attr end end |
#store(set, attr, flags) ⇒ Object
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]}>]
735 736 737 |
# File 'lib/net/imap.rb', line 735 def store(set, attr, flags) return store_internal("STORE", set, attr, flags) end |
#subscribe(mailbox) ⇒ Object
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.
449 450 451 |
# File 'lib/net/imap.rb', line 449 def subscribe(mailbox) send_command("SUBSCRIBE", mailbox) end |
#thread(algorithm, search_keys, charset) ⇒ Object
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.
809 810 811 |
# File 'lib/net/imap.rb', line 809 def thread(algorithm, search_keys, charset) return thread_internal("THREAD", algorithm, search_keys, charset) end |
#uid_copy(set, mailbox) ⇒ Object
As for #copy(), but set
contains unique identifiers.
753 754 755 |
# File 'lib/net/imap.rb', line 753 def uid_copy(set, mailbox) copy_internal("UID COPY", set, mailbox) end |
#uid_fetch(set, attr) ⇒ Object
As for #fetch(), but set
contains unique identifiers.
717 718 719 |
# File 'lib/net/imap.rb', line 717 def uid_fetch(set, attr) return fetch_internal("UID FETCH", set, attr) end |
#uid_search(keys, charset = nil) ⇒ Object
As for #search(), but returns unique identifiers.
685 686 687 |
# File 'lib/net/imap.rb', line 685 def uid_search(keys, charset = nil) return search_internal("UID SEARCH", keys, charset) end |
#uid_sort(sort_keys, search_keys, charset) ⇒ Object
As for #sort(), but returns an array of unique identifiers.
771 772 773 |
# File 'lib/net/imap.rb', line 771 def uid_sort(sort_keys, search_keys, charset) return sort_internal("UID SORT", sort_keys, search_keys, charset) end |
#uid_store(set, attr, flags) ⇒ Object
As for #store(), but set
contains unique identifiers.
740 741 742 |
# File 'lib/net/imap.rb', line 740 def uid_store(set, attr, flags) return store_internal("UID STORE", set, attr, flags) end |
#uid_thread(algorithm, search_keys, charset) ⇒ Object
As for #thread(), but returns unique identifiers instead of message sequence numbers.
815 816 817 |
# File 'lib/net/imap.rb', line 815 def uid_thread(algorithm, search_keys, charset) return thread_internal("UID THREAD", algorithm, search_keys, charset) end |
#unsubscribe(mailbox) ⇒ Object
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.
459 460 461 |
# File 'lib/net/imap.rb', line 459 def unsubscribe(mailbox) send_command("UNSUBSCRIBE", mailbox) end |