# class Net::IMAP

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

## `IMAP` Overview¶ ↑

An `IMAP` client connects to a server, and then authenticates itself using either `authenticate()` or `login()`. Having authenticated itself, there is a range of commands available to it. Most work with mailboxes, which may be arranged in an hierarchical namespace, and each of which contains zero or more messages. How this is implemented on the server is implementation-dependent; on a UNIX server, it will frequently be implemented as files in mailbox format within a hierarchy of directories.

To work on the messages within a mailbox, the client must first select that mailbox, using either `select()` or (for read-only access) `examine()`. Once the client has successfully selected a mailbox, they enter selected state, and that mailbox becomes the current mailbox, on which mail-item related commands implicitly operate.

Messages have two sorts of identifiers: message sequence numbers and UIDs.

Message sequence numbers number messages within a mailbox from 1 up to the number of items in the mailbox. If a new message arrives during a session, it receives a sequence number equal to the new size of the mailbox. If messages are expunged from the mailbox, remaining messages have their sequence numbers “shuffled down” to fill the gaps.

UIDs, on the other hand, are permanently guaranteed not to identify another message within the same mailbox, even if the existing message is deleted. UIDs are required to be assigned in ascending (but not necessarily sequential) order within a mailbox; this means that if a non-IMAP client rearranges the order of mailitems within a mailbox, the UIDs have to be reassigned. An `IMAP` client thus cannot rearrange message orders.

## Examples of Usage¶ ↑

### List sender and subject of all recent messages in the default mailbox¶ ↑

    imap = Net::IMAP.new('mail.example.com')
    imap.authenticate('LOGIN', 'joe_user', 'joes_password')
    imap.examine('INBOX')
    imap.search(["RECENT"]).each do |message_id|
      envelope = imap.fetch(message_id, "ENVELOPE")[0].attr["ENVELOPE"]
      puts "#{envelope.from[0].name}: \t#{envelope.subject}"
    end

### Move all messages from April 2003 from “Mail/sent-mail” to “Mail/sent-apr03”¶ ↑

    imap = Net::IMAP.new('mail.example.com')
    imap.authenticate('LOGIN', 'joe_user', 'joes_password')
    imap.select('Mail/sent-mail')
    if not imap.list('Mail/', 'sent-apr03')
      imap.create('Mail/sent-apr03')
    end
    imap.search(["BEFORE", "30-Apr-2003", "SINCE", "1-Apr-2003"]).each do |message_id|
      imap.copy(message_id, "Mail/sent-apr03")
      imap.store(message_id, "+FLAGS", [:Deleted])
    end
    imap.expunge

## `Thread` Safety¶ ↑

`Net::IMAP` supports concurrent threads. For example,

    imap = Net::IMAP.new("imap.foo.net", "imap2")
    imap.authenticate("cram-md5", "bar", "password")
    imap.select("inbox")
    fetch_thread = Thread.start { imap.fetch(1..-1, "UID") }
    search_result = imap.search(["BODY", "hello"])
    fetch_result = fetch_thread.value
    imap.disconnect

This script invokes the FETCH command and the SEARCH command concurrently.

## Errors¶ ↑

An `IMAP` server can send three different types of responses to indicate failure:

NO

  the attempted command could not be successfully completed. For instance, the username/password used for logging in are incorrect; the selected mailbox does not exist; etc.

BAD

  the request from the client does not follow the server's understanding of the `IMAP` protocol. This includes attempting commands from the wrong client state; for instance, attempting to perform a SEARCH command without having SELECTed a current mailbox. It can also signal an internal server failure (such as a disk crash) has occurred.

BYE

  the server is saying goodbye. This can be part of a normal logout sequence, and can be used as part of a login sequence to indicate that the server is (for some reason) unwilling to accept your connection. As a response to any other command, it indicates either that the server is shutting down, or that the server is timing out the client connection due to inactivity.

These three error response are represented by the errors `Net::IMAP::NoResponseError`, `Net::IMAP::BadResponseError`, and `Net::IMAP::ByeResponseError`, all of which are subclasses of `Net::IMAP::ResponseError`. Essentially, all methods that involve sending a request to the server can generate one of these errors. Only the most pertinent instances have been documented below.

Because the `IMAP` class uses Sockets for communication, its methods are also susceptible to the various errors that can occur when working with sockets. These are generally represented as `Errno` errors. For instance, any method that involves sending a request to the server and/or receiving a response from it could raise an Errno::EPIPE error if the network connection unexpectedly goes down. See the socket(7), ip(7), tcp(7), socket(2), connect(2), and associated man pages.

Finally, a `Net::IMAP::DataFormatError` is thrown if low-level data is found to be in an incorrect format (for instance, when converting between UTF-8 and UTF-16), and `Net::IMAP::ResponseParseError` is thrown if a server response is non-parseable.

