class Net::IMAP

Net::IMAP implements Internet Message Access Protocol (IMAP) client functionality. The protocol is described in [IMAP4rev1].

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 examine (for read-only access). Once the client has successfully selected a mailbox, they enter the “selected” state, and that mailbox becomes the current mailbox, on which mail-item related commands implicitly operate.

Sequence numbers and UIDs

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.

To avoid sequence number race conditions, servers must not expunge messages when no command is in progress, nor when responding to fetch, store, or search. Expunges may be sent during any other command, including uid_fetch, uid_store, and uid_search. The noop and idle commands are both useful for this side-effect: they allow the server to send all mailbox updates, including expunges.

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 mail items within a mailbox, the UIDs have to be reassigned. An IMAP client thus cannot rearrange message orders.

Server capabilities and protocol extensions

Net::IMAP does not modify its behavior according to server capability. Users of the class must check for required capabilities before issuing commands. Special care should be taken to follow all capability requirements for starttls, login, and authenticate.

See the capability method for more information.

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.

What’s here?

Connection control methods

  • Net::IMAP.new: A new client connects immediately and waits for a successful server greeting before returning the new client object.

  • starttls: Asks the server to upgrade a clear-text connection to use TLS.

  • logout: Tells the server to end the session. Enters the “logout” state.

  • disconnect: Disconnects the connection (without sending logout first).

  • disconnected?: True if the connection has been closed.

Core IMAP commands

The following commands are defined either by the [IMAP4rev1] base specification, or by one of the following extensions: [IDLE], [NAMESPACE], [UNSELECT], [MOVE]. These extensions are widely supported by modern IMAP4rev1 servers and have all been integrated into [IMAP4rev2]. Note: Net::IMAP doesn’t fully support IMAP4rev2 yet.

IMAP commands for any state

  • capability: Returns the server’s capabilities as an array of strings.

    Capabilities may change after starttls, authenticate, or login and cached capabilities must be reloaded.

  • noop: Allows the server to send unsolicited untagged responses.

  • logout: Tells the server to end the session. Enters the “logout” state.

IMAP commands for the “Not Authenticated” state

In addition to the universal commands, the following commands are valid in the “not authenticated” state:

  • starttls: Upgrades a clear-text connection to use TLS.

    Requires the STARTTLS capability.

  • authenticate: Identifies the client to the server using a SASL mechanism. Enters the “authenticated” state.

    Requires the AUTH=#{mechanism} capability for the chosen mechanism.

  • login: Identifies the client to the server using a plain text password. Using authenticate is generally preferred. Enters the “authenticated” state.

    The LOGINDISABLED capability must NOT be listed.

IMAP commands for the “Authenticated” state

In addition to the universal commands, the following commands are valid in the “authenticated” state:

  • select: Open a mailbox and enter the “selected” state.

  • examine: Open a mailbox read-only, and enter the “selected” state.

  • create: Creates a new mailbox.

  • delete: Permanently remove a mailbox.

  • rename: Change the name of a mailbox.

  • subscribe: Adds a mailbox to the “subscribed” set.

  • unsubscribe: Removes a mailbox from the “subscribed” set.

  • list: Returns names and attributes of mailboxes matching a given pattern.

  • namespace: Returns mailbox namespaces, with path prefixes and delimiters.

    Requires the NAMESPACE capability.

  • status: Returns mailbox information, e.g. message count, unseen message count, UIDVALIDITY and UIDNEXT.

  • append: Appends a message to the end of a mailbox.

  • idle: Allows the server to send updates to the client, without the client needing to poll using noop.

    Requires the IDLE capability.

  • lsub: Lists mailboxes the user has declared “active” or “subscribed”.

IMAP commands for the “Selected” state

In addition to the universal commands and the “authenticated” commands, the following commands are valid in the “selected” state:

  • close: Closes the mailbox and returns to the “authenticated” state, expunging deleted messages, unless the mailbox was opened as read-only.

  • unselect: Closes the mailbox and returns to the “authenticated” state, without expunging any messages.

    Requires the UNSELECT capability.

  • expunge: Permanently removes messages which have the Deleted flag set.

  • uid_expunge: Restricts expunge to only remove the specified UIDs.

    Requires the UIDPLUS capability.

  • search, uid_search: Returns sequence numbers or UIDs of messages that match the given searching criteria.

  • fetch, uid_fetch: Returns data associated with a set of messages, specified by sequence number or UID.

  • store, uid_store: Alters a message’s flags.

  • copy, uid_copy: Copies the specified messages to the end of the specified destination mailbox.

  • move, uid_move: Moves the specified messages to the end of the specified destination mailbox, expunging them from the current mailbox.

    Requires the MOVE capability.

  • check: Mostly obsolete. Can be replaced with noop or idle.

IMAP commands for the “Logout” state

No IMAP commands are valid in the logout state. If the socket is still open, Net::IMAP will close it after receiving server confirmation. Exceptions will be raised by IMAP commands that have already started and are waiting for a response, as well as any that are called after logout.

Supported IMAP extensions

RFC9051: IMAP4rev2

Although IMAP4rev2 is not supported yet, Net::IMAP supports several extensions that have been folded into it: IDLE, MOVE, NAMESPACE, UIDPLUS, and UNSELECT. Commands for these extensions are included with the Core IMAP commands, above. Other supported extensons are listed below.

RFC2087: QUOTA

  • getquota: returns the resource usage and limits for a quota root

  • getquotaroot: returns the list of quota roots for a mailbox, as well as their resource usage and limits.

  • setquota: sets the resource limits for a given quota root.

RFC2177: IDLE

Folded into IMAP4rev2, so it is also listed with Core IMAP commands.

  • idle: Allows the server to send updates to the client, without the client needing to poll using noop.

RFC2342: NAMESPACE

Folded into IMAP4rev2, so it is also listed with Core IMAP commands.

  • namespace: Returns mailbox namespaces, with path prefixes and delimiters.

RFC2971: ID

  • id: exchanges client and server implementation information.

RFC3691: UNSELECT

Folded into IMAP4rev2, so it is also listed with Core IMAP commands.

  • unselect: Closes the mailbox and returns to the “authenticated” state, without expunging any messages.

RFC4314: ACL

  • getacl: lists the authenticated user’s access rights to a mailbox.

  • setacl: sets the access rights for a user on a mailbox

  • Note: DELETEACL, LISTRIGHTS, and MYRIGHTS are not supported yet.

RFC4315: UIDPLUS

Folded into IMAP4rev2, so it is also listed with Core IMAP commands.

RFC5256: SORT

RFC5256: THREAD

XLIST (non-standard, deprecated)

  • xlist: replaced by SPECIAL-USE attributes in list responses.

RFC6851: MOVE

Folded into IMAP4rev2, so it is also listed with Core IMAP commands.

  • move, uid_move: Moves the specified messages to the end of the specified destination mailbox, expunging them from the current mailbox.

