class Net::IMAP

# File lib/net/imap.rb, line 766
def self.config; Config.global end

Returns the global Config object

# File lib/net/imap.rb, line 769
def self.debug; config.debug end

Returns the global debug mode.

# File lib/net/imap.rb, line 772
def self.debug=(val)
  config.debug = val
end

Sets the global debug mode.

# File lib/net/imap/data_encoding.rb, line 90
def self.decode_date(string)
  string = string.delete_prefix('"').delete_suffix('"')
  Date.strptime(string, STRFDATE)
end

Decodes string as an IMAP formatted “date”.

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

# File lib/net/imap/data_encoding.rb, line 112
def self.decode_datetime(string)
  unless string.start_with?(?") && string.end_with?(?")
    string = '"%s"' % [string]
  end
  DateTime.strptime(string, STRFTIME)
end

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

NOTE: Although double-quotes are not optional in the IMAP grammar, Net::IMAP currently parses “date-time” values as “quoted” strings and this removes the quotation marks. To be useful for strings which have already been parsed as a quoted string, this method makes double-quotes optional.

See STRFTIME.

# File lib/net/imap/data_encoding.rb, line 124
def self.decode_time(string)
  unless string.start_with?(?") && string.end_with?(?")
    string = '"%s"' % [string]
  end
  Time.strptime(string, STRFTIME)
end

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

Same as decode_datetime, but returning a Time instead.

# File lib/net/imap/data_encoding.rb, line 57
def self.decode_utf7(s)
  return s.gsub(/&([A-Za-z0-9+,]+)?-/n) {
    if base64 = $1
      (base64.tr(",", "/") + "===").unpack1("m").encode(Encoding::UTF_8, Encoding::UTF_16BE)
    else
      "&"
    end
  }
end

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

UTF-7 is a 7-bit encoding of Unicode [UTF7]. IMAP uses a slightly modified version of this to encode mailbox names containing non-ASCII characters; see [IMAP] section 5.1.3.

Net::IMAP does not automatically encode and decode mailbox names to and from UTF-7.

# File lib/net/imap.rb, line 777
def self.default_port
  return PORT
end

The default port for IMAP connections, port 143

# File lib/net/imap.rb, line 782
def self.default_tls_port
  return SSL_PORT
end

The default port for IMAPS connections, port 993

# File lib/net/imap/data_encoding.rb, line 80
def self.encode_date(date)
  date.to_date.strftime STRFDATE
end

Formats time as an IMAP4 date.

# File lib/net/imap/data_encoding.rb, line 98
def self.encode_datetime(time)
  time.to_datetime.strftime STRFTIME
end

Formats time as an IMAP4 date-time.

# File lib/net/imap/data_encoding.rb, line 68
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

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

# File lib/net/imap/data_encoding.rb, line 149
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

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

# File lib/net/imap.rb, line 934
def initialize(host, port: nil, ssl:  nil,
               config: Config.global, **config_options)
  super()
  # Config options
  @host = host
  @config = Config.new(config, **config_options)
  @port = port || (ssl ? SSL_PORT : PORT)
  @ssl_ctx_params, @ssl_ctx = build_ssl_ctx(ssl)

  # Basic Client State
  @utf8_strings = false
  @debug_output_bol = true
  @exception = nil
  @greeting = nil
  @capabilities = nil

  # Client Protocol Receiver
  @parser = ResponseParser.new(config: @config)
  @responses = Hash.new {|h, k| h[k] = [] }
  @response_handlers = []
  @receiver_thread = nil
  @receiver_thread_exception = nil
  @receiver_thread_terminating = false

  # Client Protocol Sender (including state for currently running commands)
  @tag_prefix = "RUBY"
  @tagno = 0
  @tagged_responses = {}
  @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

  # Connection
  @tls_verified = false
  @sock = tcp_socket(@host, @port)
  start_tls_session if ssl_ctx
  start_imap_connection
end

Creates a new Net::IMAP object and connects it to the specified host.

Options¶ ↑

Accepts the following options:

port

Port number. Defaults to 993 when ssl is truthy, and 143 otherwise.

ssl

If true, the connection will use TLS with the default params set by OpenSSL::SSL::SSLContext#set_params. If ssl is a hash, it’s passed to OpenSSL::SSL::SSLContext#set_params; the keys are names of attribute assignment methods on SSLContext. For example:

ca_file

The path to a file containing a PEM-format CA certificate.

ca_path

The path to a directory containing CA certificates in PEM format.

min_version

Sets the lower bound on the supported SSL/TLS protocol version. Set to an OpenSSL constant such as OpenSSL::SSL::TLS1_2_VERSION,

verify_mode

SSL session verification mode. Valid modes include OpenSSL::SSL::VERIFY_PEER and OpenSSL::SSL::VERIFY_NONE.

See OpenSSL::SSL::SSLContext for other valid SSL context params.

See DeprecatedClientOptions.new for deprecated SSL arguments.

config

A Net::IMAP::Config object to use as the basis for config. By default, the global Net::IMAP.config is used.

NOTE: config does not set config directly—it sets the parent config for inheritance. Every client creates its own unique config.

All other keyword arguments are forwarded to Net::IMAP::Config.new, to initialize the client’s config. For example:

open_timeout

Seconds to wait until a connection is opened

idle_response_timeout

Seconds to wait until an IDLE response is received

See Net::IMAP::Config for other valid options.

Examples¶ ↑

Connect to cleartext port 143 at mail.example.com and receive the server greeting:

imap = Net::IMAP.new('mail.example.com', ssl: false) # => #<Net::IMAP:0x00007f79b0872bd0>
imap.port          => 143
imap.tls_verified? => false
imap.greeting      => name: ("OK" | "PREAUTH") => status
status # => "OK"
# The client is connected in the "Not Authenticated" state.

Connect with TLS to port 993

imap = Net::IMAP.new('mail.example.com', ssl: true) # => #<Net::IMAP:0x00007f79b0872bd0>
imap.port          => 993
imap.tls_verified? => true
imap.greeting      => name: (/OK/i | /PREAUTH/i) => status
case status
in /OK/i
  # The client is connected in the "Not Authenticated" state.
  imap.authenticate("PLAIN", "joe_user", "joes_password")
in /PREAUTH/i
  # The client is connected in the "Authenticated" state.
end

Connect with prior authentication, for example using an SSL certificate:

ssl_ctx_params = {
  cert: OpenSSL::X509::Certificate.new(File.read("client.crt")),
  key:  OpenSSL::PKey::EC.new(File.read('client.key')),
  extra_chain_cert: [
    OpenSSL::X509::Certificate.new(File.read("intermediate.crt")),
  ],
}
imap = Net::IMAP.new('mail.example.com', ssl: ssl_ctx_params)
imap.port          => 993
imap.tls_verified? => true
imap.greeting      => name: "PREAUTH"
# The client is connected in the "Authenticated" state.

Exceptions¶ ↑

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

Connected to the host successfully, but it immediately said goodbye.

# File lib/net/imap.rb, line 3634
def self.saslprep(string, **opts)
  Net::IMAP::StringPrep::SASLprep.saslprep(string, **opts)
end

Delegates to Net::IMAP::StringPrep::SASLprep#saslprep.

# File lib/net/imap.rb, line 3142
def add_response_handler(handler = nil, &block)
  raise ArgumentError, "two Procs are passed" if handler && block
  synchronize do
    @response_handlers.push(block || handler)
  end
end

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
}

Related: remove_response_handler, response_handlers

# File lib/net/imap.rb, line 1867
def append(mailbox, message, flags = nil, date_time = nil)
  args = []
  if flags
    args.push(flags)
  end
  args.push(date_time) if date_time
  args.push(Literal.new(message))
  send_command("APPEND", mailbox, *args)
end

Sends an 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 lib/net/imap.rb, line 1078
def auth_capable?(mechanism)
  capable? "AUTH=#{mechanism}"
end

Returns whether the server supports a given SASL mechanism for use with the authenticate command. The mechanism is supported when capabilities includes "AUTH=#{mechanism.to_s.upcase}". When available, cached capabilities are used without sending a new capability command to the server.

imap.capable?      "AUTH=PLAIN"  # => true
imap.auth_capable? "PLAIN"       # => true
imap.auth_capable? "blurdybloop" # => false

Related: authenticate, auth_mechanisms, capable?, capabilities

# File lib/net/imap.rb, line 1061
def auth_mechanisms
  capabilities
    .grep(/\AAUTH=/i)
    .map { _1.delete_prefix("AUTH=") }
end

Returns the authenticate mechanisms that the server claims to support. These are derived from the capabilities with an AUTH= prefix.

This may be different when the connection is cleartext or using TLS. Most servers will drop all AUTH= mechanisms from capabilities after the connection has authenticated.

imap = Net::IMAP.new(hostname, ssl: false)
imap.capabilities    # => ["IMAP4REV1", "LOGINDISABLED"]
imap.auth_mechanisms # => []

imap.starttls
imap.capabilities    # => ["IMAP4REV1", "AUTH=PLAIN", "AUTH=XOAUTH2",
                     #     "AUTH=OAUTHBEARER"]
imap.auth_mechanisms # => ["PLAIN", "XOAUTH2", "OAUTHBEARER"]

imap.authenticate("XOAUTH2", username, oauth2_access_token)
imap.auth_mechanisms # => []

Related: authenticate, auth_capable?, capabilities

# File lib/net/imap.rb, line 1361
def authenticate(*args, sasl_ir: config.sasl_ir, **props, &callback)
  sasl_adapter.authenticate(*args, sasl_ir: sasl_ir, **props, &callback)
    .tap { @capabilities = capabilities_from_resp_code _1 }
end

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.

sasl_ir allows or disallows sending an “initial response” (see the SASL-IR capability, below). Defaults to the config value for sasl_ir, which defaults to true.

The registry kwarg can be used to select the mechanism implementation from a custom registry. See SASL.authenticator and SASL::Authenticators.

All other arguments are forwarded to the registered SASL authenticator for the requested mechanism. The documentation for each individual mechanism must be consulted for its specific parameters.

Related: login, starttls, auth_capable?, auth_mechanisms

Mechanisms¶ ↑

Each mechanism has different properties and requirements. Please consult the documentation for the specific mechanisms you are using:

See the SASL mechanism registry for a list of all SASL mechanisms and their specifications. To register new authenticators, see Authenticators.

Deprecated mechanisms¶ ↑

Obsolete mechanisms should be avoided, but are still available for backwards compatibility. See Deprecated mechanisms at Net::IMAP::SASL. Using a deprecated mechanism will print a warning.

Capabilities¶ ↑

"AUTH=#{mechanism}" capabilities indicate server support for mechanisms. Use auth_capable? or auth_mechanisms to check for support before using a particular mechanism.

if imap.auth_capable? "XOAUTH2"
  imap.authenticate "XOAUTH2", username, oauth2_access_token
elsif imap.auth_capable? "PLAIN"
  imap.authenticate "PLAIN", username, password
elsif !imap.capability? "LOGINDISABLED"
  imap.login username, password
else
  raise "No acceptable authentication mechanism is available"
end

Although servers should list all supported SASL mechanisms, they may allow authentication with an unlisted mechanism.

If [SASL-IR] is supported and the appropriate "AUTH=#{mechanism}" capability is present, an “initial response” may be sent as an argument to the AUTHENTICATE command, saving a round-trip. The SASL exchange allows for server challenges and client responses, but many mechanisms expect the client to “respond” first. The initial response will only be sent for “client-first” mechanisms.

Server capabilities may change after starttls, login, and authenticate. Previously cached capabilities will be cleared when this method completes. If the TaggedResponse to authenticate includes updated capabilities, they will be cached.

# File lib/net/imap.rb, line 1037
def capabilities
  @capabilities || capability
end

Returns the server capabilities. When available, cached capabilities are used without sending a new capability command to the server.

To ensure a case-insensitive comparison, capable? can be used instead.

NOTE: Most Net::IMAP methods do not currently modify their behaviour according to the server’s advertised #capabilities.

See Capabilities at Net::IMAP for more about IMAP capabilities.

Related: capable?, auth_capable?, auth_mechanisms, capability, enable

# File lib/net/imap.rb, line 1088
def capabilities_cached?
  !!@capabilities
end

Returns whether capabilities have been cached. When true, capable? and capabilities don’t require sending a capability command to the server.

See Capabilities at Net::IMAP for more about IMAP capabilities.

Related: capable?, capability, clear_cached_capabilities

# File lib/net/imap.rb, line 1126
def capability
  synchronize do
    send_command("CAPABILITY")
    @capabilities = clear_responses("CAPABILITY").last.freeze
  end
end

Sends a CAPABILITY command [IMAP4rev1 §6.1.1] and returns an array of capabilities that are supported by the server. The result is stored for use by capable? and capabilities.

NOTE: Most Net::IMAP methods do not currently modify their behaviour according to the server’s advertised #capabilities.

Net::IMAP automatically stores and discards capability data according to the requirements and recommendations in IMAP4rev2 §6.1.1, §6.2, and §7.1. Use capable?, auth_capable?, or capabilities to this cache and avoid sending the capability command unnecessarily.

