Class Net::IMAP
In: lib/net/imap.rb
Parent: Object

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

IMAP Overview

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

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

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

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

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

Examples of Usage

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

  imap = Net::IMAP.new('mail.example.com')
  imap.authenticate('LOGIN', 'joe_user', 'joes_password')
  imap.examine('INBOX')
  imap.search(["RECENT"]).each do |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 exists; etc.
BAD:the request from the client does not follow the server‘s understanding of the IMAP protocol. This includes attempting commands from the wrong client state; for instance, attempting to perform a SEARCH command without having SELECTed a current mailbox. It can also signal an internal server failure (such as a disk crash) has occurred.
BYE:the server is saying goodbye. This can be part of a normal logout sequence, and can be used as part of a login sequence to indicate that the server is (for some reason) unwilling to accept our connection. As a response to any other command, it indicates either that the server is shutting down, or that the server is timing out the client connection due to inactivity.

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

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

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

References

[IMAP]
M. 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.

Methods

Included Modules

MonitorMixin OpenSSL SSL

Classes and Modules

Class Net::IMAP::BadResponseError
Class Net::IMAP::BodyTypeBasic
Class Net::IMAP::BodyTypeMessage
Class Net::IMAP::BodyTypeMultipart
Class Net::IMAP::BodyTypeText
Class Net::IMAP::ByeResponseError
Class Net::IMAP::CramMD5Authenticator
Class Net::IMAP::DataFormatError
Class Net::IMAP::Error
Class Net::IMAP::LoginAuthenticator
Class Net::IMAP::NoResponseError
Class Net::IMAP::ResponseError
Class Net::IMAP::ResponseParseError

Constants

SEEN = :Seen   Flag indicating a message has been seen
ANSWERED = :Answered   Flag indicating a message has been answered
FLAGGED = :Flagged   Flag indicating a message has been flagged for special or urgent attention
DELETED = :Deleted   Flag indicating a message has been marked for deletion. This will occur when the mailbox is closed or expunged.
DRAFT = :Draft   Flag indicating a message is only a draft or work-in-progress version.
RECENT = :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.
NOINFERIORS = :Noinferiors   Flag indicating that a mailbox context name cannot contain children.
NOSELECT = :Noselect   Flag indicating that a mailbox is not selected.
MARKED = :Marked   Flag indicating that a mailbox has been marked "interesting" by the server; this commonly indicates that the mailbox contains new messages.
UNMARKED = :Unmarked   Flag indicating that the mailbox does not contains new messages.
DATE_MONTH = %w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)
ContinuationRequest = Struct.new(:data, :raw_data)   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.
UntaggedResponse = Struct.new(:name, :data, :raw_data)   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", "FETCH".…
data:Returns the data such as an array of flag symbols,
 a ((<Net::IMAP::MailboxList>)) object....
raw_data:Returns the raw data string.
TaggedResponse = Struct.new(:tag, :name, :data, :raw_data)   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. the name is one of "OK", "NO", "BAD".
data:Returns the data. See ((<Net::IMAP::ResponseText>)).
raw_data:Returns the raw data string.
ResponseText = Struct.new(:code, :text)   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.
ResponseCode = Struct.new(:name, :data)   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", "UIDVALIDITY".…
data:Returns the data if it exists.
MailboxList = Struct.new(:attr, :delim, :name)   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 = Struct.new(:mailbox, :usage, :quota)   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 mailbox.
quota:Quota limit imposed on mailbox.
MailboxQuotaRoot = Struct.new(:mailbox, :quotaroots)   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 effect the quota on the specified mailbox.
MailboxACLItem = Struct.new(:user, :rights)   Net::IMAP::MailboxACLItem represents 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.
StatusData = Struct.new(:mailbox, :attr)   Net::IMAP::StatusData represents 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.
FetchData = Struct.new(:seqno, :attr)   Net::IMAP::FetchData represents 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.
BODY[<section>]<<origin_octet>>
A string expressing the body contents of the specified section.
BODYSTRUCTURE
An object that describes the [MIME-IMB] body structure of a message. See 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[HEADER].
RFC822.SIZE
A number expressing the [RFC-822] size of the message.
RFC822.TEXT
Equivalent to BODY[TEXT].
UID
A number expressing the unique identifier of the message.
Envelope = Struct.new(:date, :subject, :from, :sender, :reply_to, :to, :cc, :bcc, :in_reply_to, :message_id)   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.
Address = Struct.new(:name, :route, :mailbox, :host)   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 = Struct.new(:dsp_type, :param)   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.
ThreadMember = Struct.new(:seqno, :children)   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.

