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].
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.
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
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
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.
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.
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:
|
|||||||||||||||||||||
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:
|
|||||||||||||||||||||
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:
|
|||||||||||||||||||||
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:
|
|||||||||||||||||||||
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:
|
|||||||||||||||||||||
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:
|
|||||||||||||||||||||
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:
|
|||||||||||||||||||||
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:
|
|||||||||||||||||||||
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:
|
|||||||||||||||||||||
StatusData | = | Struct.new(:mailbox, :attr) |
Net::IMAP::StatusData represents contents of the STATUS response.
Fields:
|
|||||||||||||||||||||
FetchData | = | Struct.new(:seqno, :attr) |
Net::IMAP::FetchData represents contents of the FETCH response.
Fields:
|
|||||||||||||||||||||
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:
|
|||||||||||||||||||||
Address | = | Struct.new(:name, :route, :mailbox, :host) |
Net::IMAP::Address represents electronic mail addresses.
Fields:
|
|||||||||||||||||||||
ContentDisposition | = | Struct.new(:dsp_type, :param) |
Net::IMAP::ContentDisposition represents Content-Disposition fields.
Fields:
|
|||||||||||||||||||||
ThreadMember | = | Struct.new(:seqno, :children) |
Net::IMAP::ThreadMember represents a thread-node returned by Net::IMAP#thread
Fields:
items that are children of this in the thread. |
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 |
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.
# File lib/net/imap.rb, line 281 281: def self.add_authenticator(auth_type, authenticator) 282: @@authenticators[auth_type] = authenticator 283: 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.
# 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.
# File lib/net/imap.rb, line 843 843: def self.encode_utf7(s) 844: return s.gsub(/(&)|([^\x20-\x25\x27-\x7e]+)/n) { |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. |
# 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.connect # start ssl session. 905: @sock.post_connection_check(@host) if verify 906: else 907: @usessl = false 908: end 909: @responses = Hash.new([].freeze) 910: @tagged_responses = {} 911: @response_handlers = [] 912: @response_arrival = new_cond 913: @continuation_request = nil 914: @logout_command_tag = nil 915: @debug_output_bol = true 916: 917: @greeting = get_response 918: if @greeting.name == "BYE" 919: @sock.close 920: raise ByeResponseError, @greeting.raw_data 921: end 922: 923: @client_thread = Thread.current 924: @receiver_thread = Thread.start { 925: receive_responses 926: } 927: end
# File lib/net/imap.rb, line 1227 1227: def self.u16tou8(s) 1228: len = s.length 1229: if len < 2 1230: return "" 1231: end 1232: buf = "" 1233: i = 0 1234: while i < len 1235: c = s[i] << 8 | s[i + 1] 1236: i += 2 1237: if c == 0xfeff 1238: next 1239: elsif c < 0x0080 1240: buf.concat(c) 1241: elsif c < 0x0800 1242: b2 = c & 0x003f 1243: b1 = c >> 6 1244: buf.concat(b1 | 0xc0) 1245: buf.concat(b2 | 0x80) 1246: elsif c >= 0xdc00 && c < 0xe000 1247: raise DataFormatError, "invalid surrogate detected" 1248: elsif c >= 0xd800 && c < 0xdc00 1249: if i + 2 > len 1250: raise DataFormatError, "invalid surrogate detected" 1251: end 1252: low = s[i] << 8 | s[i + 1] 1253: i += 2 1254: if low < 0xdc00 || low > 0xdfff 1255: raise DataFormatError, "invalid surrogate detected" 1256: end 1257: c = (((c & 0x03ff)) << 10 | (low & 0x03ff)) + 0x10000 1258: b4 = c & 0x003f 1259: b3 = (c >> 6) & 0x003f 1260: b2 = (c >> 12) & 0x003f 1261: b1 = c >> 18; 1262: buf.concat(b1 | 0xf0) 1263: buf.concat(b2 | 0x80) 1264: buf.concat(b3 | 0x80) 1265: buf.concat(b4 | 0x80) 1266: else # 0x0800-0xffff 1267: b3 = c & 0x003f 1268: b2 = (c >> 6) & 0x003f 1269: b1 = c >> 12 1270: buf.concat(b1 | 0xe0) 1271: buf.concat(b2 | 0x80) 1272: buf.concat(b3 | 0x80) 1273: end 1274: end 1275: return buf 1276: end
# File lib/net/imap.rb, line 1279 1279: def self.u8tou16(s) 1280: len = s.length 1281: buf = "" 1282: i = 0 1283: while i < len 1284: c = s[i] 1285: if (c & 0x80) == 0 1286: buf.concat(0x00) 1287: buf.concat(c) 1288: i += 1 1289: elsif (c & 0xe0) == 0xc0 && 1290: len >= 2 && 1291: (s[i + 1] & 0xc0) == 0x80 1292: if c == 0xc0 || c == 0xc1 1293: raise DataFormatError, format("non-shortest UTF-8 sequence (%02x)", c) 1294: end 1295: u = ((c & 0x1f) << 6) | (s[i + 1] & 0x3f) 1296: buf.concat(u >> 8) 1297: buf.concat(u & 0x00ff) 1298: i += 2 1299: elsif (c & 0xf0) == 0xe0 && 1300: i + 2 < len && 1301: (s[i + 1] & 0xc0) == 0x80 && 1302: (s[i + 2] & 0xc0) == 0x80 1303: if c == 0xe0 && s[i + 1] < 0xa0 1304: raise DataFormatError, format("non-shortest UTF-8 sequence (%02x)", c) 1305: end 1306: u = ((c & 0x0f) << 12) | ((s[i + 1] & 0x3f) << 6) | (s[i + 2] & 0x3f) 1307: # surrogate chars 1308: if u >= 0xd800 && u <= 0xdfff 1309: raise DataFormatError, format("none-UTF-16 char detected (%04x)", u) 1310: end 1311: buf.concat(u >> 8) 1312: buf.concat(u & 0x00ff) 1313: i += 3 1314: elsif (c & 0xf8) == 0xf0 && 1315: i + 3 < len && 1316: (s[i + 1] & 0xc0) == 0x80 && 1317: (s[i + 2] & 0xc0) == 0x80 && 1318: (s[i + 3] & 0xc0) == 0x80 1319: if c == 0xf0 && s[i + 1] < 0x90 1320: raise DataFormatError, format("non-shortest UTF-8 sequence (%02x)", c) 1321: end 1322: u = ((c & 0x07) << 18) | ((s[i + 1] & 0x3f) << 12) | 1323: ((s[i + 2] & 0x3f) << 6) | (s[i + 3] & 0x3f) 1324: if u < 0x10000 1325: buf.concat(u >> 8) 1326: buf.concat(u & 0x00ff) 1327: elsif u < 0x110000 1328: high = ((u - 0x10000) >> 10) | 0xd800 1329: low = (u & 0x03ff) | 0xdc00 1330: buf.concat(high >> 8) 1331: buf.concat(high & 0x00ff) 1332: buf.concat(low >> 8) 1333: buf.concat(low & 0x00ff) 1334: else 1335: raise DataFormatError, format("none-UTF-16 char detected (%04x)", u) 1336: end 1337: i += 4 1338: else 1339: raise DataFormatError, format("illegal UTF-8 sequence (%02x)", c) 1340: end 1341: end 1342: return buf 1343: end
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 }
# 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.
# 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.
# 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.
# 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.
# File lib/net/imap.rb, line 620 620: def check 621: send_command("CHECK") 622: 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.
# 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.
# 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.
# File lib/net/imap.rb, line 428 428: def delete(mailbox) 429: send_command("DELETE", mailbox) 430: end
Disconnects from the server.
# 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.
# 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.
# 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.
# 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
# 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.
# 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.
# 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.
# 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">]
# 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.
# 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.
# 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+.
# 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.
# File lib/net/imap.rb, line 321 321: def noop 322: send_command("NOOP") 323: end
Removes the response handler.
# 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.
# 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]
# 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.
# 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].
# 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].
# 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.
# 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.
# 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]}>]
# 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.
# 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.
# 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
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 459 459: def unsubscribe(mailbox) 460: send_command("UNSUBSCRIBE", mailbox) 461: end
# File lib/net/imap.rb, line 1188 1188: def copy_internal(cmd, set, mailbox) 1189: send_command(cmd, MessageSet.new(set), mailbox) 1190: end
# File lib/net/imap.rb, line 1166 1166: def fetch_internal(cmd, set, attr) 1167: if attr.instance_of?(String) 1168: attr = RawData.new(attr) 1169: end 1170: synchronize do 1171: @responses.delete("FETCH") 1172: send_command(cmd, MessageSet.new(set), attr) 1173: return @responses.delete("FETCH") 1174: end 1175: end
# File lib/net/imap.rb, line 1043 1043: def generate_tag 1044: @tagno += 1 1045: return format("%s%04d", @tag_prefix, @tagno) 1046: end
# File lib/net/imap.rb, line 991 991: def get_response 992: buff = "" 993: while true 994: s = @sock.gets(CRLF) 995: break unless s 996: buff.concat(s) 997: if /\{(\d+)\}\r\n/n =~ s 998: s = @sock.read($1.to_i) 999: buff.concat(s) 1000: else 1001: break 1002: end 1003: end 1004: return nil if buff.length == 0 1005: if @@debug 1006: $stderr.print(buff.gsub(/^/n, "S: ")) 1007: end 1008: return @parser.parse(buff) 1009: end
# File lib/net/imap.rb, line 972 972: def get_tagged_response(tag) 973: until @tagged_responses.key?(tag) 974: @response_arrival.wait 975: end 976: return pick_up_tagged_response(tag) 977: end
# File lib/net/imap.rb, line 1216 1216: def normalize_searching_criteria(keys) 1217: keys.collect! do |i| 1218: case i 1219: when -1, Range, Array 1220: MessageSet.new(i) 1221: else 1222: i 1223: end 1224: end 1225: end
# File lib/net/imap.rb, line 979 979: def pick_up_tagged_response(tag) 980: resp = @tagged_responses.delete(tag) 981: case resp.name 982: when /\A(?:NO)\z/ni 983: raise NoResponseError, resp.data.text 984: when /\A(?:BAD)\z/ni 985: raise BadResponseError, resp.data.text 986: else 987: return resp 988: end 989: end
# File lib/net/imap.rb, line 1048 1048: def put_string(str) 1049: @sock.print(str) 1050: if @@debug 1051: if @debug_output_bol 1052: $stderr.print("C: ") 1053: end 1054: $stderr.print(str.gsub(/\n(?!\z)/n, "\nC: ")) 1055: if /\r\n\z/n.match(str) 1056: @debug_output_bol = true 1057: else 1058: @debug_output_bol = false 1059: end 1060: end 1061: end
# File lib/net/imap.rb, line 929 929: def receive_responses 930: while true 931: begin 932: resp = get_response 933: rescue Exception 934: @sock.close 935: @client_thread.raise($!) 936: break 937: end 938: break unless resp 939: begin 940: synchronize do 941: case resp 942: when TaggedResponse 943: @tagged_responses[resp.tag] = resp 944: @response_arrival.broadcast 945: if resp.tag == @logout_command_tag 946: return 947: end 948: when UntaggedResponse 949: record_response(resp.name, resp.data) 950: if resp.data.instance_of?(ResponseText) && 951: (code = resp.data.code) 952: record_response(code.name, code.data) 953: end 954: if resp.name == "BYE" && @logout_command_tag.nil? 955: @sock.close 956: raise ByeResponseError, resp.raw_data 957: end 958: when ContinuationRequest 959: @continuation_request = resp 960: @response_arrival.broadcast 961: end 962: @response_handlers.each do |handler| 963: handler.call(resp) 964: end 965: end 966: rescue Exception 967: @client_thread.raise($!) 968: end 969: end 970: end
# File lib/net/imap.rb, line 1011 1011: def record_response(name, data) 1012: unless @responses.has_key?(name) 1013: @responses[name] = [] 1014: end 1015: @responses[name].push(data) 1016: end
# File lib/net/imap.rb, line 1150 1150: def search_internal(cmd, keys, charset) 1151: if keys.instance_of?(String) 1152: keys = [RawData.new(keys)] 1153: else 1154: normalize_searching_criteria(keys) 1155: end 1156: synchronize do 1157: if charset 1158: send_command(cmd, "CHARSET", charset, *keys) 1159: else 1160: send_command(cmd, *keys) 1161: end 1162: return @responses.delete("SEARCH")[-1] 1163: end 1164: end
# File lib/net/imap.rb, line 1018 1018: def send_command(cmd, *args, &block) 1019: synchronize do 1020: tag = Thread.current[:net_imap_tag] = generate_tag 1021: put_string(tag + " " + cmd) 1022: args.each do |i| 1023: put_string(" ") 1024: send_data(i) 1025: end 1026: put_string(CRLF) 1027: if cmd == "LOGOUT" 1028: @logout_command_tag = tag 1029: end 1030: if block 1031: add_response_handler(block) 1032: end 1033: begin 1034: return get_tagged_response(tag) 1035: ensure 1036: if block 1037: remove_response_handler(block) 1038: end 1039: end 1040: end 1041: end
# File lib/net/imap.rb, line 1063 1063: def send_data(data) 1064: case data 1065: when nil 1066: put_string("NIL") 1067: when String 1068: send_string_data(data) 1069: when Integer 1070: send_number_data(data) 1071: when Array 1072: send_list_data(data) 1073: when Time 1074: send_time_data(data) 1075: when Symbol 1076: send_symbol_data(data) 1077: else 1078: data.send_data(self) 1079: end 1080: end
# File lib/net/imap.rb, line 1122 1122: def send_list_data(list) 1123: put_string("(") 1124: first = true 1125: list.each do |i| 1126: if first 1127: first = false 1128: else 1129: put_string(" ") 1130: end 1131: send_data(i) 1132: end 1133: put_string(")") 1134: end
# File lib/net/imap.rb, line 1101 1101: def send_literal(str) 1102: put_string("{" + str.length.to_s + "}" + CRLF) 1103: while @continuation_request.nil? && 1104: !@tagged_responses.key?(Thread.current[:net_imap_tag]) 1105: @response_arrival.wait 1106: end 1107: if @continuation_request.nil? 1108: pick_up_tagged_response(Thread.current[:net_imap_tag]) 1109: raise ResponseError.new("expected continuation request") 1110: end 1111: @continuation_request = nil 1112: put_string(str) 1113: end
# File lib/net/imap.rb, line 1115 1115: def send_number_data(num) 1116: if num < 0 || num >= 4294967296 1117: raise DataFormatError, num.to_s 1118: end 1119: put_string(num.to_s) 1120: end
# File lib/net/imap.rb, line 1097 1097: def send_quoted_string(str) 1098: put_string('"' + str.gsub(/["\\]/n, "\\\\\\&") + '"') 1099: end
# File lib/net/imap.rb, line 1082 1082: def send_string_data(str) 1083: case str 1084: when "" 1085: put_string('""') 1086: when /[\x80-\xff\r\n]/n 1087: # literal 1088: send_literal(str) 1089: when /[(){ \x00-\x1f\x7f%*"\\]/n 1090: # quoted string 1091: send_quoted_string(str) 1092: else 1093: put_string(str) 1094: end 1095: end
# File lib/net/imap.rb, line 1146 1146: def send_symbol_data(symbol) 1147: put_string("\\" + symbol.to_s) 1148: end
# File lib/net/imap.rb, line 1138 1138: def send_time_data(time) 1139: t = time.dup.gmtime 1140: s = format('"%2d-%3s-%4d %02d:%02d:%02d +0000"', 1141: t.day, DATE_MONTH[t.month - 1], t.year, 1142: t.hour, t.min, t.sec) 1143: put_string(s) 1144: end
# File lib/net/imap.rb, line 1192 1192: def sort_internal(cmd, sort_keys, search_keys, charset) 1193: if search_keys.instance_of?(String) 1194: search_keys = [RawData.new(search_keys)] 1195: else 1196: normalize_searching_criteria(search_keys) 1197: end 1198: normalize_searching_criteria(search_keys) 1199: synchronize do 1200: send_command(cmd, sort_keys, charset, *search_keys) 1201: return @responses.delete("SORT")[-1] 1202: end 1203: end
# File lib/net/imap.rb, line 1177 1177: def store_internal(cmd, set, attr, flags) 1178: if attr.instance_of?(String) 1179: attr = RawData.new(attr) 1180: end 1181: synchronize do 1182: @responses.delete("FETCH") 1183: send_command(cmd, MessageSet.new(set), attr, flags) 1184: return @responses.delete("FETCH") 1185: end 1186: end
# File lib/net/imap.rb, line 1205 1205: def thread_internal(cmd, algorithm, search_keys, charset) 1206: if search_keys.instance_of?(String) 1207: search_keys = [RawData.new(search_keys)] 1208: else 1209: normalize_searching_criteria(search_keys) 1210: end 1211: normalize_searching_criteria(search_keys) 1212: send_command(cmd, algorithm, charset, *search_keys) 1213: return @responses.delete("THREAD")[-1] 1214: end