See Capabilities at Net::IMAP for more about IMAP capabilities.

Related: capable?, auth_capable?, capability, enable

# File lib/net/imap.rb, line 1023
def capable?(capability) capabilities.include? capability.to_s.upcase end

Returns whether the server supports a given capability. When available, cached capabilities are used without sending a new capability command to the server.

NOTE: Most Net::IMAP methods do not currently modify their behaviour according to the server’s advertised #capabilities.

See Capabilities at Net::IMAP for more about IMAP capabilities.

Related: auth_capable?, capabilities, capability, enable

# File lib/net/imap.rb, line 1883
def check
  send_command("CHECK")
end

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 lib/net/imap.rb, line 1101
def clear_cached_capabilities
  synchronize do
    clear_responses("CAPABILITY")
    @capabilities = nil
  end
end

Clears capabilities that have been remembered by the Net::IMAP client. This forces a capability command to be sent the next time a capabilities query method is called.

Net::IMAP automatically discards its cached capabilities when they can change. Explicitly calling this should be unnecessary for well-behaved servers.

Related: capable?, capability, capabilities_cached?

# File lib/net/imap.rb, line 3075
def clear_responses(type = nil)
  synchronize {
    if type
      @responses.delete(type) || []
    else
      @responses.dup.transform_values(&:freeze)
        .tap { _1.default = [].freeze }
        .tap { @responses.clear }
    end
  }
    .freeze
end

Clears and returns the unhandled responses hash or the unhandled responses array for a single response type.

Clearing responses is synchronized with other threads. The lock is released before returning.

Related: extract_responses, responses, response_handlers

# File lib/net/imap.rb, line 1893
def close
  send_command("CLOSE")
end

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 lib/net/imap.rb, line 2620
def copy(set, mailbox)
  copy_internal("COPY", set, mailbox)
end

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.

When UIDONLY is enabled, the COPY command is prohibited. Use uid_copy instead.

# File lib/net/imap.rb, line 1467
def create(mailbox)
  send_command("CREATE", mailbox)
end

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 lib/net/imap.rb, line 1479
def delete(mailbox)
  send_command("DELETE", mailbox)
end

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 lib/net/imap.rb, line 984
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

Disconnects from the server.

Related: logout, logout!

# File lib/net/imap.rb, line 1009
def disconnected?
  return @sock.closed?
end

Returns true if disconnected from the server.

Related: logout, disconnect

# File lib/net/imap.rb, line 2850
def enable(*capabilities)
  capabilities = capabilities
    .flatten
    .map {|e| ENABLE_ALIASES[e] || e }
    .uniq
    .join(' ')
  synchronize do
    send_command("ENABLE #{capabilities}")
    result = clear_responses("ENABLED").last || []
    @utf8_strings ||= result.include? "UTF8=ACCEPT"
    @utf8_strings ||= result.include? "IMAP4REV2"
    result
  end
end

Sends an ENABLE command [RFC5161 §3.2] [IMAP4rev2 §6.3.1] to enable the specified server capabilities. Each capability may be an array, string, or symbol. Returns a list of the capabilities that were enabled.

The ENABLE command is only valid in the authenticated state, before any mailbox is selected.

Related: capable?, capabilities, capability

Capabilities¶ ↑

The server’s capabilities must include ENABLE [RFC5161] or IMAP4REV2 [RFC9051].

Additionally, the server capabilities must include a capability matching each enabled extension (usually the same name as the enabled extension). The following capabilities may be enabled:

CONDSTORE [RFC7162]

Updates various commands to return CONDSTORE extension responses. It is not necessary to explicitly enable CONDSTORE—using any of the command parameters defined by the extension will implicitly enable it. See [RFC7162 §3.1].

:utf8 — an alias for "UTF8=ACCEPT"

In a future release, enable(:utf8) will enable either "UTF8=ACCEPT" or "IMAP4rev2", depending on server capabilities.

"UTF8=ACCEPT" [RFC6855]

The server’s capabilities must include UTF8=ACCEPT or UTF8=ONLY.

This allows the server to send strings encoded as UTF-8 which might otherwise need to use a 7-bit encoding, such as modified UTF-7 for mailbox names, or RFC2047 encoded-words for message headers.

Note: A future update may set string encodings slightly differently, e.g: “US-ASCII” when UTF-8 is not enabled, and “UTF-8” when it is. Currently, the encoding of strings sent as “quoted” or “text” will always be “UTF-8”, even when only ASCII characters are used (e.g. “Subject: Agenda”) And currently, string “literals” sent by the server will always have an “ASCII-8BIT” (binary) encoding, even if they generally contain UTF-8 data, if they are text at all.

"UTF8=ONLY" [RFC6855]

A server that reports the UTF8=ONLY capability requires that the client enable("UTF8=ACCEPT") before any mailboxes may be selected. For convenience, enable("UTF8=ONLY") is aliased to enable("UTF8=ACCEPT").

UIDONLY [RFC9586]

When UIDONLY is enabled, the fetch, store, search, copy, and move commands are prohibited and result in a tagged BAD response. Clients should instead use uid_fetch, uid_store, uid_search, uid_copy, or uid_move, respectively. All FETCH responses that would be returned are replaced by UIDFETCH responses. All EXPUNGED responses that would be returned are replaced by VANISHED responses. The “<sequence set>” uid_search criterion is prohibited.

Unsupported capabilities¶ ↑

Note: Some extensions that use ENABLE permit the server to send syntax that Net::IMAP cannot parse, which may raise an exception and disconnect. Some extensions may work, but the support may be incomplete, untested, or experimental.

Until a capability is documented here as supported, enabling it may result in undocumented behavior and a future release may update with incompatible behavior without warning or deprecation.

Caution is advised.

# File lib/net/imap.rb, line 1451
def examine(mailbox, condstore: false)
  args = ["EXAMINE", mailbox]
  args << ["CONDSTORE"] if condstore
  synchronize do
    @responses.clear
    send_command(*args)
  end
end

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 lib/net/imap.rb, line 1939
def expunge
  expunge_internal("EXPUNGE")
end

Sends an EXPUNGE command [IMAP4rev1 §6.4.3] to permanently remove all messages with the \Deleted flag from the currently selected mailbox.

Returns either an array of expunged message sequence numbers or (when the appropriate capability is enabled) VanishedData of expunged UIDs. Previously unhandled EXPUNGE or VANISHED responses are merged with the direct response to this command. VANISHED (EARLIER) responses will not be merged.