Attributes

client_thread  [RW]  The thread to receive exceptions.
greeting  [R]  Returns an initial greeting response from the server.
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

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

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

[Source]

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

Returns the debug mode.

[Source]

     # File lib/net/imap.rb, line 263
263:     def self.debug
264:       return @@debug
265:     end

Sets the debug mode.

[Source]

     # File lib/net/imap.rb, line 268
268:     def self.debug=(val)
269:       return @@debug = val
270:     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 utf7.

[Source]

     # File lib/net/imap.rb, line 827
827:     def self.decode_utf7(s)
828:       return s.gsub(/&(.*?)-/n) {
829:         if $1.empty?
830:           "&"
831:         else
832:           base64 = $1.tr(",", "/")
833:           x = base64.length % 4
834:           if x > 0
835:             base64.concat("=" * (4 - x))
836:           end
837:           u16tou8(base64.unpack("m")[0])
838:         end
839:       }
840:     end

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

[Source]

     # File lib/net/imap.rb, line 843
843:     def self.encode_utf7(s)
844:       return s.gsub(/(&)|([^\x20-\x7e]+)/u) { |x|
845:         if $1
846:           "&-"
847:         else
848:           base64 = [u8tou16(x)].pack("m")
849:           "&" + base64.delete("=\n").tr("/", ",") + "-"
850:         end
851:       }
852:     end

Creates a new Net::IMAP object and connects it to the specified port (143 by default) on the named host. If usessl 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. The certs parameter indicates the path or file containing the CA cert of the server, and the verify parameter is for the OpenSSL verification callback.

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:we connected to the host, but they immediately said goodbye to us.

[Source]

     # File lib/net/imap.rb, line 881
881:     def initialize(host, port = PORT, usessl = false, certs = nil, verify = false)
882:       super()
883:       @host = host
884:       @port = port
885:       @tag_prefix = "RUBY"
886:       @tagno = 0
887:       @parser = ResponseParser.new
888:       @sock = TCPSocket.open(host, port)
889:       if usessl
890:         unless defined?(OpenSSL)
891:           raise "SSL extension not installed"
892:         end
893:         @usessl = true
894: 
895:         # verify the server.
896:         context = SSLContext::new()
897:         context.ca_file = certs if certs && FileTest::file?(certs)
898:         context.ca_path = certs if certs && FileTest::directory?(certs)
899:         context.verify_mode = VERIFY_PEER if verify
900:         if defined?(VerifyCallbackProc)
901:           context.verify_callback = VerifyCallbackProc 
902:         end
903:         @sock = SSLSocket.new(@sock, context)
904:         @sock.sync_close = true
905:         @sock.connect   # start ssl session.
906:         @sock.post_connection_check(@host) if verify
907:       else
908:         @usessl = false
909:       end
910:       @responses = Hash.new([].freeze)
911:       @tagged_responses = {}
912:       @response_handlers = []
913:       @response_arrival = new_cond
914:       @continuation_request = nil
915:       @logout_command_tag = nil
916:       @debug_output_bol = true
917:       @exception = nil
918: 
919:       @greeting = get_response
920:       if @greeting.name == "BYE"
921:         @sock.close
922:         raise ByeResponseError, @greeting.raw_data
923:       end
924: 
925:       @client_thread = Thread.current
926:       @receiver_thread = Thread.start {
927:         receive_responses
928:       }
929:     end

Private Class methods

[Source]

      # File lib/net/imap.rb, line 1255