## References¶ ↑

[IMAP]

  1. Crispin, “INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1”,

  RFC 2060, December 1996. (Note: since obsoleted by RFC 3501)

[LANGUAGE-TAGS]

  Alvestrand, H., “Tags for the Identification of Languages”, RFC 1766, March 1995.

[MD5]

  Myers, J., and M. Rose, “The Content-MD5 Header Field”, RFC 1864, October 1995.

[MIME-IMB]

  Freed, N., and N. Borenstein, “MIME (Multipurpose Internet Mail Extensions) Part One: Format of Internet Message Bodies”, RFC 2045, November 1996.

[RFC-822]

  Crocker, D., “Standard for the Format of ARPA Internet Text Messages”, STD 11, RFC 822, University of Delaware, August 1982.

[RFC-2087]

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

[RFC-2086]

  Myers, J., “IMAP4 `ACL` extension”, RFC 2086, January 1997.

[RFC-2195]

  Klensin, J., Catoe, R., and Krumviede, P., “IMAP/POP AUTHorize Extension for Simple Challenge/Response”, RFC 2195, September 1997.

[SORT-THREAD-EXT]

  Crispin, M., “INTERNET MESSAGE ACCESS PROTOCOL - SORT and THREAD Extensions”, draft-ietf-imapext-sort, May 2003.

[OSSL]

  www.openssl.org

[RSSL]

  savannah.gnu.org/projects/rubypki

[UTF7]

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

### Constants

ANSWERED

  Flag indicating a message has been answered.

Address

  `Net::IMAP::Address` represents electronic mail addresses.

  #### Fields:¶ ↑

  name

    Returns the phrase from [RFC-822] mailbox.

  route

    Returns the route from [RFC-822] route-addr.

  mailbox

    nil indicates end of [RFC-822] group. If non-nil and host is nil, returns [RFC-822] group name. Otherwise, returns [RFC-822] local-part.

  host

    nil indicates [RFC-822] group syntax. Otherwise, returns [RFC-822] domain name.

ContentDisposition

  `Net::IMAP::ContentDisposition` represents Content-Disposition fields.

  #### Fields:¶ ↑

  dsp_type

    Returns the disposition type.

  param

    Returns a hash that represents parameters of the Content-Disposition field.

ContinuationRequest

  `Net::IMAP::ContinuationRequest` represents command continuation requests.

  The command continuation request response is indicated by a “+” token instead of a tag. This form of response indicates that the server is ready to accept the continuation of a command from the client. The remainder of this response is a line of text.

      continue_req    ::= "+" SPACE (resp_text / base64)

  #### Fields:¶ ↑

  data

    Returns the data (Net::IMAP::ResponseText).

  raw_data

    Returns the raw data string.

DATE_MONTH
DELETED

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

DRAFT

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

Envelope

  `Net::IMAP::Envelope` represents envelope structures of messages.

  #### Fields:¶ ↑

  date

    Returns a string that represents the date.

  subject

    Returns a string that represents the subject.

  from

    Returns an array of `Net::IMAP::Address` that represents the from.

  sender

    Returns an array of `Net::IMAP::Address` that represents the sender.

  reply_to

    Returns an array of `Net::IMAP::Address` that represents the reply-to.

  to

    Returns an array of `Net::IMAP::Address` that represents the to.

  cc

    Returns an array of `Net::IMAP::Address` that represents the cc.

  bcc

    Returns an array of `Net::IMAP::Address` that represents the bcc.

  in_reply_to

    Returns a string that represents the in-reply-to.

  message_id

    Returns a string that represents the message-id.

FLAGGED

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

FetchData

  `Net::IMAP::FetchData` represents the contents of the FETCH response.

  #### Fields:¶ ↑

  seqno

    Returns the message sequence number. (Note: not the unique identifier, even for the UID command response.)

  attr

    Returns a hash. Each key is a data item name, and each value is its value.

    The current data items are:

    BODY

      A form of BODYSTRUCTURE without extension data.

    `Net::IMAP::BodyTypeBasic`, `Net::IMAP::BodyTypeText`, `Net::IMAP::BodyTypeMessage`, `Net::IMAP::BodyTypeMultipart`.
  ENVELOPE

    A `Net::IMAP::Envelope` object that describes the envelope structure of a message.

  FLAGS

    A array of flag symbols that are set for this message. Flag symbols are capitalized by `String#capitalize`.

  INTERNALDATE

    A string representing the internal date of the message.

  RFC822

    Equivalent to BODY[].

  RFC822.HEADER

    Equivalent to BODY.PEEK.

  RFC822.SIZE

    A number expressing the [RFC-822] size of the message.

  RFC822.TEXT

    Equivalent to BODY.

  UID

    A number expressing the unique identifier of the message.