Handling server responses

  • greeting: The server’s initial untagged response, which can indicate a pre-authenticated connection.

  • responses: The untagged responses, as a hash. Keys are the untagged response type (e.g. “OK”, “FETCH”, “FLAGS”) and response code (e.g. “ALERT”, “UIDVALIDITY”, “UIDNEXT”, “TRYCREATE”, etc). Values are arrays of UntaggedResponse or ResponseCode.

  • add_response_handler: Add a block to be called inside the receiver thread with every server response.

  • remove_response_handler: Remove a previously added response handler.

References

[IMAP4rev1]

Crispin, M., “INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1”, RFC 3501, DOI 10.17487/RFC3501, March 2003, <www.rfc-editor.org/info/rfc3501>.

[IMAP-ABNF-EXT]

Melnikov, A. and C. Daboo, “Collected Extensions to IMAP4 ABNF”, RFC 4466, DOI 10.17487/RFC4466, April 2006, <www.rfc-editor.org/info/rfc4466>.

Note: Net::IMAP cannot parse the entire RFC4466 grammar yet.

[IMAP4rev2]

Melnikov, A., Ed., and B. Leiba, Ed., “Internet Message Access Protocol (IMAP) - Version 4rev2”, RFC 9051, DOI 10.17487/RFC9051, August 2021, <www.rfc-editor.org/info/rfc9051>.

Note: Net::IMAP is not fully compatible with IMAP4rev2 yet.

[IMAP-IMPLEMENTATION]

Leiba, B., “IMAP4 Implementation Recommendations”, RFC 2683, DOI 10.17487/RFC2683, September 1999, <www.rfc-editor.org/info/rfc2683>.

[IMAP-MULTIACCESS]

Gahrns, M., “IMAP4 Multi-Accessed Mailbox Practice”, RFC 2180, DOI 10.17487/RFC2180, July 1997, <www.rfc-editor.org/info/rfc2180>.

[UTF7]

Goldsmith, D. and M. Davis, “UTF-7 A Mail-Safe Transformation Format of Unicode”, RFC 2152, DOI 10.17487/RFC2152, May 1997, <www.rfc-editor.org/info/rfc2152>.

Message envelope and body structure

[RFC5322]

Resnick, P., Ed., “Internet Message Format”, RFC 5322, DOI 10.17487/RFC5322, October 2008, <www.rfc-editor.org/info/rfc5322>.

Note: obsoletes RFC-2822 (April 2001) and RFC-822 (August 1982).

[CHARSET]

Freed, N. and J. Postel, “IANA Charset Registration Procedures”, BCP 19, RFC 2978, DOI 10.17487/RFC2978, October 2000, <www.rfc-editor.org/info/rfc2978>.

[DISPOSITION]

Troost, R., Dorner, S., and K. Moore, Ed., “Communicating Presentation Information in Internet Messages: The Content-Disposition Header Field”, RFC 2183, DOI 10.17487/RFC2183, August 1997, <www.rfc-editor.org/info/rfc2183>.

[MIME-IMB]

Freed, N. and N. Borenstein, “Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies”, RFC 2045, DOI 10.17487/RFC2045, November 1996, <www.rfc-editor.org/info/rfc2045>.

[MIME-IMT]

Freed, N. and N. Borenstein, “Multipurpose Internet Mail Extensions (MIME) Part Two: Media Types”, RFC 2046, DOI 10.17487/RFC2046, November 1996, <www.rfc-editor.org/info/rfc2046>.

[MIME-HDRS]

Moore, K., “MIME (Multipurpose Internet Mail Extensions) Part Three: Message Header Extensions for Non-ASCII Text”, RFC 2047, DOI 10.17487/RFC2047, November 1996, <www.rfc-editor.org/info/rfc2047>.

[RFC2231]

Freed, N. and K. Moore, “MIME Parameter Value and Encoded Word Extensions: Character Sets, Languages, and Continuations”, RFC 2231, DOI 10.17487/RFC2231, November 1997, <www.rfc-editor.org/info/rfc2231>.

[I18n-HDRS]

Yang, A., Steele, S., and N. Freed, “Internationalized Email Headers”, RFC 6532, DOI 10.17487/RFC6532, February 2012, <www.rfc-editor.org/info/rfc6532>.

[LANGUAGE-TAGS]

Alvestrand, H., “Content Language Headers”, RFC 3282, DOI 10.17487/RFC3282, May 2002, <www.rfc-editor.org/info/rfc3282>.

[LOCATION]

Palme, J., Hopmann, A., and N. Shelness, “MIME Encapsulation of Aggregate Documents, such as HTML (MHTML)”, RFC 2557, DOI 10.17487/RFC2557, March 1999, <www.rfc-editor.org/info/rfc2557>.

[MD5]

Myers, J. and M. Rose, “The Content-MD5 Header Field”, RFC 1864, DOI 10.17487/RFC1864, October 1995, <www.rfc-editor.org/info/rfc1864>.

Supported IMAP Extensions

[QUOTA]

Myers, J., “IMAP4 QUOTA extension”, RFC 2087, DOI 10.17487/RFC2087, January 1997, <www.rfc-editor.org/info/rfc2087>.

[IDLE]

Leiba, B., “IMAP4 IDLE command”, RFC 2177, DOI 10.17487/RFC2177, June 1997, <www.rfc-editor.org/info/rfc2177>.

[NAMESPACE]

Gahrns, M. and C. Newman, “IMAP4 Namespace”, RFC 2342, DOI 10.17487/RFC2342, May 1998, <www.rfc-editor.org/info/rfc2342>.

[ID]

Showalter, T., “IMAP4 ID extension”, RFC 2971, DOI 10.17487/RFC2971, October 2000, <www.rfc-editor.org/info/rfc2971>.

[ACL]

Melnikov, A., “IMAP4 Access Control List (ACL) Extension”, RFC 4314, DOI 10.17487/RFC4314, December 2005, <www.rfc-editor.org/info/rfc4314>.

[UIDPLUS]

Crispin, M., “Internet Message Access Protocol (IMAP) - UIDPLUS extension”, RFC 4315, DOI 10.17487/RFC4315, December 2005, <www.rfc-editor.org/info/rfc4315>.

[SORT]

Crispin, M. and K. Murchison, “Internet Message Access Protocol - SORT and THREAD Extensions”, RFC 5256, DOI 10.17487/RFC5256, June 2008, <www.rfc-editor.org/info/rfc5256>.

[THREAD]

Crispin, M. and K. Murchison, “Internet Message Access Protocol - SORT and THREAD Extensions”, RFC 5256, DOI 10.17487/RFC5256, June 2008, <www.rfc-editor.org/info/rfc5256>.

[RFC5530]

Gulbrandsen, A., “IMAP Response Codes”, RFC 5530, DOI 10.17487/RFC5530, May 2009, <www.rfc-editor.org/info/rfc5530>.

[MOVE]

Gulbrandsen, A. and N. Freed, Ed., “Internet Message Access Protocol (IMAP) - MOVE Extension”, RFC 6851, DOI 10.17487/RFC6851, January 2013, <www.rfc-editor.org/info/rfc6851>.