1255:     def self.u16tou8(s)
1256:       len = s.length
1257:       if len < 2
1258:         return ""
1259:       end
1260:       buf = ""
1261:       i = 0
1262:       while i < len
1263:         c = s[i] << 8 | s[i + 1]
1264:         i += 2
1265:         if c == 0xfeff
1266:           next
1267:         elsif c < 0x0080
1268:           buf.concat(c)
1269:         elsif c < 0x0800
1270:           b2 = c & 0x003f
1271:           b1 = c >> 6
1272:           buf.concat(b1 | 0xc0)
1273:           buf.concat(b2 | 0x80)
1274:         elsif c >= 0xdc00 && c < 0xe000
1275:           raise DataFormatError, "invalid surrogate detected"
1276:         elsif c >= 0xd800 && c < 0xdc00
1277:           if i + 2 > len
1278:             raise DataFormatError, "invalid surrogate detected"
1279:           end
1280:           low = s[i] << 8 | s[i + 1]
1281:           i += 2
1282:           if low < 0xdc00 || low > 0xdfff
1283:             raise DataFormatError, "invalid surrogate detected"
1284:           end
1285:           c = (((c & 0x03ff)) << 10 | (low & 0x03ff)) + 0x10000
1286:           b4 = c & 0x003f
1287:           b3 = (c >> 6) & 0x003f
1288:           b2 = (c >> 12) & 0x003f
1289:           b1 = c >> 18;
1290:           buf.concat(b1 | 0xf0)
1291:           buf.concat(b2 | 0x80)
1292:           buf.concat(b3 | 0x80)
1293:           buf.concat(b4 | 0x80)
1294:         else # 0x0800-0xffff
1295:           b3 = c & 0x003f
1296:           b2 = (c >> 6) & 0x003f
1297:           b1 = c >> 12
1298:           buf.concat(b1 | 0xe0)
1299:           buf.concat(b2 | 0x80)
1300:           buf.concat(b3 | 0x80)
1301:         end
1302:       end
1303:       return buf
1304:     end

[Source]

      # File lib/net/imap.rb, line 1307
1307:     def self.u8tou16(s)
1308:       len = s.length
1309:       buf = ""
1310:       i = 0
1311:       while i < len
1312:         c = s[i]
1313:         if (c & 0x80) == 0
1314:           buf.concat(0x00)
1315:           buf.concat(c)
1316:           i += 1
1317:         elsif (c & 0xe0) == 0xc0 &&
1318:             len >= 2 &&
1319:             (s[i + 1] & 0xc0) == 0x80
1320:           if c == 0xc0 || c == 0xc1
1321:             raise DataFormatError, format("non-shortest UTF-8 sequence (%02x)", c)
1322:           end
1323:           u = ((c & 0x1f) << 6) | (s[i + 1] & 0x3f)
1324:           buf.concat(u >> 8)
1325:           buf.concat(u & 0x00ff)
1326:           i += 2
1327:         elsif (c & 0xf0) == 0xe0 &&
1328:             i + 2 < len &&
1329:             (s[i + 1] & 0xc0) == 0x80 &&
1330:             (s[i + 2] & 0xc0) == 0x80
1331:           if c == 0xe0 && s[i + 1] < 0xa0
1332:             raise DataFormatError, format("non-shortest UTF-8 sequence (%02x)", c)
1333:           end
1334:           u = ((c & 0x0f) << 12) | ((s[i + 1] & 0x3f) << 6) | (s[i + 2] & 0x3f)
1335:           # surrogate chars
1336:           if u >= 0xd800 && u <= 0xdfff
1337:             raise DataFormatError, format("none-UTF-16 char detected (%04x)", u)
1338:           end
1339:           buf.concat(u >> 8)
1340:           buf.concat(u & 0x00ff)
1341:           i += 3
1342:         elsif (c & 0xf8) == 0xf0 &&
1343:             i + 3 < len &&
1344:             (s[i + 1] & 0xc0) == 0x80 &&
1345:             (s[i + 2] & 0xc0) == 0x80 &&
1346:             (s[i + 3] & 0xc0) == 0x80
1347:           if c == 0xf0 && s[i + 1] < 0x90
1348:             raise DataFormatError, format("non-shortest UTF-8 sequence (%02x)", c)
1349:           end
1350:           u = ((c & 0x07) << 18) | ((s[i + 1] & 0x3f) << 12) |
1351:             ((s[i + 2] & 0x3f) << 6) | (s[i + 3] & 0x3f)
1352:           if u < 0x10000
1353:             buf.concat(u >> 8)
1354:             buf.concat(u & 0x00ff)
1355:           elsif u < 0x110000
1356:             high = ((u - 0x10000) >> 10) | 0xd800
1357:             low = (u & 0x03ff) | 0xdc00
1358:             buf.concat(high >> 8)
1359:             buf.concat(high & 0x00ff)
1360:             buf.concat(low >> 8)
1361:             buf.concat(low & 0x00ff)
1362:           else
1363:             raise DataFormatError, format("none-UTF-16 char detected (%04x)", u)
1364:           end
1365:           i += 4
1366:         else
1367:           raise DataFormatError, format("illegal UTF-8 sequence (%02x)", c)
1368:         end
1369:       end
1370:       return buf
1371:     end