MARKED

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

MailboxACLItem

  `Net::IMAP::MailboxACLItem` represents the response from GETACL.

      acl_data        ::= "ACL" SPACE mailbox *(SPACE identifier SPACE rights)

      identifier      ::= astring

      rights          ::= astring

  #### Fields:¶ ↑

  user

    Login name that has certain rights to the mailbox that was specified with the getacl command.

  rights

    The access rights the indicated user has to the mailbox.

MailboxList

  `Net::IMAP::MailboxList` represents contents of the LIST response.

      mailbox_list    ::= "(" #("\Marked" / "\Noinferiors" /
                          "\Noselect" / "\Unmarked" / flag_extension) ")"
                          SPACE (<"> QUOTED_CHAR <"> / nil) SPACE mailbox

  #### Fields:¶ ↑

  attr

    Returns the name attributes. Each name attribute is a symbol capitalized by `String#capitalize`, such as :Noselect (not :NoSelect).

  delim

    Returns the hierarchy delimiter.

  name

    Returns the mailbox name.

MailboxQuota

  `Net::IMAP::MailboxQuota` represents contents of GETQUOTA response. This object can also be a response to GETQUOTAROOT. In the syntax specification below, the delimiter used with the “#” construct is a single space (SPACE).

      quota_list      ::= "(" #quota_resource ")"

      quota_resource  ::= atom SPACE number SPACE number

      quota_response  ::= "QUOTA" SPACE astring SPACE quota_list

  #### Fields:¶ ↑

  mailbox

    The mailbox with the associated quota.

  usage

    Current storage usage of the mailbox.

  quota

    Quota limit imposed on the mailbox.

MailboxQuotaRoot

  `Net::IMAP::MailboxQuotaRoot` represents part of the GETQUOTAROOT response. (GETQUOTAROOT can also return `Net::IMAP::MailboxQuota`.)

      quotaroot_response ::= "QUOTAROOT" SPACE astring *(SPACE astring)

  #### Fields:¶ ↑

  mailbox

    The mailbox with the associated quota.

  quotaroots

    Zero or more quotaroots that affect the quota on the specified mailbox.

NOINFERIORS

  Flag indicating that a mailbox context name cannot contain children.

NOSELECT

  Flag indicating that a mailbox is not selected.

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.

RESPONSE_ERRORS
ResponseCode

  `Net::IMAP::ResponseCode` represents response codes.

      resp_text_code  ::= "ALERT" / "PARSE" /
                          "PERMANENTFLAGS" SPACE "(" #(flag / "\*") ")" /
                          "READ-ONLY" / "READ-WRITE" / "TRYCREATE" /
                          "UIDVALIDITY" SPACE nz_number /
                          "UNSEEN" SPACE nz_number /
                          atom [SPACE 1*<any TEXT_CHAR except "]">]

  #### Fields:¶ ↑

  name

    Returns the name, such as “ALERT”, “PERMANENTFLAGS”, or “UIDVALIDITY”.

  data

    Returns the data, if it exists.

ResponseText

  `Net::IMAP::ResponseText` represents texts of responses. The text may be prefixed by the response code.

      resp_text       ::= ["[" resp_text_code "]" SPACE] (text_mime2 / text)
                          ;; text SHOULD NOT begin with "[" or "="

  #### Fields:¶ ↑

  code

    Returns the response code. See ((<Net::IMAP::ResponseCode>)).

  text

    Returns the text.

SEEN

  Flag indicating a message has been seen.

StatusData

  `Net::IMAP::StatusData` represents the contents of the STATUS response.

  #### Fields:¶ ↑

  mailbox

    Returns the mailbox name.

  attr

    Returns a hash. Each key is one of “MESSAGES”, “RECENT”, “UIDNEXT”, “UIDVALIDITY”, “UNSEEN”. Each value is a number.

TaggedResponse

  `Net::IMAP::TaggedResponse` represents tagged responses.

  The server completion result response indicates the success or failure of the operation. It is tagged with the same tag as the client command which began the operation.

      response_tagged ::= tag SPACE resp_cond_state CRLF

      tag             ::= 1*<any ATOM_CHAR except "+">

      resp_cond_state ::= ("OK" / "NO" / "BAD") SPACE resp_text

  #### Fields:¶ ↑

  tag

    Returns the tag.

  name

    Returns the name, one of “OK”, “NO”, or “BAD”.

  data

    Returns the data. See ((<Net::IMAP::ResponseText>)).

  raw_data

    Returns the raw data string.

ThreadMember

  `Net::IMAP::ThreadMember` represents a thread-node returned by `Net::IMAP#thread`.

  #### Fields:¶ ↑

  seqno

    The sequence number of this message.

  children

    An array of `Net::IMAP::ThreadMember` objects for mail items that are children of this in the thread.

