зеркало из https://github.com/github/ruby.git
2879 строки
64 KiB
Ruby
2879 строки
64 KiB
Ruby
=begin
|
|
|
|
= net/imap.rb
|
|
|
|
Copyright (C) 2000 Shugo Maeda <shugo@ruby-lang.org>
|
|
|
|
This library is distributed under the terms of the Ruby license.
|
|
You can freely distribute/modify this library.
|
|
|
|
== Net::IMAP
|
|
|
|
Net::IMAP implements Internet Message Access Protocol (IMAP) clients.
|
|
(The protocol is described in ((<[IMAP]>)).)
|
|
|
|
Net::IMAP supports multiple commands. 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.
|
|
|
|
=== Super Class
|
|
|
|
Object
|
|
|
|
=== Class Methods
|
|
|
|
: new(host, port = 143, usessl = false, certs = nil, verify = false)
|
|
Creates a new Net::IMAP object and connects it to the specified
|
|
port 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]>))
|
|
extension 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.
|
|
|
|
: debug
|
|
Returns the debug mode.
|
|
|
|
: debug = val
|
|
Sets the debug mode.
|
|
|
|
: add_authenticator(auth_type, authenticator)
|
|
Adds an authenticator for Net::IMAP#authenticate.
|
|
|
|
=== Methods
|
|
|
|
: greeting
|
|
Returns an initial greeting response from the server.
|
|
|
|
: responses
|
|
Returns recorded untagged responses.
|
|
|
|
ex).
|
|
imap.select("inbox")
|
|
p imap.responses["EXISTS"][-1]
|
|
#=> 2
|
|
p imap.responses["UIDVALIDITY"][-1]
|
|
#=> 968263756
|
|
|
|
: disconnect
|
|
Disconnects from the server.
|
|
|
|
: capability
|
|
Sends a CAPABILITY command, and returns a listing of
|
|
capabilities that the server supports.
|
|
|
|
: noop
|
|
Sends a NOOP command to the server. It does nothing.
|
|
|
|
: logout
|
|
Sends a LOGOUT command to inform the server that the client is
|
|
done with the connection.
|
|
|
|
: authenticate(auth_type, arg...)
|
|
Sends an AUTEHNTICATE command to authenticate the client.
|
|
The auth_type parameter is a string that represents
|
|
the authentication mechanism to be used. Currently Net::IMAP
|
|
supports "LOGIN" and "CRAM-MD5" for the auth_type.
|
|
|
|
ex).
|
|
imap.authenticate('LOGIN', user, password)
|
|
|
|
: login(user, password)
|
|
Sends a LOGIN command to identify the client and carries
|
|
the plaintext password authenticating this user.
|
|
|
|
: select(mailbox)
|
|
Sends a SELECT command to select a mailbox so that messages
|
|
in the mailbox can be accessed.
|
|
|
|
: examine(mailbox)
|
|
Sends a EXAMINE command to select a mailbox so that messages
|
|
in the mailbox can be accessed. However, the selected mailbox
|
|
is identified as read-only.
|
|
|
|
: create(mailbox)
|
|
Sends a CREATE command to create a new mailbox.
|
|
|
|
: delete(mailbox)
|
|
Sends a DELETE command to remove the mailbox.
|
|
|
|
: rename(mailbox, newname)
|
|
Sends a RENAME command to change the name of the mailbox to
|
|
the newname.
|
|
|
|
: subscribe(mailbox)
|
|
Sends a SUBSCRIBE command to add the specified mailbox name to
|
|
the server's set of "active" or "subscribed" mailboxes.
|
|
|
|
: unsubscribe(mailbox)
|
|
Sends a UNSUBSCRIBE command to remove the specified mailbox name
|
|
from the server's set of "active" or "subscribed" mailboxes.
|
|
|
|
: list(refname, mailbox)
|
|
Sends a LIST command, and returns a subset of names from
|
|
the complete set of all names available to the client.
|
|
The return value is an array of ((<Net::IMAP::MailboxList>)).
|
|
|
|
ex).
|
|
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">]
|
|
|
|
: lsub(refname, mailbox)
|
|
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".
|
|
The return value is an array of ((<Net::IMAP::MailboxList>)).
|
|
|
|
: status(mailbox, attr)
|
|
Sends a STATUS command, and returns the status of the indicated
|
|
mailbox.
|
|
The return value is a hash of attributes.
|
|
|
|
ex).
|
|
p imap.status("inbox", ["MESSAGES", "RECENT"])
|
|
#=> {"RECENT"=>0, "MESSAGES"=>44}
|
|
|
|
: append(mailbox, message, flags = nil, date_time = nil)
|
|
Sends a APPEND command to append the message to the end of
|
|
the mailbox.
|
|
|
|
ex).
|
|
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
|
|
|
|
: check
|
|
Sends a CHECK command to request a checkpoint of the currently
|
|
selected mailbox.
|
|
|
|
: close
|
|
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.
|
|
|
|
: expunge
|
|
Sends a EXPUNGE command to permanently remove from the currently
|
|
selected mailbox all messages that have the \Deleted flag set.
|
|
|
|
: search(keys, charset = nil)
|
|
: uid_search(keys, charset = nil)
|
|
Sends a SEARCH command to search the mailbox for messages that
|
|
match the given searching criteria, and returns message sequence
|
|
numbers (search) or unique identifiers (uid_search).
|
|
|
|
ex).
|
|
p imap.search(["SUBJECT", "hello"])
|
|
#=> [1, 6, 7, 8]
|
|
p imap.search('SUBJECT "hello"')
|
|
#=> [1, 6, 7, 8]
|
|
|
|
: fetch(set, attr)
|
|
: uid_fetch(set, attr)
|
|
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 (fetch) or a unique identifier (uid_fetch).
|
|
The return value is an array of ((<Net::IMAP::FetchData>)).
|
|
|
|
ex).
|
|
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
|
|
|
|
: store(set, attr, flags)
|
|
: uid_store(set, attr, flags)
|
|
Sends a STORE command to alter 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 (store) or a unique identifier (uid_store).
|
|
The return value is an array of ((<Net::IMAP::FetchData>)).
|
|
|
|
ex).
|
|
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]}>]
|
|
|
|
: copy(set, mailbox)
|
|
: uid_copy(set, mailbox)
|
|
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 (copy) or a unique identifier (uid_copy).
|
|
|
|
: sort(sort_keys, search_keys, charset)
|
|
: uid_sort(sort_keys, search_keys, charset)
|
|
Sends a SORT command to sort messages in the mailbox.
|
|
|
|
ex).
|
|
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]
|
|
|
|
: setquota(mailbox, quota)
|
|
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]>)).
|
|
|
|
: getquota(mailbox)
|
|
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.
|
|
|
|
: getquotaroot(mailbox)
|
|
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>)).
|
|
|
|
: setacl(mailbox, user, rights)
|
|
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]>)).
|
|
|
|
: getacl(mailbox)
|
|
Send the GETACL command along with specified mailbox.
|
|
If this mailbox exists, an array containing objects of
|
|
((<Net::IMAP::MailboxACLItem>)) will be returned.
|
|
|
|
: add_response_handler(handler = Proc.new)
|
|
Adds a response handler.
|
|
|
|
ex).
|
|
imap.add_response_handler do |resp|
|
|
p resp
|
|
end
|
|
|
|
: remove_response_handler(handler)
|
|
Removes the response handler.
|
|
|
|
: response_handlers
|
|
Returns all response handlers.
|
|
|
|
== Net::IMAP::ContinuationRequest
|
|
|
|
Net::IMAP::ContinuationRequest represents command continuation requests.
|
|
|
|
The command continuation request response is indicated by a "+" token
|
|
instead of a tag. This form of response indicates that the server is
|
|
ready to accept the continuation of a command from the client. The
|
|
remainder of this response is a line of text.
|
|
|
|
continue_req ::= "+" SPACE (resp_text / base64)
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: data
|
|
Returns the data (Net::IMAP::ResponseText).
|
|
|
|
: raw_data
|
|
Returns the raw data string.
|
|
|
|
== Net::IMAP::UntaggedResponse
|
|
|
|
Net::IMAP::UntaggedResponse represents untagged responses.
|
|
|
|
Data transmitted by the server to the client and status responses
|
|
that do not indicate command completion are prefixed with the token
|
|
"*", and are called untagged responses.
|
|
|
|
response_data ::= "*" SPACE (resp_cond_state / resp_cond_bye /
|
|
mailbox_data / message_data / capability_data)
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: 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.
|
|
|
|
== Net::IMAP::TaggedResponse
|
|
|
|
Net::IMAP::TaggedResponse represents tagged responses.
|
|
|
|
The server completion result response indicates the success or
|
|
failure of the operation. It is tagged with the same tag as the
|
|
client command which began the operation.
|
|
|
|
response_tagged ::= tag SPACE resp_cond_state CRLF
|
|
|
|
tag ::= 1*<any ATOM_CHAR except "+">
|
|
|
|
resp_cond_state ::= ("OK" / "NO" / "BAD") SPACE resp_text
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: 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.
|
|
|
|
== Net::IMAP::ResponseText
|
|
|
|
Net::IMAP::ResponseText represents texts of responses.
|
|
The text may be prefixed by the response code.
|
|
|
|
resp_text ::= ["[" resp_text_code "]" SPACE] (text_mime2 / text)
|
|
;; text SHOULD NOT begin with "[" or "="
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: code
|
|
Returns the response code. See ((<Net::IMAP::ResponseCode>)).
|
|
|
|
: text
|
|
Returns the text.
|
|
|
|
== Net::IMAP::ResponseCode
|
|
|
|
Net::IMAP::ResponseCode represents response codes.
|
|
|
|
resp_text_code ::= "ALERT" / "PARSE" /
|
|
"PERMANENTFLAGS" SPACE "(" #(flag / "\*") ")" /
|
|
"READ-ONLY" / "READ-WRITE" / "TRYCREATE" /
|
|
"UIDVALIDITY" SPACE nz_number /
|
|
"UNSEEN" SPACE nz_number /
|
|
atom [SPACE 1*<any TEXT_CHAR except "]">]
|
|
|
|
=== SuperClass
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: name
|
|
Returns the name such as "ALERT", "PERMANENTFLAGS", "UIDVALIDITY"....
|
|
|
|
: data
|
|
Returns the data if it exists.
|
|
|
|
== Net::IMAP::MailboxList
|
|
|
|
Net::IMAP::MailboxList represents contents of the LIST response.
|
|
|
|
mailbox_list ::= "(" #("\Marked" / "\Noinferiors" /
|
|
"\Noselect" / "\Unmarked" / flag_extension) ")"
|
|
SPACE (<"> QUOTED_CHAR <"> / nil) SPACE mailbox
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: 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.
|
|
|
|
== Net::IMAP::MailboxQuota
|
|
|
|
Net::IMAP::MailboxQuota represents contents of GETQUOTA response.
|
|
This object can also be a response to GETQUOTAROOT. In the syntax
|
|
specification below, the delimiter used with the "#" construct is a
|
|
single space (SPACE).
|
|
|
|
quota_list ::= "(" #quota_resource ")"
|
|
|
|
quota_resource ::= atom SPACE number SPACE number
|
|
|
|
quota_response ::= "QUOTA" SPACE astring SPACE quota_list
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: mailbox
|
|
The mailbox with the associated quota.
|
|
|
|
: usage
|
|
Current storage usage of mailbox.
|
|
|
|
: quota
|
|
Quota limit imposed on mailbox.
|
|
|
|
== Net::IMAP::MailboxQuotaRoot
|
|
|
|
Net::IMAP::MailboxQuotaRoot represents part of the GETQUOTAROOT
|
|
response. (GETQUOTAROOT can also return Net::IMAP::MailboxQuota.)
|
|
|
|
quotaroot_response
|
|
::= "QUOTAROOT" SPACE astring *(SPACE astring)
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: mailbox
|
|
The mailbox with the associated quota.
|
|
|
|
: quotaroots
|
|
Zero or more quotaroots that effect the quota on the
|
|
specified mailbox.
|
|
|
|
== Net::IMAP::MailboxACLItem
|
|
|
|
Net::IMAP::MailboxACLItem represents response from GETACL.
|
|
|
|
acl_data ::= "ACL" SPACE mailbox *(SPACE identifier SPACE
|
|
rights)
|
|
|
|
identifier ::= astring
|
|
|
|
rights ::= astring
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: 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.
|
|
|
|
== Net::IMAP::StatusData
|
|
|
|
Net::IMAP::StatusData represents contents of the STATUS response.
|
|
|
|
=== Super Class
|
|
|
|
Object
|
|
|
|
=== Methods
|
|
|
|
: mailbox
|
|
Returns the mailbox name.
|
|
|
|
: attr
|
|
Returns a hash. Each key is one of "MESSAGES", "RECENT", "UIDNEXT",
|
|
"UIDVALIDITY", "UNSEEN". Each value is a number.
|
|
|
|
== Net::IMAP::FetchData
|
|
|
|
Net::IMAP::FetchData represents contents of the FETCH response.
|
|
|
|
=== Super Class
|
|
|
|
Object
|
|
|
|
=== Methods
|
|
|
|
: 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.
|
|
|
|
== Net::IMAP::Envelope
|
|
|
|
Net::IMAP::Envelope represents envelope structures of messages.
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: date
|
|
Retunns a string that represents the date.
|
|
|
|
: subject
|
|
Retunns a string that represents the subject.
|
|
|
|
: from
|
|
Retunns an array of ((<Net::IMAP::Address>)) that represents the from.
|
|
|
|
: sender
|
|
Retunns an array of ((<Net::IMAP::Address>)) that represents the sender.
|
|
|
|
: reply_to
|
|
Retunns an array of ((<Net::IMAP::Address>)) that represents the reply-to.
|
|
|
|
: to
|
|
Retunns an array of ((<Net::IMAP::Address>)) that represents the to.
|
|
|
|
: cc
|
|
Retunns an array of ((<Net::IMAP::Address>)) that represents the cc.
|
|
|
|
: bcc
|
|
Retunns an array of ((<Net::IMAP::Address>)) that represents the bcc.
|
|
|
|
: in_reply_to
|
|
Retunns a string that represents the in-reply-to.
|
|
|
|
: message_id
|
|
Retunns a string that represents the message-id.
|
|
|
|
== Net::IMAP::Address
|
|
|
|
((<Net::IMAP::Address>)) represents electronic mail addresses.
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: 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.
|
|
|
|
== Net::IMAP::ContentDisposition
|
|
|
|
Net::IMAP::ContentDisposition represents Content-Disposition fields.
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: dsp_type
|
|
Returns the disposition type.
|
|
|
|
: param
|
|
Returns a hash that represents parameters of the Content-Disposition
|
|
field.
|
|
|
|
== Net::IMAP::BodyTypeBasic
|
|
|
|
Net::IMAP::BodyTypeBasic represents basic body structures of messages.
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: media_type
|
|
Returns the content media type name as defined in ((<[MIME-IMB]>)).
|
|
|
|
: subtype
|
|
Returns the content subtype name as defined in ((<[MIME-IMB]>)).
|
|
|
|
: param
|
|
Returns a hash that represents parameters as defined in
|
|
((<[MIME-IMB]>)).
|
|
|
|
: content_id
|
|
Returns a string giving the content id as defined in ((<[MIME-IMB]>)).
|
|
|
|
: description
|
|
Returns a string giving the content description as defined in
|
|
((<[MIME-IMB]>)).
|
|
|
|
: encoding
|
|
Returns a string giving the content transfer encoding as defined in
|
|
((<[MIME-IMB]>)).
|
|
|
|
: size
|
|
Returns a number giving the size of the body in octets.
|
|
|
|
: md5
|
|
Returns a string giving the body MD5 value as defined in ((<[MD5]>)).
|
|
|
|
: disposition
|
|
Returns a ((<Net::IMAP::ContentDisposition>)) object giving
|
|
the content disposition.
|
|
|
|
: language
|
|
Returns a string or an array of strings giving the body
|
|
language value as defined in [LANGUAGE-TAGS].
|
|
|
|
: extension
|
|
Returns extension data.
|
|
|
|
: multipart?
|
|
Returns false.
|
|
|
|
== Net::IMAP::BodyTypeText
|
|
|
|
Net::IMAP::BodyTypeText represents TEXT body structures of messages.
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: lines
|
|
Returns the size of the body in text lines.
|
|
|
|
And Net::IMAP::BodyTypeText has all methods of ((<Net::IMAP::BodyTypeBasic>)).
|
|
|
|
== Net::IMAP::BodyTypeMessage
|
|
|
|
Net::IMAP::BodyTypeMessage represents MESSAGE/RFC822 body structures of messages.
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: envelope
|
|
Returns a ((<Net::IMAP::Envelope>)) giving the envelope structure.
|
|
|
|
: body
|
|
Returns an object giving the body structure.
|
|
|
|
And Net::IMAP::BodyTypeMessage has all methods of ((<Net::IMAP::BodyTypeText>)).
|
|
|
|
== Net::IMAP::BodyTypeText
|
|
|
|
=== Super Class
|
|
|
|
Struct
|
|
|
|
=== Methods
|
|
|
|
: media_type
|
|
Returns the content media type name as defined in ((<[MIME-IMB]>)).
|
|
|
|
: subtype
|
|
Returns the content subtype name as defined in ((<[MIME-IMB]>)).
|
|
|
|
: parts
|
|
Returns multiple parts.
|
|
|
|
: param
|
|
Returns a hash that represents parameters as defined in
|
|
((<[MIME-IMB]>)).
|
|
|
|
: disposition
|
|
Returns a ((<Net::IMAP::ContentDisposition>)) object giving
|
|
the content disposition.
|
|
|
|
: language
|
|
Returns a string or an array of strings giving the body
|
|
language value as defined in [LANGUAGE-TAGS].
|
|
|
|
: extension
|
|
Returns extension data.
|
|
|
|
: multipart?
|
|
Returns true.
|
|
|
|
== References
|
|
|
|
: [IMAP]
|
|
M. Crispin, "INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1",
|
|
RFC 2060, December 1996.
|
|
|
|
: [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.
|
|
|
|
: [OSSL]
|
|
http://www.openssl.org
|
|
|
|
: [RSSL]
|
|
http://savannah.gnu.org/projects/rubypki
|
|
|
|
=end
|
|
|
|
require "socket"
|
|
require "monitor"
|
|
require "digest/md5"
|
|
begin
|
|
require "openssl"
|
|
rescue LoadError
|
|
end
|
|
|
|
module Net
|
|
class IMAP
|
|
include MonitorMixin
|
|
if defined?(OpenSSL)
|
|
include OpenSSL
|
|
include SSL
|
|
end
|
|
|
|
attr_reader :greeting, :responses, :response_handlers
|
|
|
|
SEEN = :Seen
|
|
ANSWERED = :Answered
|
|
FLAGGED = :Flagged
|
|
DELETED = :Deleted
|
|
DRAFT = :Draft
|
|
RECENT = :Recent
|
|
|
|
NOINFERIORS = :Noinferiors
|
|
NOSELECT = :Noselect
|
|
MARKED = :Marked
|
|
UNMARKED = :Unmarked
|
|
|
|
def self.debug
|
|
return @@debug
|
|
end
|
|
|
|
def self.debug=(val)
|
|
return @@debug = val
|
|
end
|
|
|
|
def self.add_authenticator(auth_type, authenticator)
|
|
@@authenticators[auth_type] = authenticator
|
|
end
|
|
|
|
def disconnect
|
|
@sock.shutdown unless @usessl
|
|
@receiver_thread.join
|
|
@sock.close
|
|
end
|
|
|
|
def capability
|
|
synchronize do
|
|
send_command("CAPABILITY")
|
|
return @responses.delete("CAPABILITY")[-1]
|
|
end
|
|
end
|
|
|
|
def noop
|
|
send_command("NOOP")
|
|
end
|
|
|
|
def logout
|
|
send_command("LOGOUT")
|
|
end
|
|
|
|
def authenticate(auth_type, *args)
|
|
auth_type = auth_type.upcase
|
|
unless @@authenticators.has_key?(auth_type)
|
|
raise ArgumentError,
|
|
format('unknown auth type - "%s"', auth_type)
|
|
end
|
|
authenticator = @@authenticators[auth_type].new(*args)
|
|
send_command("AUTHENTICATE", auth_type) do |resp|
|
|
if resp.instance_of?(ContinuationRequest)
|
|
data = authenticator.process(resp.data.text.unpack("m")[0])
|
|
send_data([data].pack("m").chomp)
|
|
end
|
|
end
|
|
end
|
|
|
|
def login(user, password)
|
|
send_command("LOGIN", user, password)
|
|
end
|
|
|
|
def select(mailbox)
|
|
synchronize do
|
|
@responses.clear
|
|
send_command("SELECT", mailbox)
|
|
end
|
|
end
|
|
|
|
def examine(mailbox)
|
|
synchronize do
|
|
@responses.clear
|
|
send_command("EXAMINE", mailbox)
|
|
end
|
|
end
|
|
|
|
def create(mailbox)
|
|
send_command("CREATE", mailbox)
|
|
end
|
|
|
|
def delete(mailbox)
|
|
send_command("DELETE", mailbox)
|
|
end
|
|
|
|
def rename(mailbox, newname)
|
|
send_command("RENAME", mailbox, newname)
|
|
end
|
|
|
|
def subscribe(mailbox)
|
|
send_command("SUBSCRIBE", mailbox)
|
|
end
|
|
|
|
def unsubscribe(mailbox)
|
|
send_command("UNSUBSCRIBE", mailbox)
|
|
end
|
|
|
|
def list(refname, mailbox)
|
|
synchronize do
|
|
send_command("LIST", refname, mailbox)
|
|
return @responses.delete("LIST")
|
|
end
|
|
end
|
|
|
|
def getquotaroot(mailbox)
|
|
synchronize do
|
|
send_command("GETQUOTAROOT", mailbox)
|
|
result = []
|
|
result.concat(@responses.delete("QUOTAROOT"))
|
|
result.concat(@responses.delete("QUOTA"))
|
|
return result
|
|
end
|
|
end
|
|
|
|
def getquota(mailbox)
|
|
synchronize do
|
|
send_command("GETQUOTA", mailbox)
|
|
return @responses.delete("QUOTA")
|
|
end
|
|
end
|
|
|
|
# setquota(mailbox, nil) will unset quota.
|
|
def setquota(mailbox, quota)
|
|
if quota.nil?
|
|
data = '()'
|
|
else
|
|
data = '(STORAGE ' + quota.to_s + ')'
|
|
end
|
|
send_command("SETQUOTA", mailbox, RawData.new(data))
|
|
end
|
|
|
|
# setacl(mailbox, user, nil) will remove rights.
|
|
def setacl(mailbox, user, rights)
|
|
if rights.nil?
|
|
send_command("SETACL", mailbox, user, "")
|
|
else
|
|
send_command("SETACL", mailbox, user, rights)
|
|
end
|
|
end
|
|
|
|
def getacl(mailbox)
|
|
synchronize do
|
|
send_command("GETACL", mailbox)
|
|
return @responses.delete("ACL")[-1]
|
|
end
|
|
end
|
|
|
|
def lsub(refname, mailbox)
|
|
synchronize do
|
|
send_command("LSUB", refname, mailbox)
|
|
return @responses.delete("LSUB")
|
|
end
|
|
end
|
|
|
|
def status(mailbox, attr)
|
|
synchronize do
|
|
send_command("STATUS", mailbox, attr)
|
|
return @responses.delete("STATUS")[-1].attr
|
|
end
|
|
end
|
|
|
|
def append(mailbox, message, flags = nil, date_time = nil)
|
|
args = []
|
|
if flags
|
|
args.push(flags)
|
|
end
|
|
args.push(date_time) if date_time
|
|
args.push(Literal.new(message))
|
|
send_command("APPEND", mailbox, *args)
|
|
end
|
|
|
|
def check
|
|
send_command("CHECK")
|
|
end
|
|
|
|
def close
|
|
send_command("CLOSE")
|
|
end
|
|
|
|
def expunge
|
|
synchronize do
|
|
send_command("EXPUNGE")
|
|
return @responses.delete("EXPUNGE")
|
|
end
|
|
end
|
|
|
|
def search(keys, charset = nil)
|
|
return search_internal("SEARCH", keys, charset)
|
|
end
|
|
|
|
def uid_search(keys, charset = nil)
|
|
return search_internal("UID SEARCH", keys, charset)
|
|
end
|
|
|
|
def fetch(set, attr)
|
|
return fetch_internal("FETCH", set, attr)
|
|
end
|
|
|
|
def uid_fetch(set, attr)
|
|
return fetch_internal("UID FETCH", set, attr)
|
|
end
|
|
|
|
def store(set, attr, flags)
|
|
return store_internal("STORE", set, attr, flags)
|
|
end
|
|
|
|
def uid_store(set, attr, flags)
|
|
return store_internal("UID STORE", set, attr, flags)
|
|
end
|
|
|
|
def copy(set, mailbox)
|
|
copy_internal("COPY", set, mailbox)
|
|
end
|
|
|
|
def uid_copy(set, mailbox)
|
|
copy_internal("UID COPY", set, mailbox)
|
|
end
|
|
|
|
def sort(sort_keys, search_keys, charset)
|
|
return sort_internal("SORT", sort_keys, search_keys, charset)
|
|
end
|
|
|
|
def uid_sort(sort_keys, search_keys, charset)
|
|
return sort_internal("UID SORT", sort_keys, search_keys, charset)
|
|
end
|
|
|
|
def add_response_handler(handler = Proc.new)
|
|
@response_handlers.push(handler)
|
|
end
|
|
|
|
def remove_response_handler(handler)
|
|
@response_handlers.delete(handler)
|
|
end
|
|
|
|
private
|
|
|
|
CRLF = "\r\n"
|
|
PORT = 143
|
|
|
|
@@debug = false
|
|
@@authenticators = {}
|
|
|
|
def initialize(host, port = PORT, usessl = false, certs = nil, verify = false)
|
|
super()
|
|
@host = host
|
|
@port = port
|
|
@tag_prefix = "RUBY"
|
|
@tagno = 0
|
|
@parser = ResponseParser.new
|
|
@sock = TCPSocket.open(host, port)
|
|
if usessl
|
|
unless defined?(OpenSSL)
|
|
raise "SSL extension not installed"
|
|
end
|
|
@usessl = true
|
|
@sock = SSLSocket.new(@sock)
|
|
|
|
# verify the server.
|
|
@sock.ca_file = certs if certs && FileTest::file?(certs)
|
|
@sock.ca_path = certs if certs && FileTest::directory?(certs)
|
|
@sock.verify_mode = VERIFY_PEER if verify
|
|
@sock.verify_callback = VerifyCallbackProc if defined?(VerifyCallbackProc)
|
|
|
|
@sock.connect # start ssl session.
|
|
else
|
|
@usessl = false
|
|
end
|
|
@responses = Hash.new([].freeze)
|
|
@tagged_responses = {}
|
|
@response_handlers = []
|
|
@tag_arrival = new_cond
|
|
|
|
@greeting = get_response
|
|
if /\ABYE\z/ni =~ @greeting.name
|
|
@sock.close
|
|
raise ByeResponseError, resp[0]
|
|
end
|
|
|
|
@receiver_thread = Thread.start {
|
|
receive_responses
|
|
}
|
|
end
|
|
|
|
def receive_responses
|
|
while resp = get_response
|
|
synchronize do
|
|
case resp
|
|
when TaggedResponse
|
|
@tagged_responses[resp.tag] = resp
|
|
@tag_arrival.broadcast
|
|
when UntaggedResponse
|
|
record_response(resp.name, resp.data)
|
|
if resp.data.instance_of?(ResponseText) &&
|
|
(code = resp.data.code)
|
|
record_response(code.name, code.data)
|
|
end
|
|
end
|
|
@response_handlers.each do |handler|
|
|
handler.call(resp)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def get_tagged_response(tag, cmd)
|
|
until @tagged_responses.key?(tag)
|
|
@tag_arrival.wait
|
|
end
|
|
resp = @tagged_responses.delete(tag)
|
|
case resp.name
|
|
when /\A(?:NO)\z/ni
|
|
raise NoResponseError, resp.data.text
|
|
when /\A(?:BAD)\z/ni
|
|
raise BadResponseError, resp.data.text
|
|
else
|
|
return resp
|
|
end
|
|
end
|
|
|
|
def get_response
|
|
buff = ""
|
|
while true
|
|
s = @sock.gets(CRLF)
|
|
break unless s
|
|
buff.concat(s)
|
|
if /\{(\d+)\}\r\n/n =~ s
|
|
s = @sock.read($1.to_i)
|
|
buff.concat(s)
|
|
else
|
|
break
|
|
end
|
|
end
|
|
return nil if buff.length == 0
|
|
if @@debug
|
|
$stderr.print(buff.gsub(/^/n, "S: "))
|
|
end
|
|
return @parser.parse(buff)
|
|
end
|
|
|
|
def record_response(name, data)
|
|
unless @responses.has_key?(name)
|
|
@responses[name] = []
|
|
end
|
|
@responses[name].push(data)
|
|
end
|
|
|
|
def send_command(cmd, *args, &block)
|
|
synchronize do
|
|
tag = generate_tag
|
|
data = args.collect {|i| format_data(i)}.join(" ")
|
|
if data.length > 0
|
|
put_line(tag + " " + cmd + " " + data)
|
|
else
|
|
put_line(tag + " " + cmd)
|
|
end
|
|
if block
|
|
add_response_handler(block)
|
|
end
|
|
begin
|
|
return get_tagged_response(tag, cmd)
|
|
ensure
|
|
if block
|
|
remove_response_handler(block)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def generate_tag
|
|
@tagno += 1
|
|
return format("%s%04d", @tag_prefix, @tagno)
|
|
end
|
|
|
|
def send_data(*args)
|
|
data = args.collect {|i| format_data(i)}.join(" ")
|
|
put_line(data)
|
|
end
|
|
|
|
def put_line(line)
|
|
line = line + CRLF
|
|
@sock.print(line)
|
|
if @@debug
|
|
$stderr.print(line.gsub(/^/n, "C: "))
|
|
end
|
|
end
|
|
|
|
def format_data(data)
|
|
case data
|
|
when nil
|
|
return "NIL"
|
|
when String
|
|
return format_string(data)
|
|
when Integer
|
|
return format_number(data)
|
|
when Array
|
|
return format_list(data)
|
|
when Time
|
|
return format_time(data)
|
|
when Symbol
|
|
return format_symbol(data)
|
|
else
|
|
return data.format_data
|
|
end
|
|
end
|
|
|
|
def format_string(str)
|
|
case str
|
|
when ""
|
|
return '""'
|
|
when /[\x80-\xff\r\n]/n
|
|
# literal
|
|
return "{" + str.length.to_s + "}" + CRLF + str
|
|
when /[(){ \x00-\x1f\x7f%*"\\]/n
|
|
# quoted string
|
|
return '"' + str.gsub(/["\\]/n, "\\\\\\&") + '"'
|
|
else
|
|
# atom
|
|
return str
|
|
end
|
|
end
|
|
|
|
def format_number(num)
|
|
if num < 0 || num >= 4294967296
|
|
raise DataFormatError, num.to_s
|
|
end
|
|
return num.to_s
|
|
end
|
|
|
|
def format_list(list)
|
|
contents = list.collect {|i| format_data(i)}.join(" ")
|
|
return "(" + contents + ")"
|
|
end
|
|
|
|
DATE_MONTH = %w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)
|
|
|
|
def format_time(time)
|
|
t = time.dup.gmtime
|
|
return format('"%2d-%3s-%4d %02d:%02d:%02d +0000"',
|
|
t.day, DATE_MONTH[t.month - 1], t.year,
|
|
t.hour, t.min, t.sec)
|
|
end
|
|
|
|
def format_symbol(symbol)
|
|
return "\\" + symbol.to_s
|
|
end
|
|
|
|
def search_internal(cmd, keys, charset)
|
|
if keys.instance_of?(String)
|
|
keys = [RawData.new(keys)]
|
|
else
|
|
normalize_searching_criteria(keys)
|
|
end
|
|
synchronize do
|
|
if charset
|
|
send_command(cmd, "CHARSET", charset, *keys)
|
|
else
|
|
send_command(cmd, *keys)
|
|
end
|
|
return @responses.delete("SEARCH")[-1]
|
|
end
|
|
end
|
|
|
|
def fetch_internal(cmd, set, attr)
|
|
if attr.instance_of?(String)
|
|
attr = RawData.new(attr)
|
|
end
|
|
synchronize do
|
|
@responses.delete("FETCH")
|
|
send_command(cmd, MessageSet.new(set), attr)
|
|
return @responses.delete("FETCH")
|
|
end
|
|
end
|
|
|
|
def store_internal(cmd, set, attr, flags)
|
|
if attr.instance_of?(String)
|
|
attr = RawData.new(attr)
|
|
end
|
|
synchronize do
|
|
@responses.delete("FETCH")
|
|
send_command(cmd, MessageSet.new(set), attr, flags)
|
|
return @responses.delete("FETCH")
|
|
end
|
|
end
|
|
|
|
def copy_internal(cmd, set, mailbox)
|
|
send_command(cmd, MessageSet.new(set), mailbox)
|
|
end
|
|
|
|
def sort_internal(cmd, sort_keys, search_keys, charset)
|
|
if search_keys.instance_of?(String)
|
|
search_keys = [RawData.new(search_keys)]
|
|
else
|
|
normalize_searching_criteria(search_keys)
|
|
end
|
|
normalize_searching_criteria(search_keys)
|
|
synchronize do
|
|
send_command(cmd, sort_keys, charset, *search_keys)
|
|
return @responses.delete("SORT")[-1]
|
|
end
|
|
end
|
|
|
|
def normalize_searching_criteria(keys)
|
|
keys.collect! do |i|
|
|
case i
|
|
when -1, Range, Array
|
|
MessageSet.new(i)
|
|
else
|
|
i
|
|
end
|
|
end
|
|
end
|
|
|
|
class RawData
|
|
def format_data
|
|
return @data
|
|
end
|
|
|
|
private
|
|
|
|
def initialize(data)
|
|
@data = data
|
|
end
|
|
end
|
|
|
|
class Atom
|
|
def format_data
|
|
return @data
|
|
end
|
|
|
|
private
|
|
|
|
def initialize(data)
|
|
@data = data
|
|
end
|
|
end
|
|
|
|
class QuotedString
|
|
def format_data
|
|
return '"' + @data.gsub(/["\\]/n, "\\\\\\&") + '"'
|
|
end
|
|
|
|
private
|
|
|
|
def initialize(data)
|
|
@data = data
|
|
end
|
|
end
|
|
|
|
class Literal
|
|
def format_data
|
|
return "{" + @data.length.to_s + "}" + CRLF + @data
|
|
end
|
|
|
|
private
|
|
|
|
def initialize(data)
|
|
@data = data
|
|
end
|
|
end
|
|
|
|
class MessageSet
|
|
def format_data
|
|
return format_internal(@data)
|
|
end
|
|
|
|
private
|
|
|
|
def initialize(data)
|
|
@data = data
|
|
end
|
|
|
|
def format_internal(data)
|
|
case data
|
|
when "*"
|
|
return data
|
|
when Integer
|
|
ensure_nz_number(data)
|
|
if data == -1
|
|
return "*"
|
|
else
|
|
return data.to_s
|
|
end
|
|
when Range
|
|
return format_internal(data.first) +
|
|
":" + format_internal(data.last)
|
|
when Array
|
|
return data.collect {|i| format_internal(i)}.join(",")
|
|
else
|
|
raise DataFormatError, data.inspect
|
|
end
|
|
end
|
|
|
|
def ensure_nz_number(num)
|
|
if num < -1 || num == 0 || num >= 4294967296
|
|
raise DataFormatError, num.inspect
|
|
end
|
|
end
|
|
end
|
|
|
|
ContinuationRequest = Struct.new(:data, :raw_data)
|
|
UntaggedResponse = Struct.new(:name, :data, :raw_data)
|
|
TaggedResponse = Struct.new(:tag, :name, :data, :raw_data)
|
|
ResponseText = Struct.new(:code, :text)
|
|
ResponseCode = Struct.new(:name, :data)
|
|
MailboxList = Struct.new(:attr, :delim, :name)
|
|
MailboxQuota = Struct.new(:mailbox, :usage, :quota)
|
|
MailboxQuotaRoot = Struct.new(:mailbox, :quotaroots)
|
|
MailboxACLItem = Struct.new(:user, :rights)
|
|
StatusData = Struct.new(:mailbox, :attr)
|
|
FetchData = Struct.new(:seqno, :attr)
|
|
Envelope = Struct.new(:date, :subject, :from, :sender, :reply_to,
|
|
:to, :cc, :bcc, :in_reply_to, :message_id)
|
|
Address = Struct.new(:name, :route, :mailbox, :host)
|
|
ContentDisposition = Struct.new(:dsp_type, :param)
|
|
|
|
class BodyTypeBasic < Struct.new(:media_type, :subtype,
|
|
:param, :content_id,
|
|
:description, :encoding, :size,
|
|
:md5, :disposition, :language,
|
|
:extension)
|
|
def multipart?
|
|
return false
|
|
end
|
|
|
|
def media_subtype
|
|
$stderr.printf("warning: media_subtype is obsolete.\n")
|
|
$stderr.printf(" use subtype instead.\n")
|
|
return subtype
|
|
end
|
|
end
|
|
|
|
class BodyTypeText < Struct.new(:media_type, :subtype,
|
|
:param, :content_id,
|
|
:description, :encoding, :size,
|
|
:lines,
|
|
:md5, :disposition, :language,
|
|
:extension)
|
|
def multipart?
|
|
return false
|
|
end
|
|
|
|
def media_subtype
|
|
$stderr.printf("warning: media_subtype is obsolete.\n")
|
|
$stderr.printf(" use subtype instead.\n")
|
|
return subtype
|
|
end
|
|
end
|
|
|
|
class BodyTypeMessage < Struct.new(:media_type, :subtype,
|
|
:param, :content_id,
|
|
:description, :encoding, :size,
|
|
:envelope, :body, :lines,
|
|
:md5, :disposition, :language,
|
|
:extension)
|
|
def multipart?
|
|
return false
|
|
end
|
|
|
|
def media_subtype
|
|
$stderr.printf("warning: media_subtype is obsolete.\n")
|
|
$stderr.printf(" use subtype instead.\n")
|
|
return subtype
|
|
end
|
|
end
|
|
|
|
class BodyTypeMultipart < Struct.new(:media_type, :subtype,
|
|
:parts,
|
|
:param, :disposition, :language,
|
|
:extension)
|
|
def multipart?
|
|
return true
|
|
end
|
|
|
|
def media_subtype
|
|
$stderr.printf("warning: media_subtype is obsolete.\n")
|
|
$stderr.printf(" use subtype instead.\n")
|
|
return subtype
|
|
end
|
|
end
|
|
|
|
class ResponseParser
|
|
def parse(str)
|
|
@str = str
|
|
@pos = 0
|
|
@lex_state = EXPR_BEG
|
|
@token = nil
|
|
return response
|
|
end
|
|
|
|
private
|
|
|
|
EXPR_BEG = :EXPR_BEG
|
|
EXPR_DATA = :EXPR_DATA
|
|
EXPR_TEXT = :EXPR_TEXT
|
|
EXPR_RTEXT = :EXPR_RTEXT
|
|
EXPR_CTEXT = :EXPR_CTEXT
|
|
|
|
T_SPACE = :SPACE
|
|
T_NIL = :NIL
|
|
T_NUMBER = :NUMBER
|
|
T_ATOM = :ATOM
|
|
T_QUOTED = :QUOTED
|
|
T_LPAR = :LPAR
|
|
T_RPAR = :RPAR
|
|
T_BSLASH = :BSLASH
|
|
T_STAR = :STAR
|
|
T_LBRA = :LBRA
|
|
T_RBRA = :RBRA
|
|
T_LITERAL = :LITERAL
|
|
T_PLUS = :PLUS
|
|
T_PERCENT = :PERCENT
|
|
T_CRLF = :CRLF
|
|
T_EOF = :EOF
|
|
T_TEXT = :TEXT
|
|
|
|
BEG_REGEXP = /\G(?:\
|
|
(?# 1: SPACE )( )|\
|
|
(?# 2: NIL )(NIL)(?=[\x80-\xff(){ \x00-\x1f\x7f%*"\\\[\]+])|\
|
|
(?# 3: NUMBER )(\d+)(?=[\x80-\xff(){ \x00-\x1f\x7f%*"\\\[\]+])|\
|
|
(?# 4: ATOM )([^\x80-\xff(){ \x00-\x1f\x7f%*"\\\[\]+]+)|\
|
|
(?# 5: QUOTED )"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)"|\
|
|
(?# 6: LPAR )(\()|\
|
|
(?# 7: RPAR )(\))|\
|
|
(?# 8: BSLASH )(\\)|\
|
|
(?# 9: STAR )(\*)|\
|
|
(?# 10: LBRA )(\[)|\
|
|
(?# 11: RBRA )(\])|\
|
|
(?# 12: LITERAL )\{(\d+)\}\r\n|\
|
|
(?# 13: PLUS )(\+)|\
|
|
(?# 14: PERCENT )(%)|\
|
|
(?# 15: CRLF )(\r\n)|\
|
|
(?# 16: EOF )(\z))/ni
|
|
|
|
DATA_REGEXP = /\G(?:\
|
|
(?# 1: SPACE )( )|\
|
|
(?# 2: NIL )(NIL)|\
|
|
(?# 3: NUMBER )(\d+)|\
|
|
(?# 4: QUOTED )"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)"|\
|
|
(?# 5: LITERAL )\{(\d+)\}\r\n|\
|
|
(?# 6: LPAR )(\()|\
|
|
(?# 7: RPAR )(\)))/ni
|
|
|
|
TEXT_REGEXP = /\G(?:\
|
|
(?# 1: TEXT )([^\x00\x80-\xff\r\n]*))/ni
|
|
|
|
RTEXT_REGEXP = /\G(?:\
|
|
(?# 1: LBRA )(\[)|\
|
|
(?# 2: TEXT )([^\x00\x80-\xff\r\n]*))/ni
|
|
|
|
CTEXT_REGEXP = /\G(?:\
|
|
(?# 1: TEXT )([^\x00\x80-\xff\r\n\]]*))/ni
|
|
|
|
Token = Struct.new(:symbol, :value)
|
|
|
|
def response
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_PLUS
|
|
result = continue_req
|
|
when T_STAR
|
|
result = response_untagged
|
|
else
|
|
result = response_tagged
|
|
end
|
|
match(T_CRLF)
|
|
match(T_EOF)
|
|
return result
|
|
end
|
|
|
|
def continue_req
|
|
match(T_PLUS)
|
|
match(T_SPACE)
|
|
return ContinuationRequest.new(resp_text, @str)
|
|
end
|
|
|
|
def response_untagged
|
|
match(T_STAR)
|
|
match(T_SPACE)
|
|
token = lookahead
|
|
if token.symbol == T_NUMBER
|
|
return numeric_response
|
|
elsif token.symbol == T_ATOM
|
|
case token.value
|
|
when /\A(?:OK|NO|BAD|BYE|PREAUTH)\z/ni
|
|
return response_cond
|
|
when /\A(?:FLAGS)\z/ni
|
|
return flags_response
|
|
when /\A(?:LIST|LSUB)\z/ni
|
|
return list_response
|
|
when /\A(?:QUOTA)\z/ni
|
|
return getquota_response
|
|
when /\A(?:QUOTAROOT)\z/ni
|
|
return getquotaroot_response
|
|
when /\A(?:ACL)\z/ni
|
|
return getacl_response
|
|
when /\A(?:SEARCH|SORT)\z/ni
|
|
return search_response
|
|
when /\A(?:STATUS)\z/ni
|
|
return status_response
|
|
when /\A(?:CAPABILITY)\z/ni
|
|
return capability_response
|
|
else
|
|
return text_response
|
|
end
|
|
else
|
|
parse_error("unexpected token %s", token.symbol)
|
|
end
|
|
end
|
|
|
|
def response_tagged
|
|
tag = atom
|
|
match(T_SPACE)
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
return TaggedResponse.new(tag, name, resp_text, @str)
|
|
end
|
|
|
|
def response_cond
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
return UntaggedResponse.new(name, resp_text, @str)
|
|
end
|
|
|
|
def numeric_response
|
|
n = number
|
|
match(T_SPACE)
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
case name
|
|
when "EXISTS", "RECENT", "EXPUNGE"
|
|
return UntaggedResponse.new(name, n, @str)
|
|
when "FETCH"
|
|
shift_token
|
|
match(T_SPACE)
|
|
data = FetchData.new(n, msg_att)
|
|
return UntaggedResponse.new(name, data, @str)
|
|
end
|
|
end
|
|
|
|
def msg_att
|
|
match(T_LPAR)
|
|
attr = {}
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_RPAR
|
|
shift_token
|
|
break
|
|
when T_SPACE
|
|
shift_token
|
|
token = lookahead
|
|
end
|
|
case token.value
|
|
when /\A(?:ENVELOPE)\z/ni
|
|
name, val = envelope_data
|
|
when /\A(?:FLAGS)\z/ni
|
|
name, val = flags_data
|
|
when /\A(?:INTERNALDATE)\z/ni
|
|
name, val = internaldate_data
|
|
when /\A(?:RFC822(?:\.HEADER|\.TEXT)?)\z/ni
|
|
name, val = rfc822_text
|
|
when /\A(?:RFC822\.SIZE)\z/ni
|
|
name, val = rfc822_size
|
|
when /\A(?:BODY(?:STRUCTURE)?)\z/ni
|
|
name, val = body_data
|
|
when /\A(?:UID)\z/ni
|
|
name, val = uid_data
|
|
else
|
|
parse_error("unknown attribute `%s'", token.value)
|
|
end
|
|
attr[name] = val
|
|
end
|
|
return attr
|
|
end
|
|
|
|
def envelope_data
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
return name, envelope
|
|
end
|
|
|
|
def envelope
|
|
@lex_state = EXPR_DATA
|
|
match(T_LPAR)
|
|
date = nstring
|
|
match(T_SPACE)
|
|
subject = nstring
|
|
match(T_SPACE)
|
|
from = address_list
|
|
match(T_SPACE)
|
|
sender = address_list
|
|
match(T_SPACE)
|
|
reply_to = address_list
|
|
match(T_SPACE)
|
|
to = address_list
|
|
match(T_SPACE)
|
|
cc = address_list
|
|
match(T_SPACE)
|
|
bcc = address_list
|
|
match(T_SPACE)
|
|
in_reply_to = nstring
|
|
match(T_SPACE)
|
|
message_id = nstring
|
|
match(T_RPAR)
|
|
@lex_state = EXPR_BEG
|
|
return Envelope.new(date, subject, from, sender, reply_to,
|
|
to, cc, bcc, in_reply_to, message_id)
|
|
end
|
|
|
|
def flags_data
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
return name, flag_list
|
|
end
|
|
|
|
def internaldate_data
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
token = match(T_QUOTED)
|
|
return name, token.value
|
|
end
|
|
|
|
def rfc822_text
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
return name, nstring
|
|
end
|
|
|
|
def rfc822_size
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
return name, number
|
|
end
|
|
|
|
def body_data
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
return name, body
|
|
end
|
|
name.concat(section)
|
|
token = lookahead
|
|
if token.symbol == T_ATOM
|
|
name.concat(token.value)
|
|
shift_token
|
|
end
|
|
match(T_SPACE)
|
|
data = nstring
|
|
return name, data
|
|
end
|
|
|
|
def body
|
|
@lex_state = EXPR_DATA
|
|
match(T_LPAR)
|
|
token = lookahead
|
|
if token.symbol == T_LPAR
|
|
result = body_type_mpart
|
|
else
|
|
result = body_type_1part
|
|
end
|
|
match(T_RPAR)
|
|
@lex_state = EXPR_BEG
|
|
return result
|
|
end
|
|
|
|
def body_type_1part
|
|
token = lookahead
|
|
case token.value
|
|
when /\A(?:TEXT)\z/ni
|
|
return body_type_text
|
|
when /\A(?:MESSAGE)\z/ni
|
|
return body_type_msg
|
|
else
|
|
return body_type_basic
|
|
end
|
|
end
|
|
|
|
def body_type_basic
|
|
mtype, msubtype = media_type
|
|
match(T_SPACE)
|
|
param, content_id, desc, enc, size = body_fields
|
|
md5, disposition, language, extension = body_ext_1part
|
|
return BodyTypeBasic.new(mtype, msubtype,
|
|
param, content_id,
|
|
desc, enc, size,
|
|
md5, disposition, language, extension)
|
|
end
|
|
|
|
def body_type_text
|
|
mtype, msubtype = media_type
|
|
match(T_SPACE)
|
|
param, content_id, desc, enc, size = body_fields
|
|
match(T_SPACE)
|
|
lines = number
|
|
md5, disposition, language, extension = body_ext_1part
|
|
return BodyTypeText.new(mtype, msubtype,
|
|
param, content_id,
|
|
desc, enc, size,
|
|
lines,
|
|
md5, disposition, language, extension)
|
|
end
|
|
|
|
def body_type_msg
|
|
mtype, msubtype = media_type
|
|
match(T_SPACE)
|
|
param, content_id, desc, enc, size = body_fields
|
|
match(T_SPACE)
|
|
env = envelope
|
|
match(T_SPACE)
|
|
b = body
|
|
match(T_SPACE)
|
|
lines = number
|
|
md5, disposition, language, extension = body_ext_1part
|
|
return BodyTypeMessage.new(mtype, msubtype,
|
|
param, content_id,
|
|
desc, enc, size,
|
|
env, b, lines,
|
|
md5, disposition, language, extension)
|
|
end
|
|
|
|
def body_type_mpart
|
|
parts = []
|
|
while true
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
break
|
|
end
|
|
parts.push(body)
|
|
end
|
|
mtype = "MULTIPART"
|
|
msubtype = string.upcase
|
|
param, disposition, language, extension = body_ext_mpart
|
|
return BodyTypeMultipart.new(mtype, msubtype, parts,
|
|
param, disposition, language,
|
|
extension)
|
|
end
|
|
|
|
def media_type
|
|
mtype = string.upcase
|
|
match(T_SPACE)
|
|
msubtype = string.upcase
|
|
return mtype, msubtype
|
|
end
|
|
|
|
def body_fields
|
|
param = body_fld_param
|
|
match(T_SPACE)
|
|
content_id = nstring
|
|
match(T_SPACE)
|
|
desc = nstring
|
|
match(T_SPACE)
|
|
enc = string.upcase
|
|
match(T_SPACE)
|
|
size = number
|
|
return param, content_id, desc, enc, size
|
|
end
|
|
|
|
def body_fld_param
|
|
token = lookahead
|
|
if token.symbol == T_NIL
|
|
shift_token
|
|
return nil
|
|
end
|
|
match(T_LPAR)
|
|
param = {}
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_RPAR
|
|
shift_token
|
|
break
|
|
when T_SPACE
|
|
shift_token
|
|
end
|
|
name = string.upcase
|
|
match(T_SPACE)
|
|
val = string
|
|
param[name] = val
|
|
end
|
|
return param
|
|
end
|
|
|
|
def body_ext_1part
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
else
|
|
return nil
|
|
end
|
|
md5 = nstring
|
|
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
else
|
|
return md5
|
|
end
|
|
disposition = body_fld_dsp
|
|
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
else
|
|
return md5, disposition
|
|
end
|
|
language = body_fld_lang
|
|
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
else
|
|
return md5, disposition, language
|
|
end
|
|
|
|
extension = body_extensions
|
|
return md5, disposition, language, extension
|
|
end
|
|
|
|
def body_ext_mpart
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
else
|
|
return nil
|
|
end
|
|
param = body_fld_param
|
|
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
else
|
|
return param
|
|
end
|
|
disposition = body_fld_dsp
|
|
match(T_SPACE)
|
|
language = body_fld_lang
|
|
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
else
|
|
return param, disposition, language
|
|
end
|
|
|
|
extension = body_extensions
|
|
return param, disposition, language, extension
|
|
end
|
|
|
|
def body_fld_dsp
|
|
token = lookahead
|
|
if token.symbol == T_NIL
|
|
shift_token
|
|
return nil
|
|
end
|
|
match(T_LPAR)
|
|
dsp_type = string.upcase
|
|
match(T_SPACE)
|
|
param = body_fld_param
|
|
match(T_RPAR)
|
|
return ContentDisposition.new(dsp_type, param)
|
|
end
|
|
|
|
def body_fld_lang
|
|
token = lookahead
|
|
if token.symbol == T_LPAR
|
|
shift_token
|
|
result = []
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_RPAR
|
|
shift_token
|
|
return result
|
|
when T_SPACE
|
|
shift_token
|
|
end
|
|
result.push(string.upcase)
|
|
end
|
|
else
|
|
lang = nstring
|
|
if lang
|
|
return lang.upcase
|
|
else
|
|
return lang
|
|
end
|
|
end
|
|
end
|
|
|
|
def body_extensions
|
|
result = []
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_RPAR
|
|
return result
|
|
when T_SPACE
|
|
shift_token
|
|
end
|
|
result.push(body_extension)
|
|
end
|
|
end
|
|
|
|
def body_extension
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_LPAR
|
|
shift_token
|
|
result = body_extensions
|
|
match(T_RPAR)
|
|
return result
|
|
when T_NUMBER
|
|
return number
|
|
else
|
|
return nstring
|
|
end
|
|
end
|
|
|
|
def section
|
|
str = ""
|
|
token = match(T_LBRA)
|
|
str.concat(token.value)
|
|
token = match(T_ATOM, T_NUMBER, T_RBRA)
|
|
if token.symbol == T_RBRA
|
|
str.concat(token.value)
|
|
return str
|
|
end
|
|
str.concat(token.value)
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
str.concat(token.value)
|
|
token = match(T_LPAR)
|
|
str.concat(token.value)
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_RPAR
|
|
str.concat(token.value)
|
|
shift_token
|
|
break
|
|
when T_SPACE
|
|
shift_token
|
|
str.concat(token.value)
|
|
end
|
|
str.concat(format_string(astring))
|
|
end
|
|
end
|
|
token = match(T_RBRA)
|
|
str.concat(token.value)
|
|
return str
|
|
end
|
|
|
|
def format_string(str)
|
|
case str
|
|
when ""
|
|
return '""'
|
|
when /[\x80-\xff\r\n]/n
|
|
# literal
|
|
return "{" + str.length.to_s + "}" + CRLF + str
|
|
when /[(){ \x00-\x1f\x7f%*"\\]/n
|
|
# quoted string
|
|
return '"' + str.gsub(/["\\]/n, "\\\\\\&") + '"'
|
|
else
|
|
# atom
|
|
return str
|
|
end
|
|
end
|
|
|
|
def uid_data
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
return name, number
|
|
end
|
|
|
|
def text_response
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
@lex_state = EXPR_TEXT
|
|
token = match(T_TEXT)
|
|
@lex_state = EXPR_BEG
|
|
return UntaggedResponse.new(name, token.value)
|
|
end
|
|
|
|
def flags_response
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
return UntaggedResponse.new(name, flag_list, @str)
|
|
end
|
|
|
|
def list_response
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
return UntaggedResponse.new(name, mailbox_list, @str)
|
|
end
|
|
|
|
def mailbox_list
|
|
attr = flag_list
|
|
match(T_SPACE)
|
|
token = match(T_QUOTED, T_NIL)
|
|
if token.symbol == T_NIL
|
|
delim = nil
|
|
else
|
|
delim = token.value
|
|
end
|
|
match(T_SPACE)
|
|
name = astring
|
|
return MailboxList.new(attr, delim, name)
|
|
end
|
|
|
|
def getquota_response
|
|
# If quota never established, get back
|
|
# `NO Quota root does not exist'.
|
|
# If quota removed, get `()' after the
|
|
# folder spec with no mention of `STORAGE'.
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
mailbox = astring
|
|
match(T_SPACE)
|
|
match(T_LPAR)
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_RPAR
|
|
shift_token
|
|
data = MailboxQuota.new(mailbox, nil, nil)
|
|
return UntaggedResponse.new(name, data, @str)
|
|
when T_ATOM
|
|
shift_token
|
|
match(T_SPACE)
|
|
token = match(T_NUMBER)
|
|
usage = token.value
|
|
match(T_SPACE)
|
|
token = match(T_NUMBER)
|
|
quota = token.value
|
|
match(T_RPAR)
|
|
data = MailboxQuota.new(mailbox, usage, quota)
|
|
return UntaggedResponse.new(name, data, @str)
|
|
else
|
|
parse_error("unexpected token %s", token.symbol)
|
|
end
|
|
end
|
|
|
|
def getquotaroot_response
|
|
# Similar to getquota, but only admin can use getquota.
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
mailbox = astring
|
|
quotaroots = []
|
|
while true
|
|
token = lookahead
|
|
break unless token.symbol == T_SPACE
|
|
shift_token
|
|
quotaroots.push(astring)
|
|
end
|
|
data = MailboxQuotaRoot.new(mailbox, quotaroots)
|
|
return UntaggedResponse.new(name, data, @str)
|
|
end
|
|
|
|
def getacl_response
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
mailbox = astring
|
|
data = []
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_CRLF
|
|
break
|
|
when T_SPACE
|
|
shift_token
|
|
end
|
|
user = astring
|
|
match(T_SPACE)
|
|
rights = astring
|
|
##XXX data.push([user, rights])
|
|
data.push(MailboxACLItem.new(user, rights))
|
|
end
|
|
end
|
|
return UntaggedResponse.new(name, data, @str)
|
|
end
|
|
|
|
def search_response
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
token = lookahead
|
|
if token.symbol == T_SPACE
|
|
shift_token
|
|
data = []
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_CRLF
|
|
break
|
|
when T_SPACE
|
|
shift_token
|
|
end
|
|
data.push(number)
|
|
end
|
|
else
|
|
data = []
|
|
end
|
|
return UntaggedResponse.new(name, data, @str)
|
|
end
|
|
|
|
def status_response
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
mailbox = astring
|
|
match(T_SPACE)
|
|
match(T_LPAR)
|
|
attr = {}
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_RPAR
|
|
shift_token
|
|
break
|
|
when T_SPACE
|
|
shift_token
|
|
end
|
|
token = match(T_ATOM)
|
|
key = token.value.upcase
|
|
match(T_SPACE)
|
|
val = number
|
|
attr[key] = val
|
|
end
|
|
data = StatusData.new(mailbox, attr)
|
|
return UntaggedResponse.new(name, data, @str)
|
|
end
|
|
|
|
def capability_response
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
match(T_SPACE)
|
|
data = []
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_CRLF
|
|
break
|
|
when T_SPACE
|
|
shift_token
|
|
end
|
|
data.push(atom.upcase)
|
|
end
|
|
return UntaggedResponse.new(name, data, @str)
|
|
end
|
|
|
|
def resp_text
|
|
@lex_state = EXPR_RTEXT
|
|
token = lookahead
|
|
if token.symbol == T_LBRA
|
|
code = resp_text_code
|
|
else
|
|
code = nil
|
|
end
|
|
token = match(T_TEXT)
|
|
@lex_state = EXPR_BEG
|
|
return ResponseText.new(code, token.value)
|
|
end
|
|
|
|
def resp_text_code
|
|
@lex_state = EXPR_BEG
|
|
match(T_LBRA)
|
|
token = match(T_ATOM)
|
|
name = token.value.upcase
|
|
case name
|
|
when /\A(?:ALERT|PARSE|READ-ONLY|READ-WRITE|TRYCREATE)\z/n
|
|
result = ResponseCode.new(name, nil)
|
|
when /\A(?:PERMANENTFLAGS)\z/n
|
|
match(T_SPACE)
|
|
result = ResponseCode.new(name, flag_list)
|
|
when /\A(?:UIDVALIDITY|UIDNEXT|UNSEEN)\z/n
|
|
match(T_SPACE)
|
|
result = ResponseCode.new(name, number)
|
|
else
|
|
match(T_SPACE)
|
|
@lex_state = EXPR_CTEXT
|
|
token = match(T_TEXT)
|
|
@lex_state = EXPR_BEG
|
|
result = ResponseCode.new(name, token.value)
|
|
end
|
|
match(T_RBRA)
|
|
@lex_state = EXPR_RTEXT
|
|
return result
|
|
end
|
|
|
|
def address_list
|
|
token = lookahead
|
|
if token.symbol == T_NIL
|
|
shift_token
|
|
return nil
|
|
else
|
|
result = []
|
|
match(T_LPAR)
|
|
while true
|
|
token = lookahead
|
|
case token.symbol
|
|
when T_RPAR
|
|
shift_token
|
|
break
|
|
when T_SPACE
|
|
shift_token
|
|
end
|
|
result.push(address)
|
|
end
|
|
return result
|
|
end
|
|
end
|
|
|
|
ADDRESS_REGEXP = /\G\
|
|
(?# 1: NAME )(?:NIL|"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)") \
|
|
(?# 2: ROUTE )(?:NIL|"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)") \
|
|
(?# 3: MAILBOX )(?:NIL|"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)") \
|
|
(?# 4: HOST )(?:NIL|"((?:[^\x80-\xff\x00\r\n"\\]|\\["\\])*)")\
|
|
\)/ni
|
|
|
|
def address
|
|
match(T_LPAR)
|
|
if @str.index(ADDRESS_REGEXP, @pos)
|
|
# address does not include literal.
|
|
@pos = $~.end(0)
|
|
name = $1
|
|
route = $2
|
|
mailbox = $3
|
|
host = $4
|
|
for s in [name, route, mailbox, host]
|
|
if s
|
|
s.gsub!(/\\(["\\])/n, "\\1")
|
|
end
|
|
end
|
|
else
|
|
name = nstring
|
|
match(T_SPACE)
|
|
route = nstring
|
|
match(T_SPACE)
|
|
mailbox = nstring
|
|
match(T_SPACE)
|
|
host = nstring
|
|
match(T_RPAR)
|
|
end
|
|
return Address.new(name, route, mailbox, host)
|
|
end
|
|
|
|
# def flag_list
|
|
# result = []
|
|
# match(T_LPAR)
|
|
# while true
|
|
# token = lookahead
|
|
# case token.symbol
|
|
# when T_RPAR
|
|
# shift_token
|
|
# break
|
|
# when T_SPACE
|
|
# shift_token
|
|
# end
|
|
# result.push(flag)
|
|
# end
|
|
# return result
|
|
# end
|
|
|
|
# def flag
|
|
# token = lookahead
|
|
# if token.symbol == T_BSLASH
|
|
# shift_token
|
|
# token = lookahead
|
|
# if token.symbol == T_STAR
|
|
# shift_token
|
|
# return token.value.intern
|
|
# else
|
|
# return atom.intern
|
|
# end
|
|
# else
|
|
# return atom
|
|
# end
|
|
# end
|
|
|
|
FLAG_REGEXP = /\
|
|
(?# FLAG )\\([^\x80-\xff(){ \x00-\x1f\x7f%"\\]+)|\
|
|
(?# ATOM )([^\x80-\xff(){ \x00-\x1f\x7f%*"\\]+)/n
|
|
|
|
def flag_list
|
|
if @str.index(/\(([^)]*)\)/ni, @pos)
|
|
@pos = $~.end(0)
|
|
return $1.scan(FLAG_REGEXP).collect { |flag, atom|
|
|
atom || flag.capitalize.intern
|
|
}
|
|
else
|
|
parse_error("invalid flag list")
|
|
end
|
|
end
|
|
|
|
def nstring
|
|
token = lookahead
|
|
if token.symbol == T_NIL
|
|
shift_token
|
|
return nil
|
|
else
|
|
return string
|
|
end
|
|
end
|
|
|
|
def astring
|
|
token = lookahead
|
|
if string_token?(token)
|
|
return string
|
|
else
|
|
return atom
|
|
end
|
|
end
|
|
|
|
def string
|
|
token = match(T_QUOTED, T_LITERAL)
|
|
return token.value
|
|
end
|
|
|
|
STRING_TOKENS = [T_QUOTED, T_LITERAL]
|
|
|
|
def string_token?(token)
|
|
return STRING_TOKENS.include?(token.symbol)
|
|
end
|
|
|
|
def atom
|
|
result = ""
|
|
while true
|
|
token = lookahead
|
|
if atom_token?(token)
|
|
result.concat(token.value)
|
|
shift_token
|
|
else
|
|
if result.empty?
|
|
parse_error("unexpected token %s", token.symbol)
|
|
else
|
|
return result
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
ATOM_TOKENS = [
|
|
T_ATOM,
|
|
T_NUMBER,
|
|
T_NIL,
|
|
T_LBRA,
|
|
T_RBRA,
|
|
T_PLUS
|
|
]
|
|
|
|
def atom_token?(token)
|
|
return ATOM_TOKENS.include?(token.symbol)
|
|
end
|
|
|
|
def number
|
|
token = match(T_NUMBER)
|
|
return token.value.to_i
|
|
end
|
|
|
|
def nil_atom
|
|
match(T_NIL)
|
|
return nil
|
|
end
|
|
|
|
def match(*args)
|
|
token = lookahead
|
|
unless args.include?(token.symbol)
|
|
parse_error('unexpected token %s (expected %s)',
|
|
token.symbol.id2name,
|
|
args.collect {|i| i.id2name}.join(" or "))
|
|
end
|
|
shift_token
|
|
return token
|
|
end
|
|
|
|
def lookahead
|
|
unless @token
|
|
@token = next_token
|
|
end
|
|
return @token
|
|
end
|
|
|
|
def shift_token
|
|
@token = nil
|
|
end
|
|
|
|
def next_token
|
|
case @lex_state
|
|
when EXPR_BEG
|
|
if @str.index(BEG_REGEXP, @pos)
|
|
@pos = $~.end(0)
|
|
if $1
|
|
return Token.new(T_SPACE, $+)
|
|
elsif $2
|
|
return Token.new(T_NIL, $+)
|
|
elsif $3
|
|
return Token.new(T_NUMBER, $+)
|
|
elsif $4
|
|
return Token.new(T_ATOM, $+)
|
|
elsif $5
|
|
return Token.new(T_QUOTED,
|
|
$+.gsub(/\\(["\\])/n, "\\1"))
|
|
elsif $6
|
|
return Token.new(T_LPAR, $+)
|
|
elsif $7
|
|
return Token.new(T_RPAR, $+)
|
|
elsif $8
|
|
return Token.new(T_BSLASH, $+)
|
|
elsif $9
|
|
return Token.new(T_STAR, $+)
|
|
elsif $10
|
|
return Token.new(T_LBRA, $+)
|
|
elsif $11
|
|
return Token.new(T_RBRA, $+)
|
|
elsif $12
|
|
len = $+.to_i
|
|
val = @str[@pos, len]
|
|
@pos += len
|
|
return Token.new(T_LITERAL, val)
|
|
elsif $13
|
|
return Token.new(T_PLUS, $+)
|
|
elsif $14
|
|
return Token.new(T_PERCENT, $+)
|
|
elsif $15
|
|
return Token.new(T_CRLF, $+)
|
|
elsif $16
|
|
return Token.new(T_EOF, $+)
|
|
else
|
|
parse_error("[Net::IMAP BUG] BEG_REGEXP is invalid")
|
|
end
|
|
else
|
|
@str.index(/\S*/n, @pos)
|
|
parse_error("unknown token - %s", $&.dump)
|
|
end
|
|
when EXPR_DATA
|
|
if @str.index(DATA_REGEXP, @pos)
|
|
@pos = $~.end(0)
|
|
if $1
|
|
return Token.new(T_SPACE, $+)
|
|
elsif $2
|
|
return Token.new(T_NIL, $+)
|
|
elsif $3
|
|
return Token.new(T_NUMBER, $+)
|
|
elsif $4
|
|
return Token.new(T_QUOTED,
|
|
$+.gsub(/\\(["\\])/n, "\\1"))
|
|
elsif $5
|
|
len = $+.to_i
|
|
val = @str[@pos, len]
|
|
@pos += len
|
|
return Token.new(T_LITERAL, val)
|
|
elsif $6
|
|
return Token.new(T_LPAR, $+)
|
|
elsif $7
|
|
return Token.new(T_RPAR, $+)
|
|
else
|
|
parse_error("[Net::IMAP BUG] BEG_REGEXP is invalid")
|
|
end
|
|
else
|
|
@str.index(/\S*/n, @pos)
|
|
parse_error("unknown token - %s", $&.dump)
|
|
end
|
|
when EXPR_TEXT
|
|
if @str.index(TEXT_REGEXP, @pos)
|
|
@pos = $~.end(0)
|
|
if $1
|
|
return Token.new(T_TEXT, $+)
|
|
else
|
|
parse_error("[Net::IMAP BUG] TEXT_REGEXP is invalid")
|
|
end
|
|
else
|
|
@str.index(/\S*/n, @pos)
|
|
parse_error("unknown token - %s", $&.dump)
|
|
end
|
|
when EXPR_RTEXT
|
|
if @str.index(RTEXT_REGEXP, @pos)
|
|
@pos = $~.end(0)
|
|
if $1
|
|
return Token.new(T_LBRA, $+)
|
|
elsif $2
|
|
return Token.new(T_TEXT, $+)
|
|
else
|
|
parse_error("[Net::IMAP BUG] RTEXT_REGEXP is invalid")
|
|
end
|
|
else
|
|
@str.index(/\S*/n, @pos)
|
|
parse_error("unknown token - %s", $&.dump)
|
|
end
|
|
when EXPR_CTEXT
|
|
if @str.index(CTEXT_REGEXP, @pos)
|
|
@pos = $~.end(0)
|
|
if $1
|
|
return Token.new(T_TEXT, $+)
|
|
else
|
|
parse_error("[Net::IMAP BUG] CTEXT_REGEXP is invalid")
|
|
end
|
|
else
|
|
@str.index(/\S*/n, @pos) #/
|
|
parse_error("unknown token - %s", $&.dump)
|
|
end
|
|
else
|
|
parse_error("illegal @lex_state - %s", @lex_state.inspect)
|
|
end
|
|
end
|
|
|
|
def parse_error(fmt, *args)
|
|
if IMAP.debug
|
|
$stderr.printf("@str: %s\n", @str.dump)
|
|
$stderr.printf("@pos: %d\n", @pos)
|
|
$stderr.printf("@lex_state: %s\n", @lex_state)
|
|
if @token.symbol
|
|
$stderr.printf("@token.symbol: %s\n", @token.symbol)
|
|
$stderr.printf("@token.value: %s\n", @token.value.inspect)
|
|
end
|
|
end
|
|
raise ResponseParseError, format(fmt, *args)
|
|
end
|
|
end
|
|
|
|
class LoginAuthenticator
|
|
def process(data)
|
|
case @state
|
|
when STATE_USER
|
|
@state = STATE_PASSWORD
|
|
return @user
|
|
when STATE_PASSWORD
|
|
return @password
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
STATE_USER = :USER
|
|
STATE_PASSWORD = :PASSWORD
|
|
|
|
def initialize(user, password)
|
|
@user = user
|
|
@password = password
|
|
@state = STATE_USER
|
|
end
|
|
end
|
|
add_authenticator "LOGIN", LoginAuthenticator
|
|
|
|
class CramMD5Authenticator
|
|
def process(challenge)
|
|
digest = hmac_md5(challenge, @password)
|
|
return @user + " " + digest
|
|
end
|
|
|
|
private
|
|
|
|
def initialize(user, password)
|
|
@user = user
|
|
@password = password
|
|
end
|
|
|
|
def hmac_md5(text, key)
|
|
if key.length > 64
|
|
key = Digest::MD5.digest(key)
|
|
end
|
|
|
|
k_ipad = key + "\0" * (64 - key.length)
|
|
k_opad = key + "\0" * (64 - key.length)
|
|
for i in 0..63
|
|
k_ipad[i] ^= 0x36
|
|
k_opad[i] ^= 0x5c
|
|
end
|
|
|
|
digest = Digest::MD5.digest(k_ipad + text)
|
|
|
|
return Digest::MD5.hexdigest(k_opad + digest)
|
|
end
|
|
end
|
|
add_authenticator "CRAM-MD5", CramMD5Authenticator
|
|
|
|
class Error < StandardError
|
|
end
|
|
|
|
class DataFormatError < Error
|
|
end
|
|
|
|
class ResponseParseError < Error
|
|
end
|
|
|
|
class ResponseError < Error
|
|
end
|
|
|
|
class NoResponseError < ResponseError
|
|
end
|
|
|
|
class BadResponseError < ResponseError
|
|
end
|
|
|
|
class ByeResponseError < ResponseError
|
|
end
|
|
end
|
|
end
|
|
|
|
if __FILE__ == $0
|
|
require "getoptlong"
|
|
|
|
$stdout.sync = true
|
|
$port = "imap2"
|
|
$user = ENV["USER"] || ENV["LOGNAME"]
|
|
$auth = "cram-md5"
|
|
|
|
def usage
|
|
$stderr.print <<EOF
|
|
usage: #{$0} [options] <host>
|
|
|
|
--help print this message
|
|
--port=PORT specifies port
|
|
--user=USER specifies user
|
|
--auth=AUTH specifies auth type
|
|
EOF
|
|
end
|
|
|
|
def get_password
|
|
print "password: "
|
|
system("stty", "-echo")
|
|
begin
|
|
return gets.chop
|
|
ensure
|
|
system("stty", "echo")
|
|
print "\n"
|
|
end
|
|
end
|
|
|
|
def get_command
|
|
printf("%s@%s> ", $user, $host)
|
|
if line = gets
|
|
return line.strip.split(/\s+/)
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
|
|
parser = GetoptLong.new
|
|
parser.set_options(['--help', GetoptLong::NO_ARGUMENT],
|
|
['--port', GetoptLong::REQUIRED_ARGUMENT],
|
|
['--user', GetoptLong::REQUIRED_ARGUMENT],
|
|
['--auth', GetoptLong::REQUIRED_ARGUMENT])
|
|
begin
|
|
parser.each_option do |name, arg|
|
|
case name
|
|
when "--port"
|
|
$port = arg
|
|
when "--user"
|
|
$user = arg
|
|
when "--auth"
|
|
$auth = arg
|
|
when "--help"
|
|
usage
|
|
exit(1)
|
|
end
|
|
end
|
|
rescue
|
|
usage
|
|
exit(1)
|
|
end
|
|
|
|
$host = ARGV.shift
|
|
unless $host
|
|
usage
|
|
exit(1)
|
|
end
|
|
|
|
imap = Net::IMAP.new($host, $port)
|
|
begin
|
|
password = get_password
|
|
imap.authenticate($auth, $user, password)
|
|
while true
|
|
cmd, *args = get_command
|
|
break unless cmd
|
|
begin
|
|
case cmd
|
|
when "list"
|
|
for mbox in imap.list("", args[0] || "*")
|
|
if mbox.attr.include?(Net::IMAP::NOSELECT)
|
|
prefix = "!"
|
|
elsif mbox.attr.include?(Net::IMAP::MARKED)
|
|
prefix = "*"
|
|
else
|
|
prefix = " "
|
|
end
|
|
print prefix, mbox.name, "\n"
|
|
end
|
|
when "select"
|
|
imap.select(args[0] || "inbox")
|
|
print "ok\n"
|
|
when "close"
|
|
imap.close
|
|
print "ok\n"
|
|
when "summary"
|
|
unless messages = imap.responses["EXISTS"][-1]
|
|
puts "not selected"
|
|
next
|
|
end
|
|
if messages > 0
|
|
for data in imap.fetch(1..-1, ["ENVELOPE"])
|
|
print data.seqno, ": ", data.attr["ENVELOPE"].subject, "\n"
|
|
end
|
|
else
|
|
puts "no message"
|
|
end
|
|
when "fetch"
|
|
if args[0]
|
|
data = imap.fetch(args[0].to_i, ["RFC822.HEADER", "RFC822.TEXT"])[0]
|
|
puts data.attr["RFC822.HEADER"]
|
|
puts data.attr["RFC822.TEXT"]
|
|
else
|
|
puts "missing argument"
|
|
end
|
|
when "logout", "exit", "quit"
|
|
break
|
|
when "help", "?"
|
|
print <<EOF
|
|
list [pattern] list mailboxes
|
|
select [mailbox] select mailbox
|
|
close close mailbox
|
|
summary display summary
|
|
fetch [msgno] display message
|
|
logout logout
|
|
help, ? display help message
|
|
EOF
|
|
else
|
|
print "unknown command: ", cmd, "\n"
|
|
end
|
|
rescue Net::IMAP::Error
|
|
puts $!
|
|
end
|
|
end
|
|
ensure
|
|
imap.logout
|
|
imap.disconnect
|
|
end
|
|
end
|