Public Instance methods

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

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

[Source]

     # File lib/net/imap.rb, line 787
787:     def add_response_handler(handler = Proc.new)
788:       @response_handlers.push(handler)
789:     end

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

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

[Source]

     # File lib/net/imap.rb, line 606
606:     def append(mailbox, message, flags = nil, date_time = nil)
607:       args = []
608:       if flags
609:         args.push(flags)
610:       end
611:       args.push(date_time) if date_time
612:       args.push(Literal.new(message))
613:       send_command("APPEND", mailbox, *args)
614:     end

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

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

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

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

For example:

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

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

[Source]

     # File lib/net/imap.rb, line 356
356:     def authenticate(auth_type, *args)
357:       auth_type = auth_type.upcase
358:       unless @@authenticators.has_key?(auth_type)
359:         raise ArgumentError,
360:           format('unknown auth type - "%s"', auth_type)
361:       end
362:       authenticator = @@authenticators[auth_type].new(*args)
363:       send_command("AUTHENTICATE", auth_type) do |resp|
364:         if resp.instance_of?(ContinuationRequest)
365:           data = authenticator.process(resp.data.text.unpack("m")[0])
366:           s = [data].pack("m").gsub(/\n/, "")
367:           send_string_data(s)
368:           put_string(CRLF)
369:         end
370:       end
371:     end

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.

[Source]

     # File lib/net/imap.rb, line 313
313:     def capability
314:       synchronize do
315:         send_command("CAPABILITY")
316:         return @responses.delete("CAPABILITY")[-1]
317:       end
318:     end

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.

[Source]

     # File lib/net/imap.rb, line 620
620:     def check
621:       send_command("CHECK")
622:     end

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.

[Source]

     # File lib/net/imap.rb, line 627
627:     def close
628:       send_command("CLOSE")
629:     end

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

[Source]

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

Sends a CREATE command to create a new mailbox.

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

[Source]

     # File lib/net/imap.rb, line 419
419:     def create(mailbox)
420:       send_command("CREATE", mailbox)
421:     end

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.

[Source]

     # File lib/net/imap.rb, line 428
428:     def delete(mailbox)
429:       send_command("DELETE", mailbox)
430:     end

Disconnects from the server.

[Source]

     # File lib/net/imap.rb, line 286
286:     def disconnect
287:       begin
288:         # try to call SSL::SSLSocket#io.
289:         @sock.io.shutdown
290:       rescue NoMethodError
291:         # @sock is not an SSL::SSLSocket.
292:         @sock.shutdown
293:       end
294:       @receiver_thread.join
295:       @sock.close
296:     end

Returns true if disconnected from the server.

[Source]

     # File lib/net/imap.rb, line 299
299:     def disconnected?
300:       return @sock.closed?
301:     end

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.

[Source]

     # File lib/net/imap.rb, line 408
408:     def examine(mailbox)
409:       synchronize do
410:         @responses.clear
411:         send_command("EXAMINE", mailbox)
412:       end
413:     end

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

[Source]

     # File lib/net/imap.rb, line 633