UNMARKED

  Flag indicating that the mailbox does not contains new messages.

UntaggedResponse

  `Net::IMAP::UntaggedResponse` represents untagged responses.

  `Data` transmitted by the server to the client and status responses that do not indicate command completion are prefixed with the token “*”, and are called untagged responses.

      response_data   ::= "*" SPACE (resp_cond_state / resp_cond_bye /
                          mailbox_data / message_data / capability_data)

  #### Fields:¶ ↑

  name

    Returns the name, such as “FLAGS”, “LIST”, or “FETCH”.

  data

    Returns the data such as an array of flag symbols, a ((<Net::IMAP::MailboxList>)) object.

  raw_data

    Returns the raw data string.

### Attributes

client_thread[RW]

The thread to receive exceptions.

greeting[R]

Returns an initial greeting response from the server.

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

add_authenticator(auth_type, authenticator) click to toggle source

Adds an authenticator for `Net::IMAP#authenticate`. `auth_type` is the type of authentication this authenticator supports (for instance, “LOGIN”). The `authenticator` is an object which defines a process() method to handle authentication with the server. See `Net::IMAP::LoginAuthenticator`, `Net::IMAP::CramMD5Authenticator`, and `Net::IMAP::DigestMD5Authenticator` for examples.

If `auth_type` refers to an existing authenticator, it will be replaced by the new one.

    # File lib/net/imap.rb, line 301
    def self.add_authenticator(auth_type, authenticator)
      @@authenticators[auth_type] = authenticator
    end

debug() click to toggle source

Returns the debug mode.

    # File lib/net/imap.rb, line 271
    def self.debug
      return @@debug
    end

debug=(val) click to toggle source

Sets the debug mode.

    # File lib/net/imap.rb, line 276
    def self.debug=(val)
      return @@debug = val
    end

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 lib/net/imap.rb, line 999
    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 lib/net/imap.rb, line 306
    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 lib/net/imap.rb, line 311
    def self.default_tls_port
      return SSL_PORT
    end

Also aliased as: default_imaps_port, default_ssl_port
encode_utf7(s) click to toggle source

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

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

format_date(time) click to toggle source

Formats `time` as an IMAP-style date.

    # File lib/net/imap.rb, line 1022
    def self.format_date(time)
      return time.strftime('%d-%b-%Y')
    end

format_datetime(time) click to toggle source

Formats `time` as an IMAP-style date-time.

    # File lib/net/imap.rb, line 1027
    def self.format_datetime(time)
      return time.strftime('%d-%b-%Y %H:%M %z')
    end

max_flag_count() click to toggle source

Returns the max number of flags interned to symbols.

    # File lib/net/imap.rb, line 281
    def self.max_flag_count
      return @@max_flag_count
    end

max_flag_count=(count) click to toggle source

Sets the max number of flags interned to symbols.

    # File lib/net/imap.rb, line 286
    def self.max_flag_count=(count)
      @@max_flag_count = count
    end

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 is true, then an attempt will be made to use SSL (now TLS) to connect to the server. For this to work `OpenSSL` [OSSL] and the Ruby `OpenSSL` [RSSL] extensions need to be installed. If options is a hash, it's passed to `OpenSSL::SSL::SSLContext#set_params` as parameters.

`open_timeout`

  Seconds to wait until a connection is opened

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 `MonitorMixin::new`

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

### Public Instance Methods

add_response_handler(handler = Proc.new) 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 lib/net/imap.rb, line 906
    def add_response_handler(handler = Proc.new)
      @response_handlers.push(handler)
    end

append(mailbox, message, flags = nil, date_time = nil) click to toggle source

Sends a APPEND command to append the `message` to the end of the `mailbox`. The optional `flags` argument is an array of flags initially passed to the new message. The optional `date_time` argument specifies the creation time to assign to the new message; it defaults to the current time. For example:

    imap.append("inbox", <<EOF.gsub(/\n/, "\r\n"), [:Seen], Time.now)
    Subject: hello
    From: 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.

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

authenticate(auth_type, *args) click to toggle source

Sends an AUTHENTICATE command to authenticate the client. The `auth_type` parameter is a string that represents the authentication mechanism to be used. Currently `Net::IMAP` supports the authentication mechanisms:

    LOGIN:: login using cleartext user and password.
    CRAM-MD5:: login with cleartext user and encrypted password
               (see [RFC-2195] for a full description).  This
               mechanism requires that the server have the user's
               password stored in clear-text password.

For both of these mechanisms, there should be two `args`: username and (cleartext) password. A server may not support one or the other of these mechanisms; check `capability()` for a capability of the form “AUTH=LOGIN” or “AUTH=CRAM-MD5”.

