Class: Net::IMAP

Inherits:
Protocol
  • Object
show all
Includes:
MonitorMixin, OpenSSL, SSL
Defined in:
lib/net/imap.rb,
lib/net/imap/flags.rb,
lib/net/imap/command_data.rb,
lib/net/imap/data_encoding.rb,
lib/net/imap/response_data.rb,
lib/net/imap/response_parser.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 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.

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 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.

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, M. “INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1”, RFC-3501, March 2003. (Note: obsoletes RFC-2060, December 1996.)

[LANGUAGE-TAGS]

Phillips, A. and Davis, M. “Tags for Identifying Languages”, RFC-5646, September 2009. (Note: obsoletes RFC-3066, January 2001, RFC-4646, September 2006, and 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-5322]

Resnick, P., “Internet Message Format”, RFC-5322, October 2008. (Note: obsoletes RFC-2822, April 2001, and RFC-822, August 1982.)

[EXT-QUOTA]

Myers, J., “IMAP4 QUOTA extension”, RFC-2087, January 1997.

[EXT-NAMESPACE]

Gahrns, M. and Newman, C., “IMAP4 Namespace”, RFC-2342, May 1998.

[EXT-ID]

Showalter, T., “IMAP4 ID extension”, RFC-2971, October 2000.

[EXT-ACL]

Melnikov, A., “IMAP4 ACL extension”, RFC-4314, December 2005. (Note: obsoletes RFC-2086, January 1997.)

[EXT-SORT-THREAD]

Crispin, M. and Muchison, K., “INTERNET MESSAGE ACCESS PROTOCOL - SORT and THREAD Extensions”, RFC-5256, June 2008.

[EXT-MOVE]

Gulbrandsen, A. and Freed, N., “Internet Message Access Protocol (IMAP) - MOVE Extension”, RFC-6851, January 2013.

[OSSL]

www.openssl.org

[RSSL]

savannah.gnu.org/projects/rubypki

[UTF7]

Goldsmith, D. and Davis, M., “UTF-7: A Mail-Safe Transformation Format of Unicode”, RFC-2152, May 1997.

Defined Under Namespace

Modules: Authenticators, NumValidator, StringFormatter Classes: Address, Atom, BadResponseError, BodyTypeAttachment, BodyTypeBasic, BodyTypeExtension, BodyTypeMessage, BodyTypeMultipart, BodyTypeText, ByeResponseError, ClientID, ContentDisposition, ContinuationRequest, CramMD5Authenticator, DataFormatError, DigestMD5Authenticator, Envelope, Error, FetchData, FlagCountError, IgnoredResponse, Literal, LoginAuthenticator, MailboxACLItem, MailboxList, MailboxQuota, MailboxQuotaRoot, MessageSet, Namespace, Namespaces, NoResponseError, PlainAuthenticator, QuotedString, RawData, ResponseCode, ResponseError, ResponseParseError, ResponseParser, ResponseText, StatusData, TaggedResponse, ThreadMember, UntaggedResponse

Constant Summary collapse

VERSION =
"0.2.1"
SEEN =

:category: Message Flags

Flag indicating a message has been seen.

:Seen
ANSWERED =

:category: Message Flags

Flag indicating a message has been answered.

:Answered
FLAGGED =

:category: Message Flags

Flag indicating a message has been flagged for special or urgent attention.

:Flagged
DELETED =

:category: Message Flags

Flag indicating a message has been marked for deletion. This will occur when the mailbox is closed or expunged.

:Deleted
DRAFT =

:category: Message Flags

Flag indicating a message is only a draft or work-in-progress version.

:Draft
RECENT =

:category: Message Flags

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 =

:category: Mailbox Flags

Flag indicating that a mailbox context name cannot contain children.

:Noinferiors
NOSELECT =

:category: Mailbox Flags

Flag indicating that a mailbox is not selected.

:Noselect
MARKED =

:category: Mailbox Flags

Flag indicating that a mailbox has been marked “interesting” by the server; this commonly indicates that the mailbox contains new messages.

:Marked
UNMARKED =

:category: Mailbox Flags

Flag indicating that the mailbox does not contains new messages.

:Unmarked
@@max_flag_count =
10000

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#client_threadObject

The thread to receive exceptions.