IANA registries

Constants

STRFDATE

strftime/strptime format for an IMAP4 date, excluding optional dquotes. Use via the encode_date and decode_date methods.

date            = date-text / DQUOTE date-text DQUOTE
date-text       = date-day "-" date-month "-" date-year

date-day        = 1*2DIGIT
                    ; Day of month
date-month      = "Jan" / "Feb" / "Mar" / "Apr" / "May" / "Jun" /
                  "Jul" / "Aug" / "Sep" / "Oct" / "Nov" / "Dec"
date-year       = 4DIGIT
STRFTIME

strftime/strptime format for an IMAP4 date-time, including dquotes. See the encode_datetime and decode_datetime methods.

date-time       = DQUOTE date-day-fixed "-" date-month "-" date-year
                  SP time SP zone DQUOTE

date-day-fixed  = (SP DIGIT) / 2DIGIT
                    ; Fixed-format version of date-day
date-month      = "Jan" / "Feb" / "Mar" / "Apr" / "May" / "Jun" /
                  "Jul" / "Aug" / "Sep" / "Oct" / "Nov" / "Dec"
date-year       = 4DIGIT
time            = 2DIGIT ":" 2DIGIT ":" 2DIGIT
                    ; Hours minutes seconds
zone            = ("+" / "-") 4DIGIT
                    ; Signed four-digit value of hhmm representing
                    ; hours and minutes east of Greenwich (that is,
                    ; the amount that the given time differs from
                    ; Universal Time).  Subtracting the timezone
                    ; from the given time will give the UT form.
                    ; The Universal Time zone is "+0000".

Note that Time.strptime "%d" flexibly parses either space or zero padding. However, the DQUOTEs are not optional.

VERSION

Attributes

greeting[R]

Returns the initial greeting the server, an UntaggedResponse.

idle_response_timeout[R]

Seconds to wait until an IDLE response is received.

open_timeout[R]

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.

response_handlers[R]

Returns all response handlers.

responses[R]

Returns recorded untagged responses.

For example:

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

Public Class Methods

debug() click to toggle source

Returns the debug mode.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 740
def self.debug
  return @@debug
end
debug=(val) click to toggle source

Sets the debug mode.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 745
def self.debug=(val)
  return @@debug = val
end
decode_date(string) → Date click to toggle source

Decodes string as an IMAP formatted “date”.

Double quotes are optional. Day of month may be padded with zero or space. See STRFDATE.

# File net-imap-0.3.4.1/lib/net/imap/data_encoding.rb, line 89
def self.decode_date(string)
  string = string.delete_prefix('"').delete_suffix('"')
  Date.strptime(string, STRFDATE)
end
Also aliased as: parse_date
decode_datetime(string) → DateTime click to toggle source

Decodes string as an IMAP4 formatted “date-time”.

Note that double quotes are not optional. See STRFTIME.

# File net-imap-0.3.4.1/lib/net/imap/data_encoding.rb, line 106
def self.decode_datetime(string)
  DateTime.strptime(string, STRFTIME)
end
Also aliased as: parse_datetime
decode_time(string) → Time click to toggle source

Decodes string as an IMAP4 formatted “date-time”.

Same as decode_datetime, but returning a Time instead.

# File net-imap-0.3.4.1/lib/net/imap/data_encoding.rb, line 115
def self.decode_time(string)
  decode_datetime(string).to_time
end
Also aliased as: parse_time
decode_utf7(s) click to toggle source

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.

# File net-imap-0.3.4.1/lib/net/imap/data_encoding.rb, line 56
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_imap_port()
Alias for: default_port
default_imaps_port()
Alias for: default_tls_port
default_port() click to toggle source

The default port for IMAP connections, port 143

# File net-imap-0.3.4.1/lib/net/imap.rb, line 750
def self.default_port
  return PORT
end
Also aliased as: default_imap_port
default_ssl_port()
Alias for: default_tls_port
default_tls_port() click to toggle source

The default port for IMAPS connections, port 993

# File net-imap-0.3.4.1/lib/net/imap.rb, line 755
def self.default_tls_port
  return SSL_PORT
end
encode_date(date) click to toggle source

Formats time as an IMAP4 date.

# File net-imap-0.3.4.1/lib/net/imap/data_encoding.rb, line 79
def self.encode_date(date)
  date.to_date.strftime STRFDATE
end
Also aliased as: format_date
encode_datetime(time) → string click to toggle source

Formats time as an IMAP4 date-time.

# File net-imap-0.3.4.1/lib/net/imap/data_encoding.rb, line 97
def self.encode_datetime(time)
  time.to_datetime.strftime STRFTIME
end
Also aliased as: encode_time
encode_time(time)
Also aliased as: format_time
Alias for: encode_datetime
encode_utf7(s) click to toggle source

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

# File net-imap-0.3.4.1/lib/net/imap/data_encoding.rb, line 67
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(date)
Alias for: encode_date
format_datetime(time) click to toggle source
DEPRECATED

The original version returned incorrectly formatted strings. Strings returned by encode_datetime or format_time use the correct IMAP4rev1 syntax for “date-time”.

This invalid format has been temporarily retained for backward compatibility. A future release will change this method to return the correct format.

# File net-imap-0.3.4.1/lib/net/imap/data_encoding.rb, line 137
def self.format_datetime(time)
  warn("#{self}.format_datetime incorrectly formats IMAP date-time. " \
       "Convert to #{self}.encode_datetime or #{self}.format_time instead.",
       uplevel: 1, category: :deprecated)
  time.strftime("%d-%b-%Y %H:%M %z")
end
format_time(time)
Alias for: encode_time
Net::IMAP.new(host, options = {}) click to toggle source

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[:ssl] is true, then an attempt will be made to use SSL (now TLS) to connect to the server. If options[:ssl] is a hash, it’s passed to OpenSSL::SSL::SSLContext#set_params as parameters.

open_timeout

Seconds to wait until a connection is opened

idle_response_timeout

Seconds to wait until an IDLE response is received

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

The connected to the host was successful, but it immediately said goodbye.

Calls superclass method
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2009
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
  @open_timeout = options[:open_timeout] || 30
  @idle_response_timeout = options[:idle_response_timeout] || 5
  @parser = ResponseParser.new
  @sock = tcp_socket(@host, @port)
  begin
    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
    @continued_command_tag = nil
    @continuation_request_arrival = new_cond
    @continuation_request_exception = nil
    @idle_done_cond = nil
    @logout_command_tag = nil
    @debug_output_bol = true
    @exception = nil

    @greeting = get_response
    if @greeting.nil?
      raise Error, "connection closed"
    end
    if @greeting.name == "BYE"
      raise ByeResponseError, @greeting
    end

    @client_thread = Thread.current
    @receiver_thread = Thread.start {
      begin
        receive_responses
      rescue Exception
      end
    }
    @receiver_thread_terminating = false
  rescue Exception
    @sock.close
    raise
  end