633:     def expunge
634:       synchronize do
635:         send_command("EXPUNGE")
636:         return @responses.delete("EXPUNGE")
637:       end
638:     end

Sends a FETCH command to retrieve data associated with a message in the mailbox. The set parameter is a number or an array of numbers or a Range object. The number is a message sequence number. attr is a list of attributes to fetch; see the documentation for Net::IMAP::FetchData for a list of valid attributes. The return value is an array of Net::IMAP::FetchData. For example:

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

[Source]

     # File lib/net/imap.rb, line 712
712:     def fetch(set, attr)
713:       return fetch_internal("FETCH", set, attr)
714:     end

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

[Source]

     # File lib/net/imap.rb, line 546
546:     def getacl(mailbox)
547:       synchronize do
548:         send_command("GETACL", mailbox)
549:         return @responses.delete("ACL")[-1]
550:       end
551:     end

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

[Source]

     # File lib/net/imap.rb, line 510
510:     def getquota(mailbox)
511:       synchronize do
512:         send_command("GETQUOTA", mailbox)
513:         return @responses.delete("QUOTA")
514:       end
515:     end

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

[Source]

     # File lib/net/imap.rb, line 496
496:     def getquotaroot(mailbox)
497:       synchronize do
498:         send_command("GETQUOTAROOT", mailbox)
499:         result = []
500:         result.concat(@responses.delete("QUOTAROOT"))
501:         result.concat(@responses.delete("QUOTA"))
502:         return result
503:       end
504:     end

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

[Source]

     # File lib/net/imap.rb, line 485
485:     def list(refname, mailbox)
486:       synchronize do
487:         send_command("LIST", refname, mailbox)
488:         return @responses.delete("LIST")
489:       end
490:     end

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.

[Source]

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

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

[Source]

     # File lib/net/imap.rb, line 327
327:     def logout
328:       send_command("LOGOUT")
329:     end

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

[Source]

     # File lib/net/imap.rb, line 558
558:     def lsub(refname, mailbox)
559:       synchronize do
560:         send_command("LSUB", refname, mailbox)
561:         return @responses.delete("LSUB")
562:       end
563:     end

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

[Source]

     # File lib/net/imap.rb, line 321
321:     def noop
322:       send_command("NOOP")
323:     end

Removes the response handler.

[Source]

     # File lib/net/imap.rb, line 792
792:     def remove_response_handler(handler)
793:       @response_handlers.delete(handler)
794:     end

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.

[Source]

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

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]