262
263
264
# File 'lib/net/imap.rb', line 262

def client_thread
  @client_thread
end

#greetingObject (readonly)

Returns an initial greeting response from the server.


239
240
241
# File 'lib/net/imap.rb', line 239

def greeting
  @greeting
end

#idle_response_timeoutObject (readonly)

Seconds to wait until an IDLE response is received.


259
260
261
# File 'lib/net/imap.rb', line 259

def idle_response_timeout
  @idle_response_timeout
end

#open_timeoutObject (readonly)

Seconds to wait until a connection is opened. If the IMAP object cannot open a connection within this time, it raises a Net::OpenTimeout exception. The default value is 30 seconds.


256
257
258
# File 'lib/net/imap.rb', line 256

def open_timeout
  @open_timeout
end

#response_handlersObject (readonly)

Returns all response handlers.


251
252
253
# File 'lib/net/imap.rb', line 251

def response_handlers
  @response_handlers
end

#responsesObject (readonly)

Returns recorded untagged responses. For example:

imap.select("inbox")
p imap.responses["EXISTS"][-1]
#=> 2
p imap.responses["UIDVALIDITY"][-1]
#=> 968263756

248
249
250
# File 'lib/net/imap.rb', line 248

def responses
  @responses
end

Class Method Details

.debugObject

Returns the debug mode.


265
266
267
# File 'lib/net/imap.rb', line 265

def self.debug
  return @@debug
end

.debug=(val) ⇒ Object

Sets the debug mode.


270
271
272
# File 'lib/net/imap.rb', line 270

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 UTF-7.


14
15
16
17
18
19
20
21
22
# File 'lib/net/imap/data_encoding.rb', line 14

def self.decode_utf7(s)
  return s.gsub(/&([^-]+)?-/n) {
    if $1
      ($1.tr(",", "/") + "===").unpack1("m").encode(Encoding::UTF_8, Encoding::UTF_16BE)
    else
      "&"
    end
  }
end

.default_portObject Also known as: default_imap_port

The default port for IMAP connections, port 143


275
276
277
# File 'lib/net/imap.rb', line 275

def self.default_port
  return PORT
end

.default_tls_portObject Also known as: default_imaps_port, default_ssl_port

The default port for IMAPS connections, port 993


280
281
282
# File 'lib/net/imap.rb', line 280

def self.default_tls_port
  return SSL_PORT
end

.encode_utf7(s) ⇒ Object

Encode a string from UTF-8 format to modified UTF-7.


25
26
27
28
29
30
31
32
33
34
# File 'lib/net/imap/data_encoding.rb', line 25

def self.encode_utf7(s)
  return s.gsub(/(&)|[^\x20-\x7e]+/) {
    if $1
      "&-"
    else
      base64 = [$&.encode(Encoding::UTF_16BE)].pack("m0")
      "&" + base64.delete("=").tr("/", ",") + "-"
    end
  }.force_encoding("ASCII-8BIT")
end

.format_date(time) ⇒ Object

Formats time as an IMAP-style date.


37
38
39
# File 'lib/net/imap/data_encoding.rb', line 37

def self.format_date(time)
  return time.strftime('%d-%b-%Y')
end

.format_datetime(time) ⇒ Object

Formats time as an IMAP-style date-time.


42
43
44
# File 'lib/net/imap/data_encoding.rb', line 42

def self.format_datetime(time)
  return time.strftime('%d-%b-%Y %H:%M %z')
end

.max_flag_countObject

Returns the max number of flags interned to symbols.


66
67
68
# File 'lib/net/imap/flags.rb', line 66

def self.max_flag_count
  return @@max_flag_count
end

.max_flag_count=(count) ⇒ Object

Sets the max number of flags interned to symbols.


71
72
73
# File 'lib/net/imap/flags.rb', line 71

def self.max_flag_count=(count)
  @@max_flag_count = count
end

Instance Method Details

#add_response_handler(handler = nil, &block) ⇒ Object

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:

imap.add_response_handler { |resp|
  if resp.kind_of?(Net::IMAP::UntaggedResponse) and resp.name == "EXISTS"
    puts "Mailbox now has #{resp.data} messages"
  end
}

Raises:

  • (ArgumentError)

965
966
967
968
# File 'lib/net/imap.rb', line 965