end
parse_date(string)
Alias for: decode_date
parse_datetime(string)
Alias for: decode_datetime
parse_time(string)
Alias for: decode_time

Public Instance Methods

add_response_handler(handler = nil, &block) click to toggle source

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

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 net-imap-0.3.4.1/lib/net/imap.rb, line 1963
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) click to toggle source

Sends an APPEND command [IMAP4rev1 §6.3.11] 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: shugo@ruby-lang.org
To: shugo@ruby-lang.org

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.

Capabilities

If UIDPLUS [RFC4315] is supported and the destination supports persistent UIDs, the server’s response should include an APPENDUID response code with UIDPlusData. This will report the UIDVALIDITY of the destination mailbox and the assigned UID of the appended message.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1487
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(mechanism, ...) → ok_resp click to toggle source
authenticate(mech, *creds, **props) {|prop, auth| val } → ok_resp
authenticate(mechanism, authnid, credentials, authzid=nil) → ok_resp
authenticate(mechanism, **properties) → ok_resp
authenticate(mechanism) {|propname, authctx| prop_value } → ok_resp

Sends an AUTHENTICATE command [IMAP4rev1 §6.2.2] to authenticate the client. If successful, the connection enters the “authenticated” state.

mechanism is the name of the SASL authentication mechanism to be used. All other arguments are forwarded to the authenticator for the requested mechanism. The listed call signatures are suggestions. The documentation for each individual mechanism must be consulted for its specific parameters.

An exception Net::IMAP::NoResponseError is raised if authentication fails.

Related: login, starttls

Supported SASL Mechanisms

PLAIN

See PlainAuthenticator. Login using clear-text username and password.

XOAUTH2

See XOauth2Authenticator. Login using a username and OAuth2 access token. Non-standard and obsoleted by OAUTHBEARER, but widely supported.

Deprecated: Obsolete mechanisms are available for backwards compatibility.

For DIGEST-MD5 see DigestMD5Authenticator.

For LOGIN, see LoginAuthenticator.

For CRAM-MD5, see CramMD5Authenticator.

Using a deprecated mechanism will print a warning.

See Net::IMAP::Authenticators for information on plugging in authenticators for other mechanisms. See the SASL mechanism registry for information on these and other SASL mechanisms.

Capabilities

Clients MUST NOT attempt to authenticate with a mechanism unless "AUTH=#{mechanism}" for that mechanism is a server capability.

Server capabilities may change after starttls, login, and authenticate. Cached capabilities must be invalidated after this method completes. The TaggedResponse to authenticate may include updated capabilities in its ResponseCode.

Example

If the authenticators ignore unhandled keyword arguments, the same config can be used for multiple mechanisms:

password  = nil # saved locally, so we don't ask more than once
accesstok = nil # saved locally...
creds = {
  authcid:      username,
  password:     proc { password  ||= ui.prompt_for_password },
  oauth2_token: proc { accesstok ||= kms.fresh_access_token },
}
capa = imap.capability
if    capa.include? "AUTH=OAUTHBEARER"
  imap.authenticate "OAUTHBEARER",   **creds # authcid, oauth2_token
elsif capa.include? "AUTH=XOAUTH2"
  imap.authenticate "XOAUTH2",       **creds # authcid, oauth2_token
elsif capa.include? "AUTH=SCRAM-SHA-256"
  imap.authenticate "SCRAM-SHA-256", **creds # authcid, password
elsif capa.include? "AUTH=PLAIN"
  imap.authenticate "PLAIN",         **creds # authcid, password
elsif capa.include? "AUTH=DIGEST-MD5"
  imap.authenticate "DIGEST-MD5",    **creds # authcid, password
elsif capa.include? "LOGINDISABLED"
  raise "the server has disabled login"
else
  imap.login username, password
end
# File net-imap-0.3.4.1/lib/net/imap.rb, line 1040
def authenticate(mechanism, *args, **props, &cb)
  authenticator = self.class.authenticator(mechanism, *args, **props, &cb)
  send_command("AUTHENTICATE", mechanism) 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
capability() click to toggle source

Sends a CAPABILITY command [IMAP4rev1 §6.1.1] and returns an array of capabilities that the server supports. Each capability is a string.

See the IANA IMAP4 capabilities registry for a list of all standard capabilities, and their reference RFCs.

Note that Net::IMAP does not currently 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.

Capability requirements—other than IMAP4rev1—are listed in the documentation for each command method.

Basic IMAP4rev1 capabilities

All IMAP4rev1 servers must include IMAP4rev1 in their capabilities list. All IMAP4rev1 servers must implement the STARTTLS, AUTH=PLAIN, and LOGINDISABLED capabilities, and clients must respect their presence or absence. See the capabilites requirements on starttls, login, and authenticate.

Using IMAP4rev1 extensions

IMAP4rev1 servers must not activate incompatible behavior until an explicit client action invokes a capability, e.g. sending a command or command argument specific to that capability. Extensions with backward compatible behavior, such as response codes or mailbox attributes, may be sent at any time.

Invoking capabilities which are unknown to Net::IMAP may cause unexpected behavior and errors, for example ResponseParseError is raised when unknown response syntax is received. Invoking commands or command parameters that are unsupported by the server may raise NoResponseError, BadResponseError, or cause other unexpected behavior.

Caching CAPABILITY responses

Servers may send their capability list, unsolicited, using the CAPABILITY response code or an untagged CAPABILITY response. These responses can be retrieved and cached using responses or add_response_handler.

But cached capabilities must be discarded after starttls, login, or authenticate. The OK TaggedResponse to login and authenticate may include CAPABILITY response code data, but the TaggedResponse for starttls is sent clear-text and cannot be trusted.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 849
def capability
  synchronize do
    send_command("CAPABILITY")
    return @responses.delete("CAPABILITY")[-1]
  end
end
check() click to toggle source

Sends a CHECK command [IMAP4rev1 §6.4.1] 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.

Related: idle, noop

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1503
def check
  send_command("CHECK")
end
close() click to toggle source

Sends a CLOSE command [IMAP4rev1 §6.4.2] to close the currently selected mailbox. The CLOSE command permanently removes from the mailbox all messages that have the \Deleted flag set.

Related: unselect

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1513
def close
  send_command("CLOSE")
end
copy(set, mailbox) click to toggle source

Sends a COPY command [IMAP4rev1 §6.4.7] 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.

Related: uid_copy

Capabilities

If UIDPLUS [RFC4315] is supported, the server’s response should include a COPYUID response code with UIDPlusData. This will report the UIDVALIDITY of the destination mailbox, the UID set of the source messages, and the assigned UID set of the moved messages.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1749
def copy(set, mailbox)
  copy_internal("COPY", set, mailbox)
end
create(mailbox) click to toggle source

Sends a CREATE command [IMAP4rev1 §6.3.3] to create a new mailbox.

A Net::IMAP::NoResponseError is raised if a mailbox with that name cannot be created.