Authentication is done using the appropriate authenticator object: see @@authenticators for more information on plugging in your own authenticator.

For example:

    imap.authenticate('LOGIN', user, password)

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

    # File lib/net/imap.rb, line 417
    def authenticate(auth_type, *args)
      auth_type = auth_type.upcase
      unless @@authenticators.has_key?(auth_type)
        raise ArgumentError,
          format('unknown auth type - "%s"', auth_type)
      end
      authenticator = @@authenticators[auth_type].new(*args)
      send_command("AUTHENTICATE", auth_type) do |resp|
        if resp.instance_of?(ContinuationRequest)
          data = authenticator.process(resp.data.text.unpack("m")[0])
          s = [data].pack("m0")
          send_string_data(s)
          put_string(CRLF)
        end
      end
    end

capability() click to toggle source

Sends a CAPABILITY command, and returns an array of capabilities that the server supports. Each capability is a string. See [IMAP] for a list of possible capabilities.

Note that the `Net::IMAP` class does not modify its behaviour according to the capabilities of the server; it is up to the user of the class to ensure that a certain capability is supported by a server before using it.

    # File lib/net/imap.rb, line 359
    def capability
      synchronize do
        send_command("CAPABILITY")
        return @responses.delete("CAPABILITY")[-1]
      end
    end

check() click to toggle source

Sends a CHECK command to request a checkpoint of the currently selected mailbox. This performs implementation-specific housekeeping; for instance, reconciling the mailbox's in-memory and on-disk state.

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

close() click to toggle source

Sends a CLOSE command to close the currently selected mailbox. The CLOSE command permanently removes from the mailbox all messages that have the Deleted flag set.

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

copy(set, mailbox) click to toggle source

Sends a COPY command to copy the specified message(s) to the end of the specified destination `mailbox`. The `set` parameter is a number, an array of numbers, or a `Range` object. The number is a message sequence number.

    # File lib/net/imap.rb, line 853
    def copy(set, mailbox)
      copy_internal("COPY", set, mailbox)
    end

create(mailbox) click to toggle source

Sends a CREATE command to create a new `mailbox`.

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

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

delete(mailbox) click to toggle source

Sends a DELETE command to remove the `mailbox`.

A `Net::IMAP::NoResponseError` is raised if a mailbox with that name cannot be deleted, either because it does not exist or because the client does not have permission to delete it.

    # File lib/net/imap.rb, line 489
    def delete(mailbox)
      send_command("DELETE", mailbox)
    end

disconnect() click to toggle source

Disconnects from the server.

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

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

examine(mailbox) click to toggle source

Sends a EXAMINE command to select a `mailbox` so that messages in the `mailbox` can be accessed. Behaves the same as `select()`, except that the selected `mailbox` is identified as read-only.

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

    # File lib/net/imap.rb, line 469
    def examine(mailbox)
      synchronize do
        @responses.clear
        send_command("EXAMINE", mailbox)
      end
    end

expunge() click to toggle source

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

    # File lib/net/imap.rb, line 726
    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 to retrieve data associated with a message in the mailbox.

The `set` parameter is a number or a range between two numbers, or an array of those. The number is a message sequence number, where -1 represents a '*' for use in range notation like 100..-1 being interpreted as '100:*'. Beware that the `exclude_end?` property of a `Range` object is ignored, and the contents of a range are independent of the order of the range endpoints as per the protocol specification, so 1…5, 5..1 and 5…1 are all equivalent to 1..5.

`attr` is a list of attributes to fetch; see the documentation for `Net::IMAP::FetchData` for a list of valid attributes.

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

For example:

    p imap.fetch(6..8, "UID")
    #=> [#<Net::IMAP::FetchData seqno=6, attr={"UID"=>98}>, \\
         #<Net::IMAP::FetchData seqno=7, attr={"UID"=>99}>, \\
         #<Net::IMAP::FetchData seqno=8, attr={"UID"=>100}>]
    p imap.fetch(6, "BODY[HEADER.FIELDS (SUBJECT)]")
    #=> [#<Net::IMAP::FetchData seqno=6, attr={"BODY[HEADER.FIELDS (SUBJECT)]"=>"Subject: test\r\n\r\n"}>]
    data = imap.uid_fetch(98, ["RFC822.SIZE", "INTERNALDATE"])[0]
    p data.seqno
    #=> 6
    p data.attr["RFC822.SIZE"]
    #=> 611
    p data.attr["INTERNALDATE"]
    #=> "12-Oct-2000 22:40:59 +0900"
    p data.attr["UID"]
    #=> 98

    # File lib/net/imap.rb, line 817
    def fetch(set, attr, mod = nil)
      return fetch_internal("FETCH", set, attr, mod)
    end