def add_response_handler(handler = nil, &block)
  raise ArgumentError, "two Procs are passed" if handler && block
  @response_handlers.push(block || 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 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:

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.


753
754
755
756
757
758
759
760
761
# File 'lib/net/imap.rb', line 753

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

#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 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 add_authenticator 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.


410
411
412
413
414
415
416
417
418
419
420
# File 'lib/net/imap.rb', line 410

def authenticate(auth_type, *args)
  authenticator = self.class.authenticator(auth_type, *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("m0")
      send_string_data(s)
      put_string(CRLF)
    end
  end
end

#capabilityObject

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.


328
329
330
331
332
333
# File 'lib/net/imap.rb', line 328

def capability
  synchronize do
    send_command("CAPABILITY")
    return @responses.delete("CAPABILITY")[-1]
  end
end

#checkObject

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.


767
768
769
# File 'lib/net/imap.rb', line 767

def check
  send_command("CHECK")
end

#closeObject

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.


774
775
776
# File 'lib/net/imap.rb', line 774

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, an array of numbers, or a Range object. The number is a message sequence number.


907
908
909
# File 'lib/net/imap.rb', line 907

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.


468
469
470
# File 'lib/net/imap.rb', line 468

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.


477
478
479
# File 'lib/net/imap.rb', line 477

def delete(mailbox)
  send_command("DELETE", mailbox)
end

#disconnectObject

Disconnects from the server.


291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
# File 'lib/net/imap.rb', line 291

def disconnect
  return if disconnected?
  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
    @sock.close
  end
  raise e if e
end

#disconnected?Boolean

Returns true if disconnected from the server.

Returns:

  • (Boolean)

314
315
316
# File 'lib/net/imap.rb', line 314

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.


457
458
459
460
461
462
# File 'lib/net/imap.rb', line 457

def examine(mailbox)
  synchronize do
    @responses.clear
    send_command("EXAMINE", mailbox)
  end
end

#expungeObject

Sends a EXPUNGE command to permanently remove from the currently selected mailbox all messages that have the Deleted flag set.


780
781
782
783
784
785
# File 'lib/net/imap.rb', line 780

def expunge
  synchronize do
    send_command("EXPUNGE")
    return @responses.delete("EXPUNGE")
  end
end

#fetch(set, attr, mod = nil) ⇒ Object

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.

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

871
872
873
# File 'lib/net/imap.rb', line 871

def fetch(set, attr, mod = nil)
  return fetch_internal("FETCH", set, attr, mod)
end

#getacl(mailbox) ⇒ Object

Send the GETACL command along with a specified mailbox. If this mailbox exists, an array containing objects of Net::IMAP::MailboxACLItem will be returned.

The ACL extension is described in [EXT-ACL]


692
693
694
695
696
697
# File 'lib/net/imap.rb', line 692

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

The QUOTA extension is described in [EXT-QUOTA]


652
653
654
655
656
657
# File 'lib/net/imap.rb', line 652

def getquota(mailbox)
  synchronize do
    send_command("GETQUOTA", mailbox)
    return @responses.delete("QUOTA")
  end
end

#getquotaroot(mailbox) ⇒ Object

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.

The QUOTA extension is described in [EXT-QUOTA]


636
637
638
639
640
641
642
643
644
# File 'lib/net/imap.rb', line 636

def getquotaroot(mailbox)
  synchronize do
    send_command("GETQUOTAROOT", mailbox)
    result = []
    result.concat(@responses.delete("QUOTAROOT"))
    result.concat(@responses.delete("QUOTA"))
    return result
  end
end

#id(client_id = nil) ⇒ Object

Sends an ID command, and returns a hash of the server's response, or nil if the server does not identify itself.

Note that the user should first check if the server supports the ID capability. For example:

capabilities = imap.capability
if capabilities.include?("ID")
  id = imap.id(
    name: "my IMAP client (ruby)",
    version: MyIMAP::VERSION,
    "support-url": "mailto:[email protected]",
    os: RbConfig::CONFIG["host_os"],
  )
end

See [EXT-ID] for field definitions.


352
353
354
355
356
357
# File 'lib/net/imap.rb', line 352

def id(client_id=nil)
  synchronize do
    send_command("ID", ClientID.new(client_id))
    @responses.delete("ID")&.last
  end
end

#idle(timeout = nil, &response_handler) ⇒ Object

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.

If timeout is given, this method returns after timeout seconds passed. timeout can be used for keep-alive. For example, the following code checks the connection for each 60 seconds.

loop do
  imap.idle(60) do |res|
    ...
  end
end

Raises:

  • (LocalJumpError)

1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
# File 'lib/net/imap.rb', line 1014

def idle(timeout = nil, &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(timeout)
      @idle_done_cond = nil
      if @receiver_thread_terminating
        raise @exception || Net::IMAP::Error.new("connection closed")
      end
    ensure
      unless @receiver_thread_terminating
        remove_response_handler(response_handler)
        put_string("DONE#{CRLF}")
        response = get_tagged_response(tag, "IDLE", @idle_response_timeout)
      end
    end
  end

  return response
end

#idle_doneObject

Leaves IDLE.


1044
1045
1046
1047
1048
1049
1050
1051
# File 'lib/net/imap.rb', line 1044

def idle_done
  synchronize do
    if @idle_done_cond.nil?
      raise Net::IMAP::Error, "not during IDLE"
    end
    @idle_done_cond.signal
  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">]

534
535
536
537
538
539
# File 'lib/net/imap.rb', line 534

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.


428
429
430
# File 'lib/net/imap.rb', line 428

def (user, password)
  send_command("LOGIN", user, password)
end

#logoutObject

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


366
367
368
# File 'lib/net/imap.rb', line 366

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.


705
706
707
708
709
710
# File 'lib/net/imap.rb', line 705

def lsub(refname, mailbox)
  synchronize do
    send_command("LSUB", refname, mailbox)
    return @responses.delete("LSUB")
  end
end

#move(set, mailbox) ⇒ Object

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 MOVE extension is described in [EXT-MOVE].


922
923
924
# File 'lib/net/imap.rb', line 922

def move(set, mailbox)
  copy_internal("MOVE", set, mailbox)
end

#namespaceObject

Sends a NAMESPACE command and returns the namespaces that are available. The NAMESPACE command allows a client to discover the prefixes of namespaces used by a server for personal mailboxes, other users' mailboxes, and shared mailboxes.

The NAMESPACE extension predates [IMAP4rev1], so most IMAP servers support it. Many popular IMAP servers are configured with the default personal namespaces as `(“” “/”)`: no prefix and “/” hierarchy delimiter. In that common case, the naive client may not have any trouble naming mailboxes.

But many servers are configured with the default personal namespace as e.g. `(“INBOX.” “.”)`, placing all personal folders under INBOX, with “.” as the hierarchy delimiter. If the client does not check for this, but naively assumes it can use the same folder names for all servers, then folder creation (and listing, moving, etc) can lead to errors.

From RFC2342:

Although typically a server will support only a single Personal
Namespace, and a single Other User's Namespace, circumstances exist
where there MAY be multiples of these, and a client MUST be prepared
for them. If a client is configured such that it is required to create
a certain mailbox, there can be circumstances where it is unclear which
Personal Namespaces it should create the mailbox in. In these
situations a client SHOULD let the user select which namespaces to
create the mailbox in.

The user of this method should first check if the server supports the NAMESPACE capability. The return value is a Net::IMAP::Namespaces object which has personal, other, and shared fields, each an array of Net::IMAP::Namespace objects. These arrays will be empty when the server responds with nil.

For example:

capabilities = imap.capability
if capabilities.include?("NAMESPACE")
  namespaces = imap.namespace
  if namespace = namespaces.personal.first
    prefix = namespace.prefix  # e.g. "" or "INBOX."
    delim  = namespace.delim   # e.g. "/" or "."
    # personal folders should use the prefix and delimiter
    imap.create(prefix + "foo")
    imap.create(prefix + "bar")
    imap.create(prefix + %w[path to my folder].join(delim))
  end
end

The NAMESPACE extension is described in [EXT-NAMESPACE]


591
592
593
594
595
596
# File 'lib/net/imap.rb', line 591

def namespace
  synchronize do
    send_command("NAMESPACE")
    return @responses.delete("NAMESPACE")[-1]
  end
end

#noopObject

Sends a NOOP command to the server. It does nothing.


360
361
362
# File 'lib/net/imap.rb', line 360

def noop
  send_command("NOOP")
end

#remove_response_handler(handler) ⇒ Object

Removes the response handler.


971
972
973
# File 'lib/net/imap.rb', line 971

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.


488
489
490
# File 'lib/net/imap.rb', line 488

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]

827
828
829
# File 'lib/net/imap.rb', line 827

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.


444
445
446
447
448
449
# File 'lib/net/imap.rb', line 444

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 ACL extension is described in [EXT-ACL]


679
680
681
682
683
684
685
# File 'lib/net/imap.rb', line 679

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 a server admin for this to work.

The QUOTA extension is described in [EXT-QUOTA]


665
666
667
668
669
670
671
672
# File 'lib/net/imap.rb', line 665

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]

The SORT extension is described in [EXT-SORT-THREAD].


942
943
944
# File 'lib/net/imap.rb', line 942

def sort(sort_keys, search_keys, charset)
  return sort_internal("SORT", sort_keys, search_keys, charset)
end

#starttls(options = {}, verify = true) ⇒ Object

Sends a STARTTLS command to start TLS session.


371
372
373
374
375
376
377
378
379
380
381
382
383
# File 'lib/net/imap.rb', line 371

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

#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 whose statuses are to be requested. 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.


728
729
730
731
732
733
# File 'lib/net/imap.rb', line 728

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, 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.

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]}>]