[Source]

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

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["EXISTS"][-1], and the number of recent messages from @responses["RECENT"][-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.

[Source]

     # File lib/net/imap.rb, line 395
395:     def select(mailbox)
396:       synchronize do
397:         @responses.clear
398:         send_command("SELECT", mailbox)
399:       end
400:     end

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

[Source]

     # File lib/net/imap.rb, line 535
535:     def setacl(mailbox, user, rights)
536:       if rights.nil? 
537:         send_command("SETACL", mailbox, user, "")
538:       else
539:         send_command("SETACL", mailbox, user, rights)
540:       end
541:     end

Sends a SETQUOTA command along with the specified mailbox and quota. If quota is nil, then quota will be unset for that mailbox. Typically one needs to be logged in as server admin for this to work. The IMAP quota commands are described in [RFC-2087].

[Source]

     # File lib/net/imap.rb, line 522
522:     def setquota(mailbox, quota)
523:       if quota.nil?
524:         data = '()'
525:       else
526:         data = '(STORAGE ' + quota.to_s + ')'
527:       end
528:       send_command("SETQUOTA", mailbox, RawData.new(data))
529:     end

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.

[Source]

     # File lib/net/imap.rb, line 766
766:     def sort(sort_keys, search_keys, charset)
767:       return sort_internal("SORT", sort_keys, search_keys, charset)
768:     end

Sends a STATUS command, and returns the status of the indicated mailbox. attr is a list of one or more attributes that we are request the status of. Supported attributes include:

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

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

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

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

[Source]

     # File lib/net/imap.rb, line 581
581:     def status(mailbox, attr)
582:       synchronize do
583:         send_command("STATUS", mailbox, attr)
584:         return @responses.delete("STATUS")[-1].attr
585:       end
586:     end

Sends a STORE command to alter data associated with messages in the mailbox, in particular their flags. The set parameter is a number or an array of numbers or a Range object. Each number is a message sequence number. attr is the name of a data item to store: ‘FLAGS’ means to replace the message‘s flag list with the provided one; ’+FLAGS’ means to add the provided flags; and ’-FLAGS’ means to remove them. flags is a list of flags.

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

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

[Source]

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

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.

[Source]

     # File lib/net/imap.rb, line 449
449:     def subscribe(mailbox)
450:       send_command("SUBSCRIBE", mailbox)
451:     end

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

ORDEREDSUBJECT:split into single-level threads according to subject, ordered by date.
REFERENCES:split into threads by parent/child relationships determined by which message is a reply to which.

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

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

[Source]

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

As for copy(), but set contains unique identifiers.

[Source]

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

As for fetch(), but set contains unique identifiers.

[Source]

     # File lib/net/imap.rb, line 717
717:     def uid_fetch(set, attr)
718:       return fetch_internal("UID FETCH", set, attr)
719:     end

As for search(), but returns unique identifiers.

[Source]

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

As for sort(), but returns an array of unique identifiers.

[Source]

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

As for store(), but set contains unique identifiers.

[Source]

     # File lib/net/imap.rb, line 740
740:     def uid_store(set, attr, flags)
741:       return store_internal("UID STORE", set, attr, flags)
742:     end

As for thread(), but returns unique identifiers instead of message sequence numbers.

[Source]

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

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.

[Source]

     # File lib/net/imap.rb, line 459
459:     def unsubscribe(mailbox)
460:       send_command("UNSUBSCRIBE", mailbox)
461:     end

Private Instance methods

[Source]

      # File lib/net/imap.rb, line 1216
1216:     def copy_internal(cmd, set, mailbox)
1217:       send_command(cmd, MessageSet.new(set), mailbox)
1218:     end

[Source]

      # File lib/net/imap.rb, line 1188
1188:     def fetch_internal(cmd, set, attr)
1189:       case attr
1190:       when String then
1191:         attr = RawData.new(attr)
1192:       when Array then
1193:         attr = attr.map { |arg|
1194:           arg.is_a?(String) ? RawData.new(arg) : arg
1195:         }
1196:       end
1197: 
1198:       synchronize do
1199:         @responses.delete("FETCH")
1200:         send_command(cmd, MessageSet.new(set), attr)
1201:         return @responses.delete("FETCH")
1202:       end
1203:     end

[Source]

      # File lib/net/imap.rb, line 1064
1064:     def generate_tag
1065:       @tagno += 1
1066:       return format("%s%04d", @tag_prefix, @tagno)
1067:     end

[Source]

      # File lib/net/imap.rb, line 1012
1012:     def get_response
1013:       buff = ""
1014:       while true
1015:         s = @sock.gets(CRLF)
1016:         break unless s
1017:         buff.concat(s)
1018:         if /\{(\d+)\}\r\n/n =~ s
1019:           s = @sock.read($1.to_i)
1020:           buff.concat(s)
1021:         else
1022:           break
1023:         end
1024:       end
1025:       return nil if buff.length == 0
1026:       if @@debug
1027:         $stderr.print(buff.gsub(/^/n, "S: "))
1028:       end
1029:       return @parser.parse(buff)
1030:     end

[Source]

     # File lib/net/imap.rb, line 992
992:     def get_tagged_response(tag)
993:       until @tagged_responses.key?(tag)
994:         raise @exception if @exception
995:         @response_arrival.wait
996:       end
997:       return pick_up_tagged_response(tag)
998:     end

[Source]

      # File lib/net/imap.rb, line 1244
1244:     def normalize_searching_criteria(keys)
1245:       keys.collect! do |i|
1246:         case i
1247:         when -1, Range, Array
1248:           MessageSet.new(i)
1249:         else
1250:           i
1251:         end
1252:       end
1253:     end

[Source]

      # File lib/net/imap.rb, line 1000
1000:     def pick_up_tagged_response(tag)
1001:       resp = @tagged_responses.delete(tag)
1002:       case resp.name
1003:       when /\A(?:NO)\z/ni
1004:         raise NoResponseError, resp.data.text
1005:       when /\A(?:BAD)\z/ni
1006:         raise BadResponseError, resp.data.text
1007:       else
1008:         return resp
1009:       end
1010:     end

[Source]

      # File lib/net/imap.rb, line 1069
1069:     def put_string(str)
1070:       @sock.print(str)
1071:       if @@debug
1072:         if @debug_output_bol
1073:           $stderr.print("C: ")
1074:         end
1075:         $stderr.print(str.gsub(/\n(?!\z)/n, "\nC: "))
1076:         if /\r\n\z/n.match(str)
1077:           @debug_output_bol = true
1078:         else
1079:           @debug_output_bol = false
1080:         end
1081:       end
1082:     end

[Source]

     # File lib/net/imap.rb, line 931
931:     def receive_responses
932:       while true
933:         synchronize do
934:           @exception = nil
935:         end
936:         begin
937:           resp = get_response
938:         rescue Exception => e
939:           synchronize do
940:             @sock.close unless @sock.closed?
941:             @exception = e
942:           end
943:           break
944:         end
945:         unless resp
946:           synchronize do
947:             @exception = EOFError.new("end of file reached")
948:           end
949:           break
950:         end
951:         begin
952:           synchronize do
953:             case resp
954:             when TaggedResponse
955:               @tagged_responses[resp.tag] = resp
956:               @response_arrival.broadcast
957:               if resp.tag == @logout_command_tag
958:                 return
959:               end
960:             when UntaggedResponse
961:               record_response(resp.name, resp.data)
962:               if resp.data.instance_of?(ResponseText) &&
963:                   (code = resp.data.code)
964:                 record_response(code.name, code.data)
965:               end
966:               if resp.name == "BYE" && @logout_command_tag.nil?
967:                 @sock.close
968:                 @exception = ByeResponseError.new(resp.raw_data)
969:                 @response_arrival.broadcast
970:                 return
971:               end
972:             when ContinuationRequest
973:               @continuation_request = resp
974:               @response_arrival.broadcast
975:             end
976:             @response_handlers.each do |handler|
977:               handler.call(resp)
978:             end
979:           end
980:         rescue Exception => e
981:           @exception = e
982:           synchronize do
983:             @response_arrival.broadcast
984:           end
985:         end
986:       end
987:       synchronize do
988:         @response_arrival.broadcast
989:       end
990:     end

[Source]

      # File lib/net/imap.rb, line 1032
1032:     def record_response(name, data)
1033:       unless @responses.has_key?(name)
1034:         @responses[name] = []
1035:       end
1036:       @responses[name].push(data)
1037:     end

[Source]

      # File lib/net/imap.rb, line 1172
1172:     def search_internal(cmd, keys, charset)
1173:       if keys.instance_of?(String)
1174:         keys = [RawData.new(keys)]
1175:       else
1176:         normalize_searching_criteria(keys)
1177:       end
1178:       synchronize do
1179:         if charset
1180:           send_command(cmd, "CHARSET", charset, *keys)
1181:         else
1182:           send_command(cmd, *keys)
1183:         end
1184:         return @responses.delete("SEARCH")[-1]
1185:       end
1186:     end

[Source]

      # File lib/net/imap.rb, line 1039
1039:     def send_command(cmd, *args, &block)
1040:       synchronize do
1041:         tag = Thread.current[:net_imap_tag] = generate_tag
1042:         put_string(tag + " " + cmd)
1043:         args.each do |i|
1044:           put_string(" ")
1045:           send_data(i)
1046:         end
1047:         put_string(CRLF)
1048:         if cmd == "LOGOUT"
1049:           @logout_command_tag = tag
1050:         end
1051:         if block
1052:           add_response_handler(block)
1053:         end
1054:         begin
1055:           return get_tagged_response(tag)
1056:         ensure
1057:           if block
1058:             remove_response_handler(block)
1059:           end
1060:         end
1061:       end
1062:     end

[Source]

      # File lib/net/imap.rb, line 1084
1084:     def send_data(data)
1085:       case data
1086:       when nil
1087:         put_string("NIL")
1088:       when String
1089:         send_string_data(data)
1090:       when Integer
1091:         send_number_data(data)
1092:       when Array
1093:         send_list_data(data)
1094:       when Time
1095:         send_time_data(data)
1096:       when Symbol
1097:         send_symbol_data(data)
1098:       else
1099:         data.send_data(self)
1100:       end
1101:     end

[Source]

      # File lib/net/imap.rb, line 1144
1144:     def send_list_data(list)
1145:       put_string("(")
1146:       first = true
1147:       list.each do |i|
1148:         if first
1149:           first = false
1150:         else
1151:           put_string(" ")
1152:         end
1153:         send_data(i)
1154:       end
1155:       put_string(")")
1156:     end

[Source]

      # File lib/net/imap.rb, line 1122
1122:     def send_literal(str)
1123:       put_string("{" + str.length.to_s + "}" + CRLF)
1124:       while @continuation_request.nil? &&
1125:         !@tagged_responses.key?(Thread.current[:net_imap_tag])
1126:         @response_arrival.wait
1127:         raise @exception if @exception
1128:       end
1129:       if @continuation_request.nil?
1130:         pick_up_tagged_response(Thread.current[:net_imap_tag])
1131:         raise ResponseError.new("expected continuation request")
1132:       end
1133:       @continuation_request = nil
1134:       put_string(str)
1135:     end

[Source]

      # File lib/net/imap.rb, line 1137
1137:     def send_number_data(num)
1138:       if num < 0 || num >= 4294967296
1139:         raise DataFormatError, num.to_s
1140:       end
1141:       put_string(num.to_s)
1142:     end

[Source]

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

[Source]

      # File lib/net/imap.rb, line 1103
1103:     def send_string_data(str)
1104:       case str
1105:       when ""
1106:         put_string('""')
1107:       when /[\x80-\xff\r\n]/n
1108:         # literal
1109:         send_literal(str)
1110:       when /[(){ \x00-\x1f\x7f%*"\\]/n
1111:         # quoted string
1112:         send_quoted_string(str)
1113:       else
1114:         put_string(str)
1115:       end
1116:     end

[Source]

      # File lib/net/imap.rb, line 1168
1168:     def send_symbol_data(symbol)
1169:       put_string("\\" + symbol.to_s)
1170:     end

[Source]

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

[Source]

      # File lib/net/imap.rb, line 1220
1220:     def sort_internal(cmd, sort_keys, search_keys, charset)
1221:       if search_keys.instance_of?(String)
1222:         search_keys = [RawData.new(search_keys)]
1223:       else
1224:         normalize_searching_criteria(search_keys)
1225:       end
1226:       normalize_searching_criteria(search_keys)
1227:       synchronize do
1228:         send_command(cmd, sort_keys, charset, *search_keys)
1229:         return @responses.delete("SORT")[-1]
1230:       end
1231:     end

[Source]

      # File lib/net/imap.rb, line 1205
1205:     def store_internal(cmd, set, attr, flags)
1206:       if attr.instance_of?(String)
1207:         attr = RawData.new(attr)
1208:       end
1209:       synchronize do
1210:         @responses.delete("FETCH")
1211:         send_command(cmd, MessageSet.new(set), attr, flags)
1212:         return @responses.delete("FETCH")
1213:       end
1214:     end

[Source]

      # File lib/net/imap.rb, line 1233
1233:     def thread_internal(cmd, algorithm, search_keys, charset)
1234:       if search_keys.instance_of?(String)
1235:         search_keys = [RawData.new(search_keys)]
1236:       else
1237:         normalize_searching_criteria(search_keys)
1238:       end
1239:       normalize_searching_criteria(search_keys)
1240:       send_command(cmd, algorithm, charset, *search_keys)
1241:       return @responses.delete("THREAD")[-1]
1242:     end

[Validate]