getacl(mailbox) click to toggle source

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

    # File lib/net/imap.rb, line 639
    def getacl(mailbox)
      synchronize do
        send_command("GETACL", mailbox)
        return @responses.delete("ACL")[-1]
      end
    end

getquota(mailbox) click to toggle source

Sends the GETQUOTA command along with specified `mailbox`. If this mailbox exists, then an array containing a `Net::IMAP::MailboxQuota` object is returned. This command is generally only available to server admin.

    # File lib/net/imap.rb, line 603
    def getquota(mailbox)
      synchronize do
        send_command("GETQUOTA", mailbox)
        return @responses.delete("QUOTA")
      end
    end

getquotaroot(mailbox) click to toggle source

Sends the GETQUOTAROOT command along with the specified `mailbox`. This command is generally available to both admin and user. If this mailbox exists, it returns an array containing objects of type `Net::IMAP::MailboxQuotaRoot` and `Net::IMAP::MailboxQuota`.

    # File lib/net/imap.rb, line 589
    def getquotaroot(mailbox)
      synchronize do
        send_command("GETQUOTAROOT", mailbox)
        result = []
        result.concat(@responses.delete("QUOTAROOT"))
        result.concat(@responses.delete("QUOTA"))
        return result
      end
    end

idle(timeout = nil, &response_handler) click to toggle source

Sends an IDLE command that waits for notifications of new or expunged messages. Yields responses from the server during the IDLE.

Use `idle_done()` to leave IDLE.

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

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

    # File lib/net/imap.rb, line 952
    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")
          end
        end
      end

      return response
    end

idle_done() click to toggle source

Leaves IDLE.

    # File lib/net/imap.rb, line 982
    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, and returns a subset of names from the complete set of all names available to the client. `refname` provides a context (for instance, a base directory in a directory-based mailbox hierarchy). `mailbox` specifies a mailbox or (via wildcards) mailboxes under that context. Two wildcards may be used in `mailbox`: '*', which matches all characters including the hierarchy delimiter (for instance, '/' on a UNIX-hosted directory-based mailbox hierarchy); and '%', which matches all characters except the hierarchy delimiter.

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

The return value is an array of `Net::IMAP::MailboxList`. For example:

    imap.create("foo/bar")
    imap.create("foo/baz")
    p imap.list("", "foo/%")
    #=> [#<Net::IMAP::MailboxList attr=[:Noselect], delim="/", name="foo/">, \\
         #<Net::IMAP::MailboxList attr=[:Noinferiors, :Marked], delim="/", name="foo/bar">, \\
         #<Net::IMAP::MailboxList attr=[:Noinferiors], delim="/", name="foo/baz">]

    # File lib/net/imap.rb, line 546
    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 to identify the client and carries the plaintext `password` authenticating this `user`. Note that, unlike calling `authenticate()` with an `auth_type` of “LOGIN”, `login()` does not use the login authenticator.

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

    # File lib/net/imap.rb, line 440
    def login(user, password)
      send_command("LOGIN", user, password)
    end

logout() click to toggle source

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

    # File lib/net/imap.rb, line 373
    def logout
      send_command("LOGOUT")
    end

lsub(refname, mailbox) click to toggle source

Sends a LSUB command, and returns a subset of names from the set of names that the user has declared as being “active” or “subscribed.” `refname` and `mailbox` are interpreted as for `list()`. The return value is an array of `Net::IMAP::MailboxList`.

    # File lib/net/imap.rb, line 651
    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 to move the specified message(s) to the end of the specified destination `mailbox`. The `set` parameter is a number, an array of numbers, or a `Range` object. The number is a message sequence number. The `IMAP` MOVE extension is described in [RFC-6851].

    # File lib/net/imap.rb, line 867
    def move(set, mailbox)
      copy_internal("MOVE", set, mailbox)
    end

noop() click to toggle source

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

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

remove_response_handler(handler) click to toggle source

Removes the response handler.

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

rename(mailbox, newname) click to toggle source

Sends a RENAME command to change the name of the `mailbox` to `newname`.

A `Net::IMAP::NoResponseError` is raised if a mailbox with the name `mailbox` cannot be renamed to `newname` for whatever reason; for instance, because `mailbox` does not exist, or because there is already a mailbox with the name `newname`.

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

search(keys, charset = nil) click to toggle source

Sends a SEARCH command to search the mailbox for messages that match the given searching criteria, and returns message sequence numbers. `keys` can either be a string holding the entire search string, or a single-dimension array of search keywords and arguments. The following are some common search criteria; see [IMAP] section 6.4.4 for a full list.

<message set>

  a set of message sequence numbers. ',' indicates an interval, ':' indicates a range. For instance, '2,10:12,15' means “2,10,11,12,15”.