894
895
896
# File 'lib/net/imap.rb', line 894

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.


498
499
500
# File 'lib/net/imap.rb', line 498

def subscribe(mailbox)
  send_command("SUBSCRIBE", mailbox)
end

#thread(algorithm, search_keys, charset) ⇒ Object

Similar to #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.

The THREAD extension is described in [EXT-SORT-THREAD].


988
989
990
# File 'lib/net/imap.rb', line 988

def thread(algorithm, search_keys, charset)
  return thread_internal("THREAD", algorithm, search_keys, charset)
end

#uid_copy(set, mailbox) ⇒ Object

Similar to #copy, but set contains unique identifiers.


912
913
914
# File 'lib/net/imap.rb', line 912

def uid_copy(set, mailbox)
  copy_internal("UID COPY", set, mailbox)
end

#uid_fetch(set, attr, mod = nil) ⇒ Object

Similar to #fetch, but set contains unique identifiers.


876
877
878
# File 'lib/net/imap.rb', line 876

def uid_fetch(set, attr, mod = nil)
  return fetch_internal("UID FETCH", set, attr, mod)
end

#uid_move(set, mailbox) ⇒ Object

Similar to #move, but set contains unique identifiers.

The MOVE extension is described in [EXT-MOVE].


929
930
931
# File 'lib/net/imap.rb', line 929

