## i would like, for example, to be able to add in a ruby-talk
## specific module that would detect and link to /ruby-talk:\d+/
## sequences in the text of an email. (how sweet would that be?)
+##
+## this class cathces all source exceptions. if the underlying source throws
+## an error, it is caught and handled.
+
class Message
SNIPPET_LEN = 80
- WRAP_LEN = 80 # wrap at this width
RE_PATTERN = /^((re|re[\[\(]\d[\]\)]):\s*)+/i
- HookManager.register "mime-decode", <<EOS
-Executes when decoding a MIME attachment.
-Variables:
- content_type: the content-type of the message
- filename: the filename of the attachment as saved to disk (generated
- on the fly, so don't call more than once)
- sibling_types: if this attachment is part of a multipart MIME attachment,
- an array of content-types for all attachments. Otherwise,
- the empty array.
-Return value:
- The decoded text of the attachment, or nil if not decoded.
-EOS
-#' stupid ruby-mode
-
## some utility methods
class << self
def normalize_subj s; s.gsub(RE_PATTERN, ""); end
def reify_subj s; subj_is_reply?(s) ? s : "Re: " + s; end
end
- class Attachment
- ## encoded_content is still possible MIME-encoded
- ##
- ## raw_content is after decoding but before being turned into
- ## inlineable text.
- ##
- ## lines is array of inlineable text.
-
- attr_reader :content_type, :filename, :lines, :raw_content
-
- def initialize content_type, filename, encoded_content, sibling_types
- @content_type = content_type
- @filename = filename
- @raw_content = encoded_content.decode
- charset = encoded_content.charset
-
- if @content_type =~ /^text\/plain\b/
- @lines = Message.convert_from(@raw_content, charset).split("\n")
- else
- text = HookManager.run "mime-decode", :content_type => content_type,
- :filename => lambda { write_to_disk }, :sibling_types => sibling_types
- @lines = text.split("\n") if text
- end
- end
-
- def inlineable?; !@lines.nil? end
-
- def view!
- path = write_to_disk
- system "/usr/bin/run-mailcap --action=view #{@content_type}:#{path} >& /dev/null"
- $? == 0
- end
-
- ## used when viewing the attachment as text
- def to_s
- @lines || @raw_content
- end
-
- private
-
- def write_to_disk
- file = Tempfile.new "redwood.attachment"
- file.print @raw_content
- file.close
- file.path
- end
- end
-
- class Text
- attr_reader :lines
- def initialize lines
- ## do some wrapping
- @lines = lines.map { |l| l.chomp.wrap WRAP_LEN }.flatten
- end
- end
-
- class Quote
- attr_reader :lines
- def initialize lines
- @lines = lines
- end
- end
-
- class Signature
- attr_reader :lines
- def initialize lines
- @lines = lines
- end
- end
-
QUOTE_PATTERN = /^\s{0,4}[>|\}]/
BLOCK_QUOTE_PATTERN = /^-----\s*Original Message\s*----+$/
QUOTE_START_PATTERN = /(^\s*Excerpts from)|(^\s*In message )|(^\s*In article )|(^\s*Quoting )|((wrote|writes|said|says)\s*:\s*$)/
- SIG_PATTERN = /(^-- ?$)|(^\s*----------+\s*$)|(^\s*_________+\s*$)|(^\s*--~--~-)/
+ SIG_PATTERN = /(^-- ?$)|(^\s*----------+\s*$)|(^\s*_________+\s*$)|(^\s*--~--~-)|(^\s*--\+\+\*\*==)/
MAX_SIG_DISTANCE = 15 # lines from the end
DEFAULT_SUBJECT = ""
attr_reader :id, :date, :from, :subj, :refs, :replytos, :to, :source,
:cc, :bcc, :labels, :list_address, :recipient_email, :replyto,
- :source_info, :chunks
+ :source_info, :chunks, :list_subscribe, :list_unsubscribe
bool_reader :dirty, :source_marked_read
def parse_header header
header.each { |k, v| header[k.downcase] = v }
-
- @from = PersonManager.person_for header["from"]
-
- @id = header["message-id"]
- unless @id
- @id = "sup-faked-" + Digest::MD5.hexdigest(raw_header)
- Redwood::log "faking message-id for message from #@from: #@id"
- end
+
+ @id =
+ if header["message-id"]
+ sanitize_message_id header["message-id"]
+ else
+ returning("sup-faked-" + Digest::MD5.hexdigest(raw_header)) do |id|
+ Redwood::log "faking message-id for message from #@from: #{id}"
+ end
+ end
+
+ @from =
+ if header["from"]
+ PersonManager.person_for header["from"]
+ else
+ name = "Sup Auto-generated Fake Sender <sup@fake.sender.example.com>"
+ Redwood::log "faking from for message #@id: #{name}"
+ PersonManager.person_for name
+ end
date = header["date"]
@date =
@to = PersonManager.people_for header["to"]
@cc = PersonManager.people_for header["cc"]
@bcc = PersonManager.people_for header["bcc"]
- @refs = (header["references"] || "").gsub(/[<>]/, "").split(/\s+/).flatten
- @replytos = (header["in-reply-to"] || "").scan(/<(.*?)>/).flatten
+ @refs = (header["references"] || "").scan(/<(.+?)>/).map { |x| sanitize_message_id x.first }
+ @replytos = (header["in-reply-to"] || "").scan(/<(.+?)>/).map { |x| sanitize_message_id x.first }
+
@replyto = PersonManager.person_for header["reply-to"]
@list_address =
if header["list-post"]
@recipient_email = header["envelope-to"] || header["x-original-to"] || header["delivered-to"]
@source_marked_read = header["status"] == "RO"
+ @list_subscribe = header["list-subscribe"]
+ @list_unsubscribe = header["list-unsubscribe"]
end
private :parse_header
@source.fn_for_offset @source_info
end
+ def sanitize_message_id mid; mid.gsub(/\s/, "") end
+
def save index
index.sync_message self if @dirty
@dirty = false
def load_from_source!
@chunks ||=
if @source.has_errors?
- [Text.new(error_message(@source.error.message.split("\n")))]
+ [Chunk::Text.new(error_message(@source.error.message.split("\n")))]
else
begin
## we need to re-read the header because it contains information
Redwood::log "problem getting messages from #{@source}: #{e.message}"
## we need force_to_top here otherwise this window will cover
## up the error message one
+ @source.error ||= e
Redwood::report_broken_sources :force_to_top => true
- [Text.new(error_message(e.message))]
+ [Chunk::Text.new(error_message(e.message))]
end
end
end
EOS
end
- def raw_header
+ ## wrap any source methods that might throw sourceerrors
+ def with_source_errors_handled
begin
- @source.raw_header @source_info
+ yield
rescue SourceError => e
Redwood::log "problem getting messages from #{@source}: #{e.message}"
+ @source.error ||= e
+ Redwood::report_broken_sources :force_to_top => true
error_message e.message
end
end
- def raw_full_message
- begin
- @source.raw_full_message @source_info
- rescue SourceError => e
- Redwood::log "problem getting messages from #{@source}: #{e.message}"
- error_message(e.message)
- end
+ def raw_header
+ with_source_errors_handled { @source.raw_header @source_info }
+ end
+
+ def raw_message
+ with_source_errors_handled { @source.raw_message @source_info }
+ end
+
+ ## much faster than raw_message
+ def each_raw_message_line &b
+ with_source_errors_handled { @source.each_raw_message_line(@source_info, &b) }
end
def content
to.map { |p| "#{p.name} #{p.email}" },
cc.map { |p| "#{p.name} #{p.email}" },
bcc.map { |p| "#{p.name} #{p.email}" },
- chunks.select { |c| c.is_a? Text }.map { |c| c.lines },
+ chunks.select { |c| c.is_a? Chunk::Text }.map { |c| c.lines },
Message.normalize_subj(subj),
].flatten.compact.join " "
end
- def basic_body_lines
- chunks.find_all { |c| c.is_a?(Text) || c.is_a?(Quote) }.map { |c| c.lines }.flatten
+ def quotable_body_lines
+ chunks.find_all { |c| c.quotable? }.map { |c| c.lines }.flatten
end
- def basic_header_lines
+ def quotable_header_lines
["From: #{@from.full_address}"] +
(@to.empty? ? [] : ["To: " + @to.map { |p| p.full_address }.join(", ")]) +
(@cc.empty? ? [] : ["Cc: " + @cc.map { |p| p.full_address }.join(", ")]) +
## of the gruesome slaughterhouse and sausage factory that is a
## mime-encoded message, but need only see the delicious end
## product.
+
+ def multipart_signed_to_chunks m
+# Redwood::log ">> multipart SIGNED: #{m.header['Content-Type']}: #{m.body.size}"
+ if m.body.size != 2
+ Redwood::log "warning: multipart/signed with #{m.body.size} parts (expecting 2)"
+ return
+ end
+
+ payload, signature = m.body
+ if signature.multipart?
+ Redwood::log "warning: multipart/signed with payload multipart #{payload.multipart?} and signature multipart #{signature.multipart?}"
+ return
+ end
+
+ if payload.header.content_type == "application/pgp-signature"
+ Redwood::log "warning: multipart/signed with payload content type #{payload.header.content_type}"
+ return
+ end
+
+ if signature.header.content_type != "application/pgp-signature"
+ Redwood::log "warning: multipart/signed with signature content type #{signature.header.content_type}"
+ return
+ end
+
+ [CryptoManager.verify(payload, signature), message_to_chunks(payload)].flatten.compact
+ end
+
+ def multipart_encrypted_to_chunks m
+ Redwood::log ">> multipart ENCRYPTED: #{m.header['Content-Type']}: #{m.body.size}"
+ if m.body.size != 2
+ Redwood::log "warning: multipart/encrypted with #{m.body.size} parts (expecting 2)"
+ return
+ end
+
+ control, payload = m.body
+ if control.multipart?
+ Redwood::log "warning: multipart/encrypted with control multipart #{control.multipart?} and payload multipart #{payload.multipart?}"
+ return
+ end
+
+ if payload.header.content_type != "application/octet-stream"
+ Redwood::log "warning: multipart/encrypted with payload content type #{payload.header.content_type}"
+ return
+ end
+
+ if control.header.content_type != "application/pgp-encrypted"
+ Redwood::log "warning: multipart/encrypted with control content type #{signature.header.content_type}"
+ return
+ end
+
+ decryptedm, sig, notice = CryptoManager.decrypt payload
+ children = message_to_chunks(decryptedm) if decryptedm
+ [notice, sig, children].flatten.compact
+ end
+
def message_to_chunks m, sibling_types=[]
if m.multipart?
- sibling_types = m.body.map { |p| p.header.content_type }
- m.body.map { |p| message_to_chunks p, sibling_types }.flatten.compact # recurse
+ chunks =
+ case m.header.content_type
+ when "multipart/signed"
+ multipart_signed_to_chunks m
+ when "multipart/encrypted"
+ multipart_encrypted_to_chunks m
+ end
+
+ unless chunks
+ sibling_types = m.body.map { |p| p.header.content_type }
+ chunks = m.body.map { |p| message_to_chunks p, sibling_types }.flatten.compact
+ end
+
+ chunks
+ elsif m.header.content_type == "message/rfc822"
+ payload = RMail::Parser.read(m.body)
+ from = payload.header.from.first
+ from_person = from ? PersonManager.person_for(from.format) : nil
+ [Chunk::EnclosedMessage.new(from_person, payload.to_s)]
else
filename =
## first, paw through the headers looking for a filename
## if there's a filename, we'll treat it as an attachment.
if filename
- [Attachment.new(m.header.content_type, filename, m, sibling_types)]
+ [Chunk::Attachment.new(m.header.content_type, filename, m, sibling_types)]
## otherwise, it's body text
else
- body = Message.convert_from m.body, m.charset
+ body = Message.convert_from m.decode, m.charset
text_to_chunks body.normalize_whitespace.split("\n")
end
end
end
def self.convert_from body, charset
- return body unless charset
-
begin
+ raise MessageFormatError, "RubyMail decode returned a null body" unless body
+ return body unless charset
Iconv.iconv($encoding, charset, body).join
- rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence => e
+ rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence, MessageFormatError => e
Redwood::log "warning: error (#{e.class.name}) decoding message body from #{charset}: #{e.message}"
File.open("sup-unable-to-decode.txt", "w") { |f| f.write body }
body
end
if newstate
- chunks << Text.new(chunk_lines) unless chunk_lines.empty?
+ chunks << Chunk::Text.new(chunk_lines) unless chunk_lines.empty?
chunk_lines = [line]
state = newstate
else
if chunk_lines.empty?
# nothing
else
- chunks << Quote.new(chunk_lines)
+ chunks << Chunk::Quote.new(chunk_lines)
end
chunk_lines = [line]
state = newstate
## final object
case state
when :quote, :block_quote
- chunks << Quote.new(chunk_lines) unless chunk_lines.empty?
+ chunks << Chunk::Quote.new(chunk_lines) unless chunk_lines.empty?
when :text
- chunks << Text.new(chunk_lines) unless chunk_lines.empty?
+ chunks << Chunk::Text.new(chunk_lines) unless chunk_lines.empty?
when :sig
- chunks << Signature.new(chunk_lines) unless chunk_lines.empty?
+ chunks << Chunk::Signature.new(chunk_lines) unless chunk_lines.empty?
end
chunks
end
projects / sup / blobdiff