BEFORE <date>

  messages with an internal date strictly before <date>. The date argument has a format similar to 8-Aug-2002.

BODY <string>

  messages that contain <string> within their body.

CC <string>

  messages containing <string> in their CC field.

FROM <string>

  messages that contain <string> in their FROM field.

NEW

  messages with the Recent, but not the Seen, flag set.

NOT <search-key>

  negate the following search key.

OR <search-key> <search-key>

  “or” two search keys together.

ON <date>

  messages with an internal date exactly equal to <date>, which has a format similar to 8-Aug-2002.

SINCE <date>

  messages with an internal date on or after <date>.

SUBJECT <string>

  messages with <string> in their subject.

TO <string>

  messages with <string> in their TO field.

For example:

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

    # File lib/net/imap.rb, line 773
    def search(keys, charset = nil)
      return search_internal("SEARCH", keys, charset)
    end

select(mailbox) click to toggle source

Sends a SELECT command to select a `mailbox` so that messages in the `mailbox` can be accessed.

After you have selected a mailbox, you may retrieve the number of items in that mailbox from @responses[-1], and the number of recent messages from @responses[-1]. Note that these values can change if new messages arrive during a session; see `add_response_handler()` for a way of detecting this event.

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

    # File lib/net/imap.rb, line 456
    def select(mailbox)
      synchronize do
        @responses.clear
        send_command("SELECT", mailbox)
      end
    end

setacl(mailbox, user, rights) click to toggle source

Sends the SETACL command along with `mailbox`, `user` and the `rights` that user is to have on that mailbox. If `rights` is nil, then that user will be stripped of any rights to that mailbox. The `IMAP` `ACL` commands are described in [RFC-2086].

    # File lib/net/imap.rb, line 628
    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 along with the specified `mailbox` and `quota`. If `quota` is nil, then `quota` will be unset for that mailbox. Typically one needs to be logged in as a server admin for this to work. The `IMAP` quota commands are described in [RFC-2087].

    # File lib/net/imap.rb, line 615
    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 to sort messages in the mailbox. Returns an array of message sequence numbers. For example:

    p imap.sort(["FROM"], ["ALL"], "US-ASCII")
    #=> [1, 2, 3, 5, 6, 7, 8, 4, 9]
    p imap.sort(["DATE"], ["SUBJECT", "hello"], "US-ASCII")
    #=> [6, 7, 8, 1]

See [SORT-THREAD-EXT] for more details.

    # File lib/net/imap.rb, line 885
    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 to start TLS session.

    # File lib/net/imap.rb, line 378
    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 command, and returns the status of the indicated `mailbox`. `attr` is a list of one or more attributes whose statuses are to be requested. Supported attributes include:

    MESSAGES:: the number of messages in the mailbox.
    RECENT:: the number of recent messages in the mailbox.
    UNSEEN:: the number of unseen messages in the mailbox.

The return value is a hash of attributes. For example:

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

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

    # File lib/net/imap.rb, line 674
    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 to alter data associated with messages in the mailbox, in particular their flags. The `set` parameter is a number, an array of numbers, or a `Range` object. Each number is a message sequence number. `attr` is the name of a data item to store: 'FLAGS' will replace the message's flag list with the provided one, '+FLAGS' will add the provided flags, and '-FLAGS' will remove them. `flags` is a list of flags.

The return value is an array of `Net::IMAP::FetchData`. For example:

    p imap.store(6..8, "+FLAGS", [:Deleted])
    #=> [#<Net::IMAP::FetchData seqno=6, attr={"FLAGS"=>[:Seen, :Deleted]}>, \\
         #<Net::IMAP::FetchData seqno=7, attr={"FLAGS"=>[:Seen, :Deleted]}>, \\
         #<Net::IMAP::FetchData seqno=8, attr={"FLAGS"=>[:Seen, :Deleted]}>]

    # File lib/net/imap.rb, line 840
    def store(set, attr, flags)
      return store_internal("STORE", set, attr, flags)
    end

subscribe(mailbox) click to toggle source

Sends a SUBSCRIBE command to add the specified `mailbox` name to the server's set of “active” or “subscribed” mailboxes as returned by `lsub()`.

A `Net::IMAP::NoResponseError` is raised if `mailbox` cannot be subscribed to; for instance, because it does not exist.

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

thread(algorithm, search_keys, charset) click to toggle source

Similar to `search()`, but returns message sequence numbers in threaded format, as a `Net::IMAP::ThreadMember` tree. The supported algorithms are:

ORDEREDSUBJECT

  split into single-level threads according to subject, ordered by date.

REFERENCES

  split into threads by parent/child relationships determined by which message is a reply to which.