Related: rename, delete

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1129
def create(mailbox)
  send_command("CREATE", mailbox)
end
delete(mailbox) click to toggle source

Sends a DELETE command [IMAP4rev1 §6.3.4] 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.

Related: create, rename

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1141
def delete(mailbox)
  send_command("DELETE", mailbox)
end
disconnect() click to toggle source

Disconnects from the server.

Related: logout

# File net-imap-0.3.4.1/lib/net/imap.rb, line 768
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?() click to toggle source

Returns true if disconnected from the server.

Related: logout, disconnect

# File net-imap-0.3.4.1/lib/net/imap.rb, line 793
def disconnected?
  return @sock.closed?
end
examine(mailbox) click to toggle source

Sends a EXAMINE command [IMAP4rev1 §6.3.2] 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.

Related: select

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1115
def examine(mailbox)
  synchronize do
    @responses.clear
    send_command("EXAMINE", mailbox)
  end
end
expunge() click to toggle source

Sends an EXPUNGE command [IMAP4rev1 §6.4.3] Sends a EXPUNGE command to permanently remove from the currently selected mailbox all messages that have the Deleted flag set.

Related: uid_expunge

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1538
def expunge
  synchronize do
    send_command("EXPUNGE")
    return @responses.delete("EXPUNGE")
  end
end
fetch(set, attr, mod = nil) click to toggle source

Sends a FETCH command [IMAP4rev1 §6.4.5] 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 FetchData for a list of valid attributes.

The return value is an array of FetchData or nil (instead of an empty array) if there is no matching message.

Related: uid_search, 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 net-imap-0.3.4.1/lib/net/imap.rb, line 1681
def fetch(set, attr, mod = nil)
  return fetch_internal("FETCH", set, attr, mod)
end
getacl(mailbox) click to toggle source

Sends a GETACL command [RFC4314 §3.3] along with a specified mailbox. If this mailbox exists, an array containing objects of MailboxACLItem will be returned.

Related: setacl, MailboxACLItem

Capabilities

The server’s capabilities must include ACL [RFC4314].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1410
def getacl(mailbox)
  synchronize do
    send_command("GETACL", mailbox)
    return @responses.delete("ACL")[-1]
  end
end
getquota(mailbox) click to toggle source

Sends a GETQUOTA command [RFC2087 §4.2] along with specified mailbox. If this mailbox exists, then an array containing a MailboxQuota object is returned. This command is generally only available to server admin.

Related: getquotaroot, setquota, MailboxQuota

Capabilities

The server’s capabilities must include QUOTA [RFC2087].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1354
def getquota(mailbox)
  synchronize do
    send_command("GETQUOTA", mailbox)
    return @responses.delete("QUOTA")
  end
end
getquotaroot(mailbox) click to toggle source

Sends a GETQUOTAROOT command [RFC2087 §4.3] 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 MailboxQuotaRoot and MailboxQuota.

Related: getquota, setquota, MailboxQuotaRoot, MailboxQuota

Capabilities

The server’s capabilities must include QUOTA [RFC2087].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1333
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) click to toggle source

Sends an ID command [RFC2971 §3.1] 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:bugs@example.com",
    os: RbConfig::CONFIG["host_os"],
  )
end

See [ID] for field definitions.

Capabilities

The server’s capabilities must include ID

RFC2971
# File net-imap-0.3.4.1/lib/net/imap.rb, line 879
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) click to toggle source

Sends an IDLE command [RFC2177 §3] [IMAP4rev2 §6.3.13] 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

Related: idle_done, noop, check

Capabilities

The server’s capabilities must include IDLE [RFC2177].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1910
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_done() click to toggle source

Leaves IDLE.

Related: idle

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1942
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) click to toggle source

Sends a LIST command [IMAP4rev1 §6.3.8] 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 MailboxList.

Related: lsub, 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 net-imap-0.3.4.1/lib/net/imap.rb, line 1213
def list(refname, mailbox)
  synchronize do
    send_command("LIST", refname, mailbox)
    return @responses.delete("LIST")
  end
end
login(user, password) click to toggle source

Sends a LOGIN command [IMAP4rev1 §6.2.3] to identify the client and carries the plaintext password authenticating this user. If successful, the connection enters the “authenticated” state.

Using authenticate is generally preferred over login. The LOGIN command is not the same as authenticate with the “LOGIN” mechanism.

A Net::IMAP::NoResponseError is raised if authentication fails.

Related: authenticate, starttls

Capabilities

Clients MUST NOT call login if LOGINDISABLED is listed with the capabilities.

Server capabilities may change after starttls, login, and authenticate. Cached capabilities must be invalidated after this method completes. The TaggedResponse to login may include updated capabilities in its ResponseCode.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1073
def login(user, password)
  send_command("LOGIN", user, password)
end
logout() click to toggle source

Sends a LOGOUT command [IMAP4rev1 §6.1.3] to inform the command to inform the server that the client is done with the connection.

Related: disconnect

# File net-imap-0.3.4.1/lib/net/imap.rb, line 907
def logout
  send_command("LOGOUT")
end
lsub(refname, mailbox) click to toggle source

Sends a LSUB command [IMAP4rev1 §6.3.9] 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 MailboxList objects.

Related: subscribe, unsubscribe, list, MailboxList

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1425
def lsub(refname, mailbox)
  synchronize do
    send_command("LSUB", refname, mailbox)
    return @responses.delete("LSUB")
  end
end
move(set, mailbox) click to toggle source

Sends a MOVE command [RFC6851 §3.1] [IMAP4rev2 §6.4.8] 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.

Related: uid_move

Capabilities

The server’s capabilities must include MOVE [RFC6851].

If UIDPLUS [RFC4315] is supported, the server’s response should include a COPYUID response code with UIDPlusData. This will report the UIDVALIDITY of the destination mailbox, the UID set of the source messages, and the assigned UID set of the moved messages.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1785
def move(set, mailbox)
  copy_internal("MOVE", set, mailbox)
end
namespace() click to toggle source

Sends a NAMESPACE command [RFC2342 §5] 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 return value is a Namespaces object which has personal, other, and shared fields, each an array of Namespace objects. These arrays will be empty when the server responds with nil.

Many IMAP servers are configured with the default personal namespaces as ("" "/"): no prefix and the “/” 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.

Related: list, Namespaces, Namespace

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
Capabilities

The server’s capabilities must include NAMESPACE [RFC2342].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1271
def namespace
  synchronize do
    send_command("NAMESPACE")
    return @responses.delete("NAMESPACE")[-1]
  end
end
noop() click to toggle source

Sends a NOOP command [IMAP4rev1 §6.1.2] to the server.