When no messages have been expunged, an empty array is returned, regardless of which extensions are enabled. In a future release, an empty VanishedData may be returned, based on the currently enabled extensions.

Related: uid_expunge

Capabilities¶ ↑

When either QRESYNC or UIDONLY are enabled, expunge returns VanishedData, which contains UIDs—not message sequence numbers.

# File lib/net/imap.rb, line 3099
def extract_responses(type)
  type = String.try_convert(type) or
    raise ArgumentError, "type must be a string"
  raise ArgumentError, "must provide a block" unless block_given?
  extracted = []
  responses(type) do |all|
    all.reject! do |response|
      extracted << response if yield response
    end
  end
  extracted
end

Yields all of the unhandled responses for a single response type. Removes and returns the responses for which the block returns a true value.

Extracting responses is synchronized with other threads. The lock is released before returning.

Related: responses, clear_responses

# File lib/net/imap.rb, line 2464
def fetch(...)
  fetch_internal("FETCH", ...)
end

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

set is the message sequence numbers to fetch, and may be any valid input to SequenceSet[…]. (For UIDs, use uid_fetch instead.)

attr is a list of attributes to fetch; see FetchStruct documentation for a list of supported attributes.

changedsince is an optional integer mod-sequence. It limits results to messages with a mod-sequence greater than changedsince.

The return value is an array of FetchData.

Related: uid_fetch, 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

Capabilities¶ ↑

Many extensions define new message attr names. See FetchStruct for a list of supported extension fields.

The server’s capabilities must include CONDSTORE [RFC7162] in order to use the changedsince argument. Using changedsince implicitly enables the CONDSTORE extension.

When UIDONLY is enabled, the FETCH command is prohibited. Use uid_fetch instead.

# File lib/net/imap.rb, line 1747
def getacl(mailbox)
  synchronize do
    send_command("GETACL", mailbox)
    clear_responses("ACL").last
  end
end

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 lib/net/imap.rb, line 1691
def getquota(mailbox)
  synchronize do
    send_command("GETQUOTA", mailbox)
    clear_responses("QUOTA")
  end
end

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 lib/net/imap.rb, line 1670
def getquotaroot(mailbox)
  synchronize do
    send_command("GETQUOTAROOT", mailbox)
    result = []
    result.concat(clear_responses("QUOTAROOT"))
    result.concat(clear_responses("QUOTA"))
    return result
  end
end

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 lib/net/imap.rb, line 1155
def id(client_id=nil)
  synchronize do
    send_command("ID", ClientID.new(client_id))
    clear_responses("ID").last
  end
end

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:

if capable?(: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 lib/net/imap.rb, line 2894
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

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 |response|
    do_something_with(response)
    imap.idle_done if some_condition?(response)
  end
end

Returns the server’s response to indicate the IDLE state has ended. Returns nil if the server does not respond to idle_done within config.idle_response_timeout seconds.

Related: idle_done, noop, check

Capabilities¶ ↑

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

# File lib/net/imap.rb, line 2930
def idle_done
  synchronize do
    if @idle_done_cond.nil?
      raise Net::IMAP::Error, "not during IDLE"
    end
    @idle_done_cond.signal
  end
end

Leaves IDLE, allowing idle to return.

If the server does not respond within config.idle_response_timeout seconds, idle will return nil.

Related: idle

# File lib/net/imap.rb, line 807
def idle_response_timeout; config.idle_response_timeout end

Seconds to wait until an IDLE response is received.

# File lib/net/imap.rb, line 1551
def list(refname, mailbox)
  synchronize do
    send_command("LIST", refname, mailbox)
    clear_responses("LIST")
  end
end

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 lib/net/imap.rb, line 1392
def login(user, password)
  if enforce_logindisabled? && capability?("LOGINDISABLED")
    raise LoginDisabledError
  end
  send_command("LOGIN", user, password)
    .tap { @capabilities = capabilities_from_resp_code _1 }
end

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 should be 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¶ ↑

An IMAP client MUST NOT call login when the server advertises the LOGINDISABLED capability. By default, Net::IMAP will raise a LoginDisabledError when that capability is present. See Config#enforce_logindisabled.

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 lib/net/imap.rb, line 1183
def logout
  send_command("LOGOUT")
end

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, logout!

# File lib/net/imap.rb, line 1200
def logout!
  logout unless disconnected?
rescue => ex
  warn "%s during <Net::IMAP %s:%s> logout!: %s" % [
    ex.class, host, port, ex
  ]
ensure
  disconnect
end

Calls logout then, after receiving the TaggedResponse for the LOGOUT, calls disconnect. Returns the TaggedResponse from LOGOUT. Returns nil when the client is already disconnected, in contrast to logout which raises an exception.

If logout raises a StandardError, a warning will be printed but the exception will not be re-raised.

This is useful in situations where the connection must be dropped, for example for security or after tests. If logout errors need to be handled, use logout and disconnect instead.

Related: logout, disconnect

# File lib/net/imap.rb, line 1762
def lsub(refname, mailbox)
  synchronize do
    send_command("LSUB", refname, mailbox)
    clear_responses("LSUB")
  end
end

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 lib/net/imap.rb, line 2661
def move(set, mailbox)
  copy_internal("MOVE", set, mailbox)
end

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 either IMAP4rev2 or 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.

When UIDONLY is enabled, the MOVE command is prohibited. Use uid_move instead.

# File lib/net/imap.rb, line 1608
def namespace
  synchronize do
    send_command("NAMESPACE")
    clear_responses("NAMESPACE").last
  end
end

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:¶ ↑

if capable?("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 either IMAP4rev2 or NAMESPACE [RFC2342].

# File lib/net/imap.rb, line 1174
def noop
  send_command("NOOP")
end

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:

• EXPUNGE can only be sent while a command is in progress.

• EXPUNGE must not be sent during fetch, store, or search.

• EXPUNGE may be sent during uid_fetch, uid_store, or uid_search.

Related: idle, check

# File lib/net/imap.rb, line 804
def open_timeout; config.open_timeout end

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.

# File lib/net/imap.rb, line 3152
def remove_response_handler(handler)
  synchronize do
    @response_handlers.delete(handler)
  end
end

Removes the response handler.

Related: add_response_handler, response_handlers

# File lib/net/imap.rb, line 1492
def rename(mailbox, newname)
  send_command("RENAME", mailbox, newname)
end

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 lib/net/imap.rb, line 3125
def response_handlers
  synchronize { @response_handlers.clone.freeze }
end

Returns all response handlers, including those that are added internally by commands. Each response handler will be called with every new UntaggedResponse, TaggedResponse, and ContinuationRequest.

Response handlers are called with a mutex inside the receiver thread. New responses cannot be processed and commands from other threads must wait until all response_handlers return. An exception will shut-down the receiver thread and close the connection.

For thread-safety, the returned array is a frozen copy of the internal array.

Related: add_response_handler, remove_response_handler

# File lib/net/imap.rb, line 3041
def responses(type = nil)
  if block_given?
    synchronize { yield(type ? @responses[type.to_s.upcase] : @responses) }
  elsif type
    synchronize { @responses[type.to_s.upcase].dup.freeze }
  else
    case config.responses_without_block
    when :raise
      raise ArgumentError, RESPONSES_DEPRECATION_MSG
    when :warn
      warn(RESPONSES_DEPRECATION_MSG, uplevel: 1, category: :deprecated)
    when :frozen_dup
      synchronize {
        responses = @responses.transform_values(&:freeze)
        responses.default_proc = nil
        responses.default = [].freeze
        return responses.freeze
      }
    end
    @responses
  end
end

Yields or returns unhandled server responses. Unhandled responses are stored in a hash, with arrays of UntaggedResponse#data keyed by UntaggedResponse#name and non-nil untagged ResponseCode#data keyed by ResponseCode#name.

When a block is given, yields unhandled responses and returns the block’s result. Without a block, returns the unhandled responses.

With type

Yield or return only the array of responses for that type. When no block is given, the returned array is a frozen copy.

Without type

Yield or return the entire responses hash.

When no block is given, the behavior is determined by Config#responses_without_block:

:silence_deprecation_warning (original behavior)

Returns the mutable responses hash (without any warnings). This is not thread-safe.

:warn (default since v0.5)

Prints a warning and returns the mutable responses hash. This is not thread-safe.

:frozen_dup (planned default for v0.6)

Returns a frozen copy of the unhandled responses hash, with frozen array values.

:raise

Raise an ArgumentError with the deprecation warning.

For example:

imap.select("inbox")
p imap.responses("EXISTS").last
#=> 2
p imap.responses("UIDNEXT", &:last)
#=> 123456
p imap.responses("UIDVALIDITY", &:last)
#=> 968263756
p imap.responses {|responses|
  {
    exists:      responses.delete("EXISTS").last,
    uidnext:     responses.delete("UIDNEXT").last,
    uidvalidity: responses.delete("UIDVALIDITY").last,
  }
}
#=> {:exists=>2, :uidnext=>123456, :uidvalidity=>968263756}
# "EXISTS", "UIDNEXT", and "UIDVALIDITY" have been removed:
p imap.responses(&:keys)
#=> ["FLAGS", "OK", "PERMANENTFLAGS", "RECENT", "HIGHESTMODSEQ"]

Related: extract_responses, clear_responses, response_handlers, greeting

Thread safety¶ ↑

Note: Access to the responses hash is synchronized for thread-safety. The receiver thread and response_handlers cannot process new responses until the block completes. Accessing either the response hash or its response type arrays outside of the block is unsafe. They can be safely updated inside the block. Consider using clear_responses or extract_responses instead.

Net::IMAP will add and remove responses from the responses hash and its array values, in the calling threads for commands and in the receiver thread, but will not modify any responses after adding them to the responses hash.

Clearing responses¶ ↑

Previously unhandled responses are automatically cleared before entering a mailbox with select or examine. Long-lived connections can receive many unhandled server responses, which must be pruned or they will continually consume more memory. Update or clear the responses hash or arrays inside the block, or remove responses with extract_responses, clear_responses, or add_response_handler.

Missing responses¶ ↑

Only non-nil data is stored. Many important response codes have no data of their own, but are used as “tags” on the ResponseText object they are attached to. ResponseText will be accessible by its response types: “OK”, “NO”, “BAD”, “BYE”, or “PREAUTH”.

TaggedResponse#data is not saved to responses, nor is any ResponseCode#data on tagged responses. Although some command methods do return the TaggedResponse directly, add_response_handler must be used to handle all response codes.

# File lib/net/imap.rb, line 2383
def search(...)
  search_internal("SEARCH", ...)
end

Sends a SEARCH command [IMAP4rev1 §6.4.4] to search the mailbox for messages that match the given search criteria, and returns either a SearchResult or an ESearchResult. SearchResult inherits from Array (for backward compatibility) but adds SearchResult#modseq when the CONDSTORE capability has been enabled. ESearchResult also implements #to_a, for compatibility with SearchResult.

criteria is one or more search keys and their arguments, which may be provided as an array or a string. See “Argument translation” and “Search criteria”, below.

return options control what kind of information is returned about messages matching the search criteria. Specifying return should force the server to return an ESearchResult instead of a SearchResult, but some servers disobey this requirement. Requires an extended search capability, such as ESEARCH or IMAP4rev2. See “Argument translation” and “Supported return options”, below.

charset is the name of the registered character set used by strings in the search criteria. When charset isn’t specified, either "US-ASCII" or "UTF-8" is assumed, depending on the server’s capabilities.

NOTE: Return options and charset may be sent as part of criteria. Do not use the return or charset arguments when either return options or charset are embedded in criteria.

Related: uid_search

For example:¶ ↑

imap.search(["SUBJECT", "hello", "NOT", "SEEN"])
#=> [1, 6, 7, 8]

The following assumes the server supports ESEARCH and CONDSTORE:

result = imap.uid_search(["UID", 12345.., "MODSEQ", 620_162_338],
                         return: %w(all count min max))
# => #<data Net::IMAP::ESearchResult tag="RUBY0123", uid=true,
#       data=[["ALL", Net::IMAP::SequenceSet["12346:12349,22222:22230"]],
#             ["COUNT", 13], ["MIN", 12346], ["MAX", 22230],
#             ["MODSEQ", 917162488]]>
result.to_a   # => [12346, 12347, 12348, 12349, 22222, 22223, 22224,
              #     22225, 22226, 22227, 22228, 22229, 22230]
result.uid?   # => true
result.count  # => 13
result.min    # => 12346
result.max    # => 22230
result.modseq # => 917162488

Using return options to limit the result to only min, max, and count:

result = imap.uid_search(["UID", 12345..,], return: %w(count min max))
# => #<data Net::IMAP::ESearchResult tag="RUBY0124", uid=true,
#       data=[["COUNT", 13], ["MIN", 12346], ["MAX", 22230]]>
result.to_a   # => []
result.count  # => 13
result.min    # => 12346
result.max    # => 22230

Return options and charset may be sent as keyword args or embedded in the criteria arg, but they must be in the correct order: "RETURN (...) CHARSET ... criteria...". The following searches send the exact same command to the server:

# Return options and charset as keyword arguments (preferred)
imap.search(%w(OR UNSEEN FLAGGED), return: %w(MIN MAX), charset: "UTF-8")
# Embedding return and charset in the criteria array
imap.search(["RETURN", %w(MIN MAX), "CHARSET", "UTF-8", *%w(OR UNSEEN FLAGGED)])
# Embedding return and charset in the criteria string
imap.search("RETURN (MIN MAX) CHARSET UTF-8 OR UNSEEN FLAGGED")

Sending charset as the second positional argument is supported for backward compatibility. Future versions may print a deprecation warning:

imap.search(%w(OR UNSEEN FLAGGED), "UTF-8", return: %w(MIN MAX))

Argument translation¶ ↑

return options

Must be an Array. Return option names may be either strings or symbols. Range elements which begin and end with negative integers are encoded for use with PARTIAL–any other ranges are converted to SequenceSet. Unlike criteria, other return option arguments are not automatically converted to SequenceSet.

When criteria is an Array

When the array begins with "RETURN" (case insensitive), the second array element is translated like the return parameter (as described above).

Every other member is a SEARCH command argument:

SequenceSet

Encoded as an IMAP sequence-set with SequenceSet#valid_string.

Set, Range, -1, :*, responds to to_sequence_set

Converted to SequenceSet for validation and encoding.

nested sequence-set Array

When every element in a nested array is one of the above types, a positive Integer, a sequence-set formatted String, or a deeply nested Array of these same types, the array will be converted to SequenceSet for validation and encoding.

Any other nested Array

Otherwise, a nested array is encoded as a parenthesized list, to combine multiple search keys (e.g., for use with OR and NOT).

String

Sent verbatim when it is a valid IMAP atom, and encoded as an IMAP quoted or literal string otherwise. Every standard search key name is a valid IMAP atom and every standard search key string argument is an astring which may be encoded as atom, quoted, or literal.

Note: * is not a valid IMAP atom character. Any string containing * will be encoded as a quoted string, not a sequence-set.

Integer (except for -1)

Encoded using to_s.

Date

Encoded as an IMAP date (see ::encode_date).

When criteria is a String

criteria will be sent directly to the server without any validation or encoding.

WARNING: This is vulnerable to injection attacks when external inputs are used.

Supported return options¶ ↑

For full definitions of the standard return options and return data, see the relevant RFCs.

ALL

Returns ESearchResult#all with a SequenceSet of all matching sequence numbers or UIDs. This is the default, when return options are empty.

For compatibility with SearchResult, ESearchResult#to_a returns an Array of message sequence numbers or UIDs.

Requires either the ESEARCH or IMAP4rev2 capabability. [RFC4731] [RFC9051]

COUNT

Returns ESearchResult#count with the number of matching messages.

Requires either the ESEARCH or IMAP4rev2 capabability. [RFC4731] [RFC9051]

MAX

Returns ESearchResult#max with the highest matching sequence number or UID.

Requires either the ESEARCH or IMAP4rev2 capabability. [RFC4731] [RFC9051]

MIN

Returns ESearchResult#min with the lowest matching sequence number or UID.

Requires either the ESEARCH or IMAP4rev2 capabability. [RFC4731] [RFC9051]

PARTIAL range

Returns ESearchResult#partial with a SequenceSet of a subset of matching sequence numbers or UIDs, as selected by range. As with sequence numbers, the first result is 1: 1..500 selects the first 500 search results (in mailbox order), 501..1000 the second 500, and so on. range may also be negative: -500..-1 selects the last 500 search results.

Requires either the CONTEXT=SEARCH or PARTIAL capabability. [RFC5267] [RFC9394]

MODSEQ return data¶ ↑

ESearchResult#modseq return data does not have a corresponding return option. Instead, it is returned if the MODSEQ search key is used or when the CONDSTORE extension is enabled for the selected mailbox. See [RFC4731 §3.2] or [RFC7162 §2.1.5].

RFC4466 compatible extensions¶ ↑

RFC4466 §2.6 defines standard syntax for search extensions. Net::IMAP allows sending unsupported search return options and will parse unsupported search extensions’ return values into ExtensionData. Please note that this is an intentionally unstable API. Future releases may return different (incompatible) objects, without deprecation or warning.

Search keys¶ ↑

For full definitions of the standard search criteria, see [IMAP4rev1 §6.4.4], or [IMAP4rev2 §6.4.4], in addition to documentation for any capabilities which may define additional search filters, such as CONDSTORE, WITHIN, FILTERS, SEARCH=FUZZY, OBJECTID, or SAVEDATE.

With the exception of sequence-set and parenthesized list, all search keys are composed of prefix label with zero or more arguments. The number and type of arguments is specific to each search key.

Search keys that match all messages¶ ↑

ALL

The default initial key. Matches every message in the mailbox.

SAVEDATESUPPORTED

Matches every message in the mailbox when the mailbox supports the save date attribute. Otherwise, it matches no messages.

Requires SAVEDATE capability. [RFC8514]

Sequence set search keys¶ ↑

sequence-set

Matches messages with message sequence numbers in sequence-set.

Note: this search key has no label.

UIDONLY must not be enabled. [RFC9586]

UID sequence-set

Matches messages with a UID in sequence-set.

Compound search keys¶ ↑

(search-key search-key…)

Combines one or more search-key arguments to match messages which match all contained search keys. Useful for OR, NOT, and other search keys with search-key arguments.

Note: this search key has no label.

OR search-key search-key

Matches messages which match either search-key argument.

NOT search-key

Matches messages which do not match search-key.

FUZZY search-key

Uses fuzzy matching for the specified search key.

Requires SEARCH=FUZZY capability. [RFC6203].

Flags search keys¶ ↑

ANSWERED, UNANSWERED

Matches messages with or without the \Answered flag.

DELETED, UNDELETED

Matches messages with or without the \Deleted flag.

DRAFT, UNDRAFT

Matches messages with or without the \Draft flag.

FLAGGED, UNFLAGGED

Matches messages with or without the \Flagged flag.

SEEN, UNSEEN

Matches messages with or without the \Seen flag.

KEYWORD keyword, UNKEYWORD keyword

Matches messages with or without the specified keyword.

RECENT, UNRECENT

Matches messages with or without the \Recent flag.

NOTE: The \Recent flag has been removed from IMAP4rev2.

NEW

Equivalent to (RECENT UNSEEN).

NOTE: The \Recent flag has been removed from IMAP4rev2.

Header field substring search keys¶ ↑

BCC substring

Matches when substring is in the envelope’s BCC field.

CC substring

Matches when substring is in the envelope’s CC field.

FROM substring

Matches when substring is in the envelope’s FROM field.

SUBJECT substring

Matches when substring is in the envelope’s SUBJECT field.

TO substring

Matches when substring is in the envelope’s TO field.

HEADER field substring

Matches when substring is in the specified header field.

Body text search keys¶ ↑

BODY string

Matches when string is in the body of the message. Does not match on header fields.

The server may use flexible matching, rather than simple substring matches. For example, this may use stemming or match only full words.

TEXT string

Matches when string is in the header or body of the message.

The server may use flexible matching, rather than simple substring matches. For example, this may use stemming or match only full words.

Date/Time search keys¶ ↑

SENTBEFORE date

SENTON date

SENTSINCE date

Matches when the Date header is earlier than, on, or later than date.

BEFORE date

ON date

SINCE date

Matches when the INTERNALDATE is earlier than, on, or later than date.

OLDER interval

YOUNGER interval

Matches when the INTERNALDATE is more/less than interval seconds ago.

Requires WITHIN capability. [RFC5032]

SAVEDBEFORE date

SAVEDON date

SAVEDSINCE date

Matches when the save date is earlier than, on, or later than date.

Requires SAVEDATE capability. [RFC8514]

Other message attribute search keys¶ ↑

SMALLER bytes

LARGER bytes

Matches when RFC822.SIZE is smaller or larger than bytes.

ANNOTATION entry attr value

Matches messages that have annotations with entries matching entry, attributes matching attr, and value in the attribute’s values.

Requires ANNOTATE-EXPERIMENT-1 capability. [RFC5257].

FILTER filter

References a filter that is stored on the server and matches all messages which would be matched by that filter’s search criteria.

Requires FILTERS capability. [RFC5466]

MODSEQ modseq

Matches when MODSEQ is greater than or equal to modseq.

Requires CONDSTORE capability. [RFC7162].

MODSEQ entry entry-type modseq

Matches when a specific metadata entry has been updated since modseq.

For flags, the corresponding entry name is "/flags/#{flag_name}", where flag_name includes the \ prefix. entry-type can be one of "shared", "priv" (private), or "all".

Requires CONDSTORE capability. [RFC7162].

EMAILID objectid

THREADID objectid

Matches when EMAILID/THREADID is equal to objectid (substring matches are not supported).

Requires OBJECTID capability. [RFC8474]

Capabilities¶ ↑

Return options should only be specified when the server supports IMAP4rev2 or an extension that allows them, such as ESEARCH [RFC4731].

When IMAP4rev2 is enabled, or when the server supports IMAP4rev2 but not IMAP4rev1, ESearchResult is always returned instead of SearchResult.

If CONDSTORE is supported and enabled for the selected mailbox, a non-empty SearchResult will include a MODSEQ value.

imap.select("mbox", condstore: true)
result = imap.search(["SUBJECT", "hi there", "not", "new"])
#=> Net::IMAP::SearchResult[1, 6, 7, 8, modseq: 5594]
result.modseq # => 5594

When UIDONLY is enabled, the SEARCH command is prohibited. Use uid_search instead.

# File lib/net/imap.rb, line 1433
def select(mailbox, condstore: false)
  args = ["SELECT", mailbox]
  args << ["CONDSTORE"] if condstore
  synchronize do
    @responses.clear
    send_command(*args)
  end
end

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", &:last), and the number of recent messages from imap.responses("RECENT", &:last). 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.

When the condstore keyword argument is true, the server is told to enable the extension. If mailbox supports persistence of mod-sequences, the HIGHESTMODSEQ ResponseCode will be sent as an untagged response to select and all ‘FETCH` responses will include FetchData#modseq. Otherwise, the NOMODSEQ ResponseCode will be sent.

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:

imap.responses("NO", &:last)&.code&.name == "UIDNOTSTICKY"

If [CONDSTORE] is supported, the condstore keyword parameter may be used.

imap.select("mbox", condstore: true)
modseq = imap.responses("HIGHESTMODSEQ", &:last)

# File lib/net/imap.rb, line 1729
def setacl(mailbox, user, rights)
  if rights.nil?
    send_command("SETACL", mailbox, user, "")
  else
    send_command("SETACL", mailbox, user, rights)
  end
end

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 lib/net/imap.rb, line 1709
def setquota(mailbox, quota)
  if quota.nil?
    data = '()'
  else
    data = '(STORAGE ' + quota.to_s + ')'
  end
  send_command("SETQUOTA", mailbox, RawData.new(data))
end

Sends a 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 lib/net/imap.rb, line 2709
def sort(sort_keys, search_keys, charset)
  return sort_internal("SORT", sort_keys, search_keys, charset)
end

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 lib/net/imap.rb, line 1240
def starttls(**options)
  @ssl_ctx_params, @ssl_ctx = build_ssl_ctx(options)
  send_command("STARTTLS") do |resp|
    if resp.kind_of?(TaggedResponse) && resp.name == "OK"
      clear_cached_capabilities
      clear_responses
      start_tls_session
    end
  end
end

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

Any options are forwarded directly to OpenSSL::SSL::SSLContext#set_params; the keys are names of attribute assignment methods on SSLContext.

See DeprecatedClientOptions#starttls for deprecated arguments.

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 starts immediately after that response. Any response code sent with the response (e.g. CAPABILITY) is insecure and cannot be trusted.

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

Capability¶ ↑

Clients should not call starttls unless the server advertises the STARTTLS capability.

Server capabilities may change after starttls, login, and authenticate. Cached capabilities will be cleared when this method completes.

# File lib/net/imap.rb, line 1829
def status(mailbox, attr)
  synchronize do
    send_command("STATUS", mailbox, attr)
    clear_responses("STATUS").last&.attr
  end
end

Sends a STATUS command [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.

The return value is a hash of attributes. Most status attributes return integer values, but some return other value types (documented below).

A Net::IMAP::NoResponseError is raised if status values for mailbox cannot be returned; for instance, because it does not exist.

Supported attributes¶ ↑

Unsupported attributes may be requested. The attribute value will be either an Integer or an ExtensionData object.

For example:¶ ↑

p imap.status("inbox", ["MESSAGES", "RECENT"])
#=> {"RECENT"=>0, "MESSAGES"=>44}

Capabilities¶ ↑

SIZE requires the server’s capabilities to include either IMAP4rev2 or STATUS=SIZE [RFC8483].

DELETED requires the server’s capabilities to include IMAP4rev2.

HIGHESTMODSEQ requires the server’s capabilities to include CONDSTORE [RFC7162].

MAILBOXID requires the server’s capabilities to include OBJECTID [RFC8474].

# File lib/net/imap.rb, line 2576
def store(set, attr, flags, unchangedsince: nil)
  store_internal("STORE", set, attr, flags, unchangedsince: unchangedsince)
end

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

set 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. The semantics of value varies based on attr:

• When attr is "FLAGS", the flags in value replace the message’s flag list.

• When attr is "+FLAGS", the flags in value are added to the flags for the message.

• When attr is "-FLAGS", the flags in value are removed from the message.

unchangedsince is an optional integer mod-sequence. It prohibits any changes to messages with mod-sequence greater than the specified unchangedsince value. A SequenceSet of any messages that fail this check will be returned in a MODIFIED ResponseCode.

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

Capabilities¶ ↑

Extensions may define new data items to be used with store.

The server’s capabilities must include CONDSTORE [RFC7162] in order to use the unchangedsince argument. Using unchangedsince implicitly enables the CONDSTORE extension.

When UIDONLY is enabled, the STORE command is prohibited. Use uid_store instead.

# File lib/net/imap.rb, line 1504
def subscribe(mailbox)
  send_command("SUBSCRIBE", mailbox)
end

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 lib/net/imap.rb, line 2749
def thread(algorithm, search_keys, charset)
  return thread_internal("THREAD", algorithm, search_keys, charset)
end

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:

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 lib/net/imap.rb, line 979
def tls_verified?; @tls_verified end

Returns true after the TLS negotiation has completed and the remote hostname has been verified. Returns false when TLS has been established but peer verification was disabled.

# File lib/net/imap.rb, line 2636
def uid_copy(set, mailbox)
  copy_internal("UID COPY", set, mailbox)
end

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¶ ↑

When UIDONLY in enabled, uid_copy must be used instead of copy.

Otherwise, uid_copy is updated by extensions in the same way as copy.

# File lib/net/imap.rb, line 1969
def uid_expunge(uid_set)
  expunge_internal("UID EXPUNGE", SequenceSet.new(uid_set))
end

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.

Returns the same result type as expunge.

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.

Related: expunge

Capabilities¶ ↑

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

Otherwise, uid_expunge is updated by extensions in the same way as expunge.

# File lib/net/imap.rb, line 2526
def uid_fetch(...)
  fetch_internal("UID FETCH", ...)
end

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

set is the message UIDs to fetch, and may be any valid input to SequenceSet[…]. (For message sequence numbers, use fetch instead.)

attr behaves the same as with fetch.

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.

changedsince (optional) behaves the same as with fetch.

partial is an optional range to limit the number of results returned. It’s useful when set contains an unknown number of messages. 1..500 returns the first 500 messages in set (in mailbox order), 501..1000 the second 500, and so on. partial may also be negative: -500..-1 selects the last 500 messages in set. Requires the PARTIAL capabability. [RFC9394]

For example:

# Without partial, the size of the results may be unknown beforehand:
results = imap.uid_fetch(next_uid_to_fetch.., %w(UID FLAGS))
# ... maybe wait for a long time ... and allocate a lot of memory ...
results.size # => 0..2**32-1
process results # may also take a long time and use a lot of memory...

# Using partial, the results may be paginated:
loop do
  results = imap.uid_fetch(next_uid_to_fetch.., %w(UID FLAGS),
                           partial: 1..500)
  # fetch should return quickly and allocate little memory
  results.size # => 0..500
  break if results.empty?
  next_uid_to_fetch = results.last.uid + 1
  process results
end

Related: fetch, FetchData

Capabilities¶ ↑

The server’s capabilities must include PARTIAL [RFC9394] in order to use the partial argument.

When UIDONLY is enabled, uid_fetch must be used instead of fetch, and UIDFetchData will be returned instead of FetchData.

Otherwise, uid_fetch is updated by extensions in the same way as fetch.

# File lib/net/imap.rb, line 2683
def uid_move(set, mailbox)
  copy_internal("UID MOVE", set, mailbox)
end

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¶ ↑

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

When UIDONLY is enabled, uid_move must be used instead of move.

Otherwise, uid_move is updated by extensions in the same way as move.

# File lib/net/imap.rb, line 2410
def uid_search(...)
  search_internal("UID SEARCH", ...)
end

Sends a UID SEARCH command [IMAP4rev1 §6.4.8] to search the mailbox for messages that match the given searching criteria, and returns unique identifiers (UIDs).

Returns a SearchResult object. SearchResult inherits from Array (for backward compatibility) but adds SearchResult#modseq when the CONDSTORE capability has been enabled.

See search for documentation of parameters.

Capabilities¶ ↑

When UIDONLY is enabled, uid_search must be used instead of search, and the <message set> search criterion is prohibited. Use ALL or UID sequence-set instead.

Otherwise, uid_search is updated by extensions in the same way as search.

# File lib/net/imap.rb, line 2724
def uid_sort(sort_keys, search_keys, charset)
  return sort_internal("UID SORT", sort_keys, search_keys, charset)
end

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 lib/net/imap.rb, line 2599
def uid_store(set, attr, flags, unchangedsince: nil)
  store_internal("UID STORE", set, attr, flags, unchangedsince: unchangedsince)
end

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

Capabilities¶ ↑

When UIDONLY is enabled, uid_store must be used instead of store, and UIDFetchData will be returned instead of FetchData.

Otherwise, uid_store is updated by extensions in the same way as store.

# File lib/net/imap.rb, line 2763
def uid_thread(algorithm, search_keys, charset)
  return thread_internal("UID THREAD", algorithm, search_keys, charset)
end

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 lib/net/imap.rb, line 1909
def unselect
  send_command("UNSELECT")
end

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 either IMAP4rev2 or UNSELECT [RFC3691].

# File lib/net/imap.rb, line 1517
def unsubscribe(mailbox)
  send_command("UNSUBSCRIBE", mailbox)
end

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 lib/net/imap.rb, line 1652
def xlist(refname, mailbox)
  synchronize do
    send_command("XLIST", refname, mailbox)
    clear_responses("XLIST")
  end
end

Sends a XLIST command, and returns a subset of names from the complete set of all names available to the client. refname provides a context (for instance, a base directory in a directory-based mailbox hierarchy). mailbox specifies a mailbox or (via wildcards) mailboxes under that context. Two wildcards may be used in mailbox: ‘*’, which matches all characters including the hierarchy delimiter (for instance, ‘/’ on a UNIX-hosted directory-based mailbox hierarchy); and ‘%’, which matches all characters except the hierarchy delimiter.

If refname is empty, mailbox is used directly to determine which mailboxes to match. If mailbox is empty, the root name of refname and the hierarchy delimiter are returned.

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

The return value is an array of 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).