Unlike `search()`, `charset` is a required argument. US-ASCII and UTF-8 are sample values.

See [SORT-THREAD-EXT] for more details.

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

uid_copy(set, mailbox) click to toggle source

Similar to `copy()`, but `set` contains unique identifiers.

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

uid_fetch(set, attr, mod = nil) click to toggle source

Similar to `fetch()`, but `set` contains unique identifiers.

    # File lib/net/imap.rb, line 822
    def uid_fetch(set, attr, mod = nil)
      return fetch_internal("UID FETCH", set, attr, mod)
    end

uid_move(set, mailbox) click to toggle source

Similar to `move()`, but `set` contains unique identifiers.

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

uid_search(keys, charset = nil) click to toggle source

Similar to `search()`, but returns unique identifiers.

    # File lib/net/imap.rb, line 778
    def uid_search(keys, charset = nil)
      return search_internal("UID SEARCH", keys, charset)
    end

uid_sort(sort_keys, search_keys, charset) click to toggle source

Similar to `sort()`, but returns an array of unique identifiers.

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

Similar to `store()`, but `set` contains unique identifiers.

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

Similar to `thread()`, but returns unique identifiers instead of message sequence numbers.

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

unsubscribe(mailbox) click to toggle source

Sends a UNSUBSCRIBE command to remove the specified `mailbox` name from the server's set of “active” or “subscribed” mailboxes.

A `Net::IMAP::NoResponseError` is raised if `mailbox` cannot be unsubscribed from; for instance, because the client is not currently subscribed to it.

    # File lib/net/imap.rb, line 520
    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 `Net::IMAP::MailboxList`. For example:

    imap.create("foo/bar")
    imap.create("foo/baz")
    p imap.xlist("", "foo/%")
    #=> [#<Net::IMAP::MailboxList attr=[:Noselect], delim="/", name="foo/">, \\
         #<Net::IMAP::MailboxList attr=[:Noinferiors, :Marked], delim="/", name="foo/bar">, \\
         #<Net::IMAP::MailboxList attr=[:Noinferiors], delim="/", name="foo/baz">]

    # File lib/net/imap.rb, line 578
    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 lib/net/imap.rb, line 1460
    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 lib/net/imap.rb, line 1499
    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 lib/net/imap.rb, line 1428
    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 lib/net/imap.rb, line 1284
    def generate_tag
      @tagno += 1
      return format("%s%04d", @tag_prefix, @tagno)
    end

get_response() click to toggle source

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

    # File lib/net/imap.rb, line 1211
    def get_tagged_response(tag, cmd)
      until @tagged_responses.key?(tag)
        raise @exception if @exception
        @tagged_response_arrival.wait
      end
      resp = @tagged_responses.delete(tag)
      case resp.name
      when /\A(?: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 lib/net/imap.rb, line 1488
    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 lib/net/imap.rb, line 1289
    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 lib/net/imap.rb, line 1140
    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 lib/net/imap.rb, line 1249
    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 lib/net/imap.rb, line 1412
    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 lib/net/imap.rb, line 1256
    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 lib/net/imap.rb, line 1325
    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 Time
        send_time_data(data)
      when Symbol
        send_symbol_data(data)
      else
        data.send_data(self, tag)
      end
    end

send_list_data(list, tag = nil) click to toggle source

    # File lib/net/imap.rb, line 1384
    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 lib/net/imap.rb, line 1363
    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 lib/net/imap.rb, line 1380
    def send_number_data(num)
      put_string(num.to_s)
    end

send_quoted_string(str) click to toggle source

    # File lib/net/imap.rb, line 1359
    def send_quoted_string(str)
      put_string('"' + str.gsub(/["\\]/n, "\\\\\\&") + '"')
    end

send_string_data(str, tag = nil) click to toggle source

    # File lib/net/imap.rb, line 1344
    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 lib/net/imap.rb, line 1408
    def send_symbol_data(symbol)
      put_string("\\" + symbol.to_s)
    end

send_time_data(time) click to toggle source

    # File lib/net/imap.rb, line 1400
    def send_time_data(time)
      t = time.dup.gmtime
      s = format('"%2d-%3s-%4d %02d:%02d:%02d +0000"',
                 t.day, DATE_MONTH[t.month - 1], t.year,
                 t.hour, t.min, t.sec)
      put_string(s)
    end

sort_internal(cmd, sort_keys, search_keys, charset) click to toggle source

    # File lib/net/imap.rb, line 1464
    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 lib/net/imap.rb, line 1516
    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 lib/net/imap.rb, line 1449
    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 lib/net/imap.rb, line 1131
    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 lib/net/imap.rb, line 1477
    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 lib/net/imap.rb, line 1304
    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
      when Symbol
      else
        data.validate
      end
    end