This allows the server to send unsolicited untagged EXPUNGE responses, but does not execute any client request. IMAP servers are permitted to send unsolicited untagged responses at any time, except for ‘EXPUNGE`.

Related: idle, check

# File net-imap-0.3.4.1/lib/net/imap.rb, line 898
def noop
  send_command("NOOP")
end
remove_response_handler(handler) click to toggle source

Removes the response handler.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1969
def remove_response_handler(handler)
  @response_handlers.delete(handler)
end
rename(mailbox, newname) click to toggle source

Sends a RENAME command [IMAP4rev1 §6.3.5] 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.

Related: create, delete

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1154
def rename(mailbox, newname)
  send_command("RENAME", mailbox, newname)
end
select(mailbox) click to toggle source

Sends a SELECT command [IMAP4rev1 §6.3.1] 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 imap.responses["EXISTS"][-1], and the number of recent messages from imap.responses["RECENT"][-1]. Note that these values can change if new messages arrive during a session or when existing messages are expunged; see add_response_handler for a way to detect these events.

A Net::IMAP::NoResponseError is raised if the mailbox does not exist or is for some reason non-selectable.

Related: examine

Capabilities

If [UIDPLUS] is supported, the server may return an untagged “NO” response with a “UIDNOTSTICKY” response code indicating that the mailstore does not support persistent UIDs:

@responses["NO"].last.code.name == "UIDNOTSTICKY"
# File net-imap-0.3.4.1/lib/net/imap.rb, line 1099
def select(mailbox)
  synchronize do
    @responses.clear
    send_command("SELECT", mailbox)
  end
end
setacl(mailbox, user, rights) click to toggle source

Sends a SETACL command [RFC4314 §3.1] 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.

Related: getacl

Capabilities

The server’s capabilities must include ACL [RFC4314].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1392
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) click to toggle source

Sends a SETQUOTA command [RFC2087 §4.1] 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.

Related: getquota, getquotaroot

Capabilities

The server’s capabilities must include QUOTA [RFC2087].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1372
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) click to toggle source

Sends a SORT command [RFC5256 §3] to search a mailbox for messages that match search_keys and return an array of message sequence numbers, sorted by sort_keys. search_keys are interpreted the same as for search.

Related: uid_sort, search, uid_search, thread, uid_thread

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

The server’s capabilities must include SORT [RFC5256].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1829
def sort(sort_keys, search_keys, charset)
  return sort_internal("SORT", sort_keys, search_keys, charset)
end
starttls(options = {}, verify = true) click to toggle source

Sends a STARTTLS command [IMAP4rev1 §6.2.1] to start a TLS session.

Any options are forwarded to OpenSSL::SSL::SSLContext#set_params.

This method returns after TLS negotiation and hostname verification are both successful. Any error indicates that the connection has not been secured.

Note:

Any response_handlers added before STARTTLS should be aware that the TaggedResponse to STARTTLS is sent clear-text, before TLS negotiation. TLS negotiation starts immediately after that response.

Related: Net::IMAP.new, login, authenticate

Capability

The server’s capabilities must include STARTTLS.

Server capabilities may change after starttls, login, and authenticate. Cached capabilities must be invalidated after this method completes.

The TaggedResponse to starttls is sent clear-text, so the server must not send capabilities in the starttls response and clients must not use them if they are sent. Servers will generally send an unsolicited untagged response immeditely after starttls completes.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 940
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) click to toggle source

Sends a STATUS commands [IMAP4rev1 §6.3.10] 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.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1449
def status(mailbox, attr)
  synchronize do
    send_command("STATUS", mailbox, attr)
    return @responses.delete("STATUS")[-1].attr
  end
end
store(set, attr, flags) click to toggle source

Sends a STORE command [IMAP4rev1 §6.4.6] 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 FetchData

Related: uid_store

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 net-imap-0.3.4.1/lib/net/imap.rb, line 1719
def store(set, attr, flags)
  return store_internal("STORE", set, attr, flags)
end
subscribe(mailbox) click to toggle source

Sends a SUBSCRIBE command [IMAP4rev1 §6.3.6] 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.

Related: unsubscribe, lsub, list

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1166
def subscribe(mailbox)
  send_command("SUBSCRIBE", mailbox)
end
thread(algorithm, search_keys, charset) click to toggle source

Sends a THREAD command [RFC5256 §3] to search a mailbox and return message sequence numbers in threaded format, as a ThreadMember tree. search_keys are interpreted the same as for search.

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.

Related: uid_thread, search, uid_search, sort, uid_sort

Capabilities

The server’s capabilities must include THREAD [RFC5256].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1869
def thread(algorithm, search_keys, charset)
  return thread_internal("THREAD", algorithm, search_keys, charset)
end
uid_copy(set, mailbox) click to toggle source

Sends a UID COPY command [IMAP4rev1 §6.4.8] to copy the specified message(s) to the end of the specified destination mailbox.

Similar to copy, but set contains unique identifiers.

Capabilities

UIDPLUS affects uid_copy the same way it affects copy.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1762
def uid_copy(set, mailbox)
  copy_internal("UID COPY", set, mailbox)
end
uid_expunge(uid_set) click to toggle source

Sends a UID EXPUNGE command [RFC4315 §2.1] [IMAP4rev2 §6.4.9] to permanently remove all messages that have both the \Deleted flag set and a UID that is included in uid_set.

By using uid_expunge instead of expunge when resynchronizing with the server, the client can ensure that it does not inadvertantly remove any messages that have been marked as \Deleted by other clients between the time that the client was last connected and the time the client resynchronizes.

Note:

Although the command takes a set of UIDs for its argument, the server still returns regular EXPUNGE responses, which contain a sequence number. These will be deleted from responses and this method returns them as an array of sequence number integers.

Related: expunge

Capabilities

The server’s capabilities must include UIDPLUS [RFC4315].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1570
def uid_expunge(uid_set)
  synchronize do
    send_command("UID EXPUNGE", MessageSet.new(uid_set))
    return @responses.delete("EXPUNGE")
  end
end
uid_fetch(set, attr, mod = nil) click to toggle source

Sends a UID FETCH command [IMAP4rev1 §6.4.8] to retrieve data associated with a message in the mailbox.

Similar to fetch, but the set parameter contains unique identifiers instead of message sequence numbers.

Note: Servers MUST implicitly include the UID message data item as part of any FETCH response caused by a UID command, regardless of whether a UID was specified as a message data item to the FETCH.

Related: fetch, FetchData

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1697
def uid_fetch(set, attr, mod = nil)
  return fetch_internal("UID FETCH", set, attr, mod)
end
uid_move(set, mailbox) click to toggle source

Sends a UID MOVE command [RFC6851 §3.2] [IMAP4rev2 §6.4.9] to move the specified message(s) to the end of the specified destination mailbox.

Similar to move, but set contains unique identifiers.

Related: move

Capabilities

Same as move: The server’s capabilities must include MOVE [RFC6851]. UIDPLUS also affects uid_move the same way it affects move.

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1803
def uid_move(set, mailbox)
  copy_internal("UID MOVE", set, mailbox)
end
uid_sort(sort_keys, search_keys, charset) click to toggle source

Sends a UID SORT command [RFC5256 §3] to search a mailbox for messages that match search_keys and return an array of unique identifiers, sorted by sort_keys. search_keys are interpreted the same as for search.

Related: sort, search, uid_search, thread, uid_thread

Capabilities

The server’s capabilities must include SORT [RFC5256].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1844
def uid_sort(sort_keys, search_keys, charset)
  return sort_internal("UID SORT", sort_keys, search_keys, charset)
end
uid_store(set, attr, flags) click to toggle source

Sends a UID STORE command [IMAP4rev1 §6.4.8] to alter data associated with messages in the mailbox, in particular their flags.

Similar to store, but set contains unique identifiers instead of message sequence numbers.

Related: store

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1731
def uid_store(set, attr, flags)
  return store_internal("UID STORE", set, attr, flags)
end
uid_thread(algorithm, search_keys, charset) click to toggle source

Sends a UID THREAD command [RFC5256 §3] Similar to thread, but returns unique identifiers instead of message sequence numbers.

Related: thread, search, uid_search, sort, uid_sort

Capabilities

The server’s capabilities must include THREAD [RFC5256].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1883
def uid_thread(algorithm, search_keys, charset)
  return thread_internal("UID THREAD", algorithm, search_keys, charset)
end
unselect() click to toggle source

Sends an UNSELECT command [RFC3691 §2] [IMAP4rev2 §6.4.2] to free the session resources for a mailbox and return to the “authenticated” state. This is the same as close, except that \Deleted messages are not removed from the mailbox.

Related: close

Capabilities

The server’s capabilities must include UNSELECT [RFC3691].

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1529
def unselect
  send_command("UNSELECT")
end
unsubscribe(mailbox) click to toggle source

Sends an UNSUBSCRIBE command [IMAP4rev1 §6.3.7] 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.

Related: subscribe, lsub, list

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1179
def unsubscribe(mailbox)
  send_command("UNSUBSCRIBE", mailbox)
end
xlist(refname, mailbox) click to toggle source

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 MailboxList objects. 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">]

Related: list, MailboxList

Capabilities

The server’s capabilities must include XLIST, a deprecated Gmail extension (replaced by SPECIAL-USE).

# File net-imap-0.3.4.1/lib/net/imap.rb, line 1315
def xlist(refname, mailbox)
  synchronize do
    send_command("XLIST", refname, mailbox)
    return @responses.delete("XLIST")
  end
end

Private Instance Methods

copy_internal(cmd, set, mailbox) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2301
def copy_internal(cmd, set, mailbox)
  send_command(cmd, MessageSet.new(set), mailbox)
end
create_ssl_params(certs = nil, verify = true) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2340
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
fetch_internal(cmd, set, attr, mod = nil) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2269
def fetch_internal(cmd, set, attr, mod = nil)
  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")
    if mod
      send_command(cmd, MessageSet.new(set), attr, mod)
    else
      send_command(cmd, MessageSet.new(set), attr)
    end
    return @responses.delete("FETCH")
  end
end
generate_tag() click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2233
def generate_tag
  @tagno += 1
  return format("%s%04d", @tag_prefix, @tagno)
end
get_response() click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2178
def get_response
  buff = String.new
  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
get_tagged_response(tag, cmd, timeout = nil) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2151
def get_tagged_response(tag, cmd, timeout = nil)
  if timeout
    deadline = Time.now + timeout
  end
  until @tagged_responses.key?(tag)
    raise @exception if @exception
    if timeout
      timeout = deadline - Time.now
      if timeout <= 0
        return nil
      end
    end
    @tagged_response_arrival.wait(timeout)
  end
  resp = @tagged_responses.delete(tag)
  case resp.name
  when /\A(?:OK)\z/ni
    return resp
  when /\A(?:NO)\z/ni
    raise NoResponseError, resp
  when /\A(?:BAD)\z/ni
    raise BadResponseError, resp
  else
    raise UnknownResponseError, resp
  end
end
normalize_searching_criteria(keys) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2329
def normalize_searching_criteria(keys)
  keys.collect! do |i|
    case i
    when -1, Range, Array
      MessageSet.new(i)
    else
      i
    end
  end
end
put_string(str) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2238
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
receive_responses() click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2080
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
          case resp.tag
          when @logout_command_tag
            return
          when @continued_command_tag
            @continuation_request_exception =
              RESPONSE_ERRORS[resp.name].new(resp)
            @continuation_request_arrival.signal
          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
record_response(name, data) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2198
def record_response(name, data)
  unless @responses.has_key?(name)
    @responses[name] = []
  end
  @responses[name].push(data)
end
search_internal(cmd, keys, charset) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2253
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
send_command(cmd, *args, &block) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2205
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, tag)
    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
send_data(data, tag = nil) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 33
def send_data(data, tag = nil)
  case data
  when nil
    put_string("NIL")
  when String
    send_string_data(data, tag)
  when Integer
    send_number_data(data)
  when Array
    send_list_data(data, tag)
  when Date
    send_date_data(data)
  when Time, DateTime
    send_time_data(data)
  when Symbol
    send_symbol_data(data)
  else
    data.send_data(self, tag)
  end
end
send_date_data(date) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 108
def send_date_data(date) put_string Net::IMAP.encode_date(date) end
send_list_data(list, tag = nil) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 94
def send_list_data(list, tag = nil)
  put_string("(")
  first = true
  list.each do |i|
    if first
      first = false
    else
      put_string(" ")
    end
    send_data(i, tag)
  end
  put_string(")")
end
send_literal(str, tag = nil) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 73
def send_literal(str, tag = nil)
  synchronize do
    put_string("{" + str.bytesize.to_s + "}" + CRLF)
    @continued_command_tag = tag
    @continuation_request_exception = nil
    begin
      @continuation_request_arrival.wait
      e = @continuation_request_exception || @exception
      raise e if e
      put_string(str)
    ensure
      @continued_command_tag = nil
      @continuation_request_exception = nil
    end
  end
end
send_number_data(num) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 90
def send_number_data(num)
  put_string(num.to_s)
end
send_quoted_string(str) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 69
def send_quoted_string(str)
  put_string('"' + str.gsub(/["\\]/n, "\\\\\\&") + '"')
end
send_string_data(str, tag = nil) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 54
def send_string_data(str, tag = nil)
  case str
  when ""
    put_string('""')
  when /[\x80-\xff\r\n]/n
    # literal
    send_literal(str, tag)
  when /[(){ \x00-\x1f\x7f%*"\\]/n
    # quoted string
    send_quoted_string(str)
  else
    put_string(str)
  end
end
send_symbol_data(symbol) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 111
def send_symbol_data(symbol)
  put_string("\\" + symbol.to_s)
end
send_time_data(time) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 109
def send_time_data(time) put_string Net::IMAP.encode_time(time) end
sort_internal(cmd, sort_keys, search_keys, charset) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2305
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
start_tls_session(params = {}) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2357
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.hostname = @host if @sock.respond_to? :hostname=
  ssl_socket_connect(@sock, @open_timeout)
  if context.verify_mode != VERIFY_NONE
    @sock.post_connection_check(@host)
  end
end
store_internal(cmd, set, attr, flags) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2290
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
tcp_socket(host, port) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2071
def tcp_socket(host, port)
  s = Socket.tcp(host, port, :connect_timeout => @open_timeout)
  s.setsockopt(:SOL_SOCKET, :SO_KEEPALIVE, true)
  s
rescue Errno::ETIMEDOUT
  raise Net::OpenTimeout, "Timeout to open TCP connection to " +
    "#{host}:#{port} (exceeds #{@open_timeout} seconds)"
end
thread_internal(cmd, algorithm, search_keys, charset) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap.rb, line 2318
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
validate_data(data) click to toggle source
# File net-imap-0.3.4.1/lib/net/imap/command_data.rb, line 12
def validate_data(data)
  case data
  when nil
  when String
  when Integer
    NumValidator.ensure_number(data)
  when Array
    if data[0] == 'CHANGEDSINCE'
      NumValidator.ensure_mod_sequence_value(data[1])
    else
      data.each do |i|
        validate_data(i)
      end
    end
  when Time, Date, DateTime
  when Symbol
  else
    data.validate
  end
end

Basic Mailbox Attributes

↑ top

Constants

HASCHILDREN

Alias for HAS_CHILDREN, to match the IMAP spelling.

HASNOCHILDREN

Alias for HAS_NO_CHILDREN, to match the IMAP spelling.

HAS_CHILDREN

The presence of this attribute indicates that the mailbox has child mailboxes. A server SHOULD NOT set this attribute if there are child mailboxes and the user does not have permission to access any of them. In this case, \HasNoChildren SHOULD be used. In many cases, however, a server may not be able to efficiently compute whether a user has access to any child mailboxes. Note that even though the \HasChildren attribute for a mailbox must be correct at the time of processing the mailbox, a client must be prepared to deal with a situation when a mailbox is marked with the \HasChildren attribute, but no child mailbox appears in the response to the list command. This might happen, for example, due to child mailboxes being deleted or made inaccessible to the user (using access control) by another client before the server is able to list them.

It is an error for the server to return both a \HasChildren and a \HasNoChildren attribute in the same list response. A client that encounters a list response with both \HasChildren and \HasNoChildren attributes present should act as if both are absent in the list response.

HAS_NO_CHILDREN

The presence of this attribute indicates that the mailbox has NO child mailboxes that are accessible to the currently authenticated user.

It is an error for the server to return both a \HasChildren and a \HasNoChildren attribute in the same list response. A client that encounters a list response with both \HasChildren and \HasNoChildren attributes present should act as if both are absent in the list response.

Note: the \HasNoChildren attribute should not be confused with the \NoInferiors attribute, which indicates that no child mailboxes exist now and none can be created in the future.

MARKED

The mailbox has been marked “interesting” by the server; the mailbox probably contains messages that have been added since the last time the mailbox was selected.

If it is not feasible for the server to determine whether or not the mailbox is “interesting”, the server SHOULD NOT send either \Marked or \Unmarked. The server MUST NOT send more than one of \Marked, \Unmarked, and \NoSelect for a single mailbox, and it MAY send none of these.

NOINFERIORS

Alias for NO_INFERIORS, to match the IMAP spelling.

NONEXISTENT

The \NonExistent attribute indicates that a mailbox name does not refer to an existing mailbox. Note that this attribute is not meaningful by itself, as mailbox names that match the canonical list pattern but don’t exist must not be returned unless one of the two conditions listed below is also satisfied:

  1. The mailbox name also satisfies the selection criteria (for example, it is subscribed and the “SUBSCRIBED” selection option has been specified).

  2. “RECURSIVEMATCH” has been specified, and the mailbox name has at least one descendant mailbox name that does not match the list pattern and does match the selection criteria.

In practice, this means that the \NonExistent attribute is usually returned with one or more of \Subscribed, \Remote, \HasChildren, or the CHILDINFO extended data item.

The client must treat the presence of the \NonExistent attribute as if the \NoSelect attribute was also sent by the server

NOSELECT

Alias for NO_SELECT, to match the IMAP spelling.

NO_INFERIORS

Mailbox attribute indicating it is not possible for any child levels of hierarchy to exist under this name; no child levels exist now and none can be created in the future children.

The client must treat the presence of the \NoInferiors attribute as if the \HasNoChildren attribute was also sent by the server

NO_SELECT

Mailbox attribute indicating it is not possible to use this name as a selectable mailbox.

REMOTE

The mailbox is a remote mailbox.

SUBSCRIBED

The mailbox name was subscribed to using the subscribe command.

UNMARKED

The mailbox does not contain any additional messages since the last time the mailbox was selected.

If it is not feasible for the server to determine whether or not the mailbox is “interesting”, the server SHOULD NOT send either \Marked or \Unmarked. The server MUST NOT send more than one of \Marked, \Unmarked, and \NoSelect for a single mailbox, and it MAY send none of these.

Mailbox role attributes

↑ top

Constants

ALL

Mailbox attribute indicating that this mailbox presents all messages in the user’s message store. Implementations MAY omit some messages, such as, perhaps, those in Trash and Junk. When this special use is supported, it is almost certain to represent a virtual mailbox

ARCHIVE

Mailbox attribute indicating that this mailbox is used to archive messages. The meaning of an “archival” mailbox is server dependent; typically, it will be used to get messages out of the inbox, or otherwise keep them out of the user’s way, while still making them accessible

DRAFTS

Mailbox attribute indicating that this mailbox is used to hold draft messages – typically, messages that are being composed but have not yet been sent. In some server implementations, this might be a virtual mailbox, containing messages from other mailboxes that are marked with the “Draft” message flag. Alternatively, this might just be advice that a client put drafts here

JUNK

Mailbox attribute indicating that this mailbox is where messages deemed to be junk mail are held. Some server implementations might put messages here automatically. Alternatively, this might just be advice to a client-side spam filter.

SENT

Mailbox attribute indicating that this mailbox is used to hold copies of messages that have been sent. Some server implementations might put messages here automatically. Alternatively, this might just be advice that a client save sent messages here.

TRASH

Mailbox attribute indicating that this mailbox is used to hold messages that have been deleted or marked for deletion. In some server implementations, this might be a virtual mailbox, containing messages from other mailboxes that are marked with the \Deleted message flag. Alternatively, this might just be advice that a client that chooses not to use the IMAP \Deleted model should use as its trash location. In server implementations that strictly expect the IMAP \Deleted model, this special use is likely not to be supported.

System Flags

↑ top

Constants

ANSWERED

Flag indicating a message has been answered.

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.

FLAGGED

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

Also a mailbox special use attribute, which indicates that this mailbox presents all messages marked in some way as “important”. When this special use is supported, it is likely to represent a virtual mailbox collecting messages (from other mailboxes) that are marked with the “Flagged” message flag.

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.

This flag was defined by IMAP4rev1 and is deprecated by IMAP4rev2.

SEEN

Flag indicating a message has been read.