def uid_move(set, mailbox)
  copy_internal("UID MOVE", set, mailbox)
end

#uid_search(keys, charset = nil) ⇒ Object

Similar to #search, but returns unique identifiers.


832
833
834
# File 'lib/net/imap.rb', line 832

def uid_search(keys, charset = nil)
  return search_internal("UID SEARCH", keys, charset)
end

#uid_sort(sort_keys, search_keys, charset) ⇒ Object

Similar to #sort, but returns an array of unique identifiers.

The SORT extension is described in [EXT-SORT-THREAD].


949
950
951
# File 'lib/net/imap.rb', line 949

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

Similar to #store, but set contains unique identifiers.


899
900
901
# File 'lib/net/imap.rb', line 899

def uid_store(set, attr, flags)
  return store_internal("UID STORE", set, attr, flags)
end

#uid_thread(algorithm, search_keys, charset) ⇒ Object

Similar to #thread, but returns unique identifiers instead of message sequence numbers.

The THREAD extension is described in [EXT-SORT-THREAD].


996
997
998
# File 'lib/net/imap.rb', line 996

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.


508
509
510
# File 'lib/net/imap.rb', line 508

def unsubscribe(mailbox)
  send_command("UNSUBSCRIBE", mailbox)
end

#xlist(refname, mailbox) ⇒ Object

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">]

623
624
625
626
627
628
# File 'lib/net/imap.rb', line 623

def xlist(refname, mailbox)
  synchronize do
    send_command("XLIST", refname, mailbox)
    return @responses.delete("XLIST")
  end
end