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
end
class Attachment
- attr_reader :content_type, :filename, :content, :lines
- def initialize content_type, filename, content
+ ## 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
- @content = content
+ @raw_content = encoded_content.decode
- if inlineable?
- @lines = to_s.split("\n")
- end
+ @lines =
+ case @content_type
+ when /^text\/plain\b/
+ Message.convert_from(@raw_content, encoded_content.charset).split("\n")
+ else
+ text = HookManager.run "mime-decode", :content_type => content_type,
+ :filename => lambda { write_to_disk },
+ :sibling_types => sibling_types
+ text.split("\n") if text
+
+ end
end
- def view!
- file = Tempfile.new "redwood.attachment"
- file.print raw_content
- file.close
+ def inlineable?; !@lines.nil? end
- system "/usr/bin/run-mailcap --action=view #{@content_type}:#{file.path} >& /dev/null"
+ 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
- def to_s; Message.decode_and_convert @content; end
- def raw_content; @content.decode end
+ private
- def inlineable?; @content_type =~ /^text\/plain/ end
+ def write_to_disk
+ file = Tempfile.new "redwood.attachment"
+ file.print @raw_content
+ file.close
+ file.path
+ end
end
class Text
end
end
+ class CryptoSignature
+ attr_reader :lines, :description
+
+ def initialize payload, signature
+ @payload = payload
+ @signature = signature
+ @status = nil
+ @description = nil
+ @lines = []
+ end
+
+ def status
+ verify
+ @status
+ end
+
+ def description
+ verify
+ @description
+ end
+
+private
+
+ def verify
+ @status, @description, @lines = CryptoManager.verify(@payload, @signature) unless @status
+ end
+ end
QUOTE_PATTERN = /^\s{0,4}[>|\}]/
BLOCK_QUOTE_PATTERN = /^-----\s*Original Message\s*----+$/
SIG_PATTERN = /(^-- ?$)|(^\s*----------+\s*$)|(^\s*_________+\s*$)|(^\s*--~--~-)/
MAX_SIG_DISTANCE = 15 # lines from the end
- DEFAULT_SUBJECT = "(missing subject)"
+ DEFAULT_SUBJECT = ""
DEFAULT_SENDER = "(missing sender)"
attr_reader :id, :date, :from, :subj, :refs, :replytos, :to, :source,
bool_reader :dirty, :source_marked_read
- ## if you specify a :header, will use values from that. otherwise, will try and
- ## load the header from the source.
+ ## if you specify a :header, will use values from that. otherwise,
+ ## will try and load the header from the source.
def initialize opts
@source = opts[:source] or raise ArgumentError, "source can't be nil"
@source_info = opts[:source_info] or raise ArgumentError, "source_info can't be nil"
@dirty = false
@chunks = nil
- read_header(opts[:header] || @source.load_header(@source_info))
+ parse_header(opts[:header] || @source.load_header(@source_info))
end
- def read_header header
+ def parse_header header
header.each { |k, v| header[k.downcase] = v }
- %w(message-id date).each do |f|
- raise MessageFormatError, "no #{f} field in header #{header.inspect} (source #@source offset #@source_info)" unless header.include? f
- raise MessageFormatError, "nil #{f} field in header #{header.inspect} (source #@source offset #@source_info)" unless header[f]
- end
+ @from = PersonManager.person_for header["from"]
- begin
- date = header["date"]
- @date = Time === date ? date : Time.parse(header["date"])
- rescue ArgumentError => e
- raise MessageFormatError, "unparsable date #{header['date']}: #{e.message}"
+ @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
+ date = header["date"]
+ @date =
+ case date
+ when Time
+ date
+ when String
+ begin
+ Time.parse date
+ rescue ArgumentError => e
+ raise MessageFormatError, "unparsable date #{header['date']}: #{e.message}"
+ end
+ else
+ Redwood::log "faking date header for #{@id}"
+ Time.now
+ end
+
@subj = header.member?("subject") ? header["subject"].gsub(/\s+/, " ").gsub(/\s+$/, "") : DEFAULT_SUBJECT
- @from = PersonManager.person_for header["from"]
@to = PersonManager.people_for header["to"]
@cc = PersonManager.people_for header["cc"]
@bcc = PersonManager.people_for header["bcc"]
- @id = header["message-id"]
@refs = (header["references"] || "").gsub(/[<>]/, "").split(/\s+/).flatten
@replytos = (header["in-reply-to"] || "").scan(/<(.*?)>/).flatten
@replyto = PersonManager.person_for header["reply-to"]
@recipient_email = header["envelope-to"] || header["x-original-to"] || header["delivered-to"]
@source_marked_read = header["status"] == "RO"
end
- private :read_header
+ private :parse_header
def snippet; @snippet || chunks && @snippet; end
def is_list_message?; !@list_address.nil?; end
## bloat the index.
## actually, it's also the differentiation between to/cc/bcc,
## so i will keep this.
- read_header @source.load_header(@source_info)
+ parse_header @source.load_header(@source_info)
message_to_chunks @source.load_message(@source_info)
rescue SourceError, SocketError, MessageFormatError => e
Redwood::log "problem getting messages from #{@source}: #{e.message}"
EOS
end
- def raw_header
+ def with_source_errors_handled
begin
- @source.raw_header @source_info
+ yield
rescue SourceError => e
Redwood::log "problem getting messages from #{@source}: #{e.message}"
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
## the general behavior i want is: ignore content-disposition, at
## least in so far as it suggests something being inline vs being an
## attachment. (because really, that should be the recipient's
- ## decision to make.) if a mime part is text/plain, then decode it
- ## and display it inline. if it has associated filename, then make
- ## it collapsable and individually saveable; otherwise, treat it as
- ## regular body text.
+ ## decision to make.) if a mime part is text/plain, OR if the user
+ ## decoding hook converts it, then decode it and display it
+ ## inline. for these decoded attachments, if it has associated
+ ## filename, then make it collapsable and individually saveable;
+ ## otherwise, treat it as regular body text.
+ ##
+ ## everything else is just an attachment and is not displayed
+ ## inline.
##
## so, in contrast to mutt, the user is not exposed to the workings
## of the gruesome slaughterhouse and sausage factory that is a
## mime-encoded message, but need only see the delicious end
## product.
- def message_to_chunks m
+
+ 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
+
+ [CryptoSignature.new(payload, signature), message_to_chunks(payload)].flatten
+ end
+
+ def message_to_chunks m, sibling_types=[]
if m.multipart?
- m.body.map { |p| message_to_chunks p }.flatten.compact # recurse
+ chunks = multipart_signed_to_chunks(m) if m.header.content_type == "multipart/signed"
+ 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
else
filename =
## first, paw through the headers looking for a filename
if m.header["Content-Disposition"] &&
- m.header["Content-Disposition"] =~ /filename="(.*?[^\\])"/
+ m.header["Content-Disposition"] =~ /filename="?(.*?[^\\])("|;|$)/
$1
elsif m.header["Content-Type"] &&
m.header["Content-Type"] =~ /name=(.*?)(;|$)/
## if there's a filename, we'll treat it as an attachment.
if filename
- [Attachment.new(m.header.content_type, filename, m)]
+ [Attachment.new(m.header.content_type, filename, m, sibling_types)]
## otherwise, it's body text
else
- body = Message.decode_and_convert m
-
+ body = Message.convert_from m.decode, m.charset
text_to_chunks body.normalize_whitespace.split("\n")
end
end
end
- def self.decode_and_convert m
- charset =
- if m.header.field?("content-type") && m.header.fetch("content-type") =~ /charset=(.*?)(;|$)/
- $1
- end
-
- m.body && body = m.decode or raise MessageFormatError, "For some bizarre reason, RubyMail was unable to parse this message."
+ def self.convert_from body, charset
+ return body unless charset
- if charset
- begin
- body = Iconv.iconv($encoding, charset, body).join
- rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence => e
- Redwood::log "warning: error decoding message body from #{charset}: #{e.message}"
- end
+ begin
+ Iconv.iconv($encoding, charset, body).join
+ rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence => 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
- body
end
## parse the lines of text into chunk objects. the heuristics here
projects / sup / blobdiff