sup 0.3 → 0.4

data/lib/sup/crypto.rb

@@ -3,42 +3,98 @@ module Redwood
 class CryptoManager
   include Singleton
 
+  class Error < StandardError; end
+
+  OUTGOING_MESSAGE_OPERATIONS = OrderedHash.new(
+    [:sign, "Sign"],
+    [:sign_and_encrypt, "Sign and encrypt"],
+    [:encrypt, "Encrypt only"]
+  )
+
   def initialize
     @mutex = Mutex.new
     self.class.i_am_the_instance self
 
     bin = `which gpg`.chomp
-    bin = `which pgp`.chomp unless bin =~ /\S/
 
     @cmd =
       case bin
       when /\S/
+        Redwood::log "crypto: detected gpg binary in #{bin}"
         "#{bin} --quiet --batch --no-verbose --logger-fd 1 --use-agent"
       else
+        Redwood::log "crypto: no gpg binary detected"
         nil
       end
   end
 
-  # returns a cryptosignature
+  def have_crypto?; !@cmd.nil? end
+
+  def sign from, to, payload
+    payload_fn = Tempfile.new "redwood.payload"
+    payload_fn.write format_payload(payload)
+    payload_fn.close
+
+    output = run_gpg "--output - --armor --detach-sign --textmode --local-user '#{from}' #{payload_fn.path}"
+
+    raise Error, (output || "gpg command failed: #{cmd}") unless $?.success?
+
+    envelope = RMail::Message.new
+    envelope.header["Content-Type"] = 'multipart/signed; protocol="application/pgp-signature"; micalg=pgp-sha1'
+
+    envelope.add_part payload
+    signature = RMail::Message.make_attachment output, "application/pgp-signature", nil, "signature.asc"
+    envelope.add_part signature
+    envelope
+  end
+
+  def encrypt from, to, payload, sign=false
+    payload_fn = Tempfile.new "redwood.payload"
+    payload_fn.write format_payload(payload)
+    payload_fn.close
+
+    recipient_opts = to.map { |r| "--recipient '#{r}'" }.join(" ")
+    sign_opts = sign ? "--sign --local-user '#{from}'" : ""
+    gpg_output = run_gpg "--output - --armor --encrypt --textmode #{sign_opts} #{recipient_opts} #{payload_fn.path}"
+    raise Error, (gpg_output || "gpg command failed: #{cmd}") unless $?.success?
+
+    encrypted_payload = RMail::Message.new
+    encrypted_payload.header["Content-Type"] = "application/octet-stream"
+    encrypted_payload.header["Content-Disposition"] = 'inline; filename="msg.asc"'
+    encrypted_payload.body = gpg_output
+
+    control = RMail::Message.new
+    control.header["Content-Type"] = "application/pgp-encrypted"
+    control.header["Content-Disposition"] = "attachment"
+    control.body = "Version: 1\n"
+
+    envelope = RMail::Message.new
+    envelope.header["Content-Type"] = 'multipart/encrypted; protocol="application/pgp-encrypted"'
+
+    envelope.add_part control
+    envelope.add_part encrypted_payload
+    envelope
+  end
+
+  def sign_and_encrypt from, to, payload
+    encrypt from, to, payload, true
+  end
+
   def verify payload, signature # both RubyMail::Message objects
     return unknown_status(cant_find_binary) unless @cmd
 
     payload_fn = Tempfile.new "redwood.payload"
-    payload_fn.write payload.to_s.gsub(/(^|[^\r])\n/, "\\1\r\n").gsub(/^MIME-Version: .*\r\n/, "")
+    payload_fn.write format_payload(payload)
     payload_fn.close
 
     signature_fn = Tempfile.new "redwood.signature"
     signature_fn.write signature.decode
     signature_fn.close
 
-    cmd = "#{@cmd} --verify #{signature_fn.path} #{payload_fn.path} 2> /dev/null"
-
-    #Redwood::log "gpg: running: #{cmd}"
-    gpg_output = `#{cmd}`
-    #Redwood::log "got output: #{gpg_output.inspect}"
-    output_lines = gpg_output.split(/\n/)
+    output = run_gpg "--verify #{signature_fn.path} #{payload_fn.path}"
+    output_lines = output.split(/\n/)
 
-    if gpg_output =~ /^gpg: (.* signature from .*$)/
+    if output =~ /^gpg: (.* signature from .*$)/
       if $? == 0
         Chunk::CryptoNotice.new :valid, $1, output_lines
       else
@@ -49,35 +105,22 @@ class CryptoManager
     end
   end
 
-  # returns decrypted_message, status, desc, lines
-  def decrypt payload # RubyMail::Message objects
+  ## returns decrypted_message, status, desc, lines
+  def decrypt payload # a RubyMail::Message object
     return unknown_status(cant_find_binary) unless @cmd
 
-#    cmd = "#{@cmd} --decrypt 2> /dev/null"
-
-#    Redwood::log "gpg: running: #{cmd}"
-
-#    gpg_output =
-#      IO.popen(cmd, "a+") do |f|
-#        f.puts payload.to_s
-#        f.gets
-#      end
-
     payload_fn = Tempfile.new "redwood.payload"
     payload_fn.write payload.to_s
     payload_fn.close
 
-    cmd = "#{@cmd} --decrypt #{payload_fn.path} 2> /dev/null"
-    Redwood::log "gpg: running: #{cmd}"
-    gpg_output = `#{cmd}`
-    Redwood::log "got output: #{gpg_output.inspect}"
+    output = run_gpg "--decrypt #{payload_fn.path}"
 
-    if $? == 0 # successful decryption
+    if $?.success?
       decrypted_payload, sig_lines =
-        if gpg_output =~ /\A(.*?)((^gpg: .*$)+)\Z/m
+        if output =~ /\A(.*?)((^gpg: .*$)+)\Z/m
           [$1, $2]
         else
-          [gpg_output, nil]
+          [output, nil]
         end
       
       sig = 
@@ -92,7 +135,7 @@ class CryptoManager
       notice = Chunk::CryptoNotice.new :valid, "This message has been decrypted for display"
       [RMail::Parser.read(decrypted_payload), sig, notice]
     else
-      notice = Chunk::CryptoNotice.new :invalid, "This message could not be decrypted", gpg_output.split("\n")
+      notice = Chunk::CryptoNotice.new :invalid, "This message could not be decrypted", output.split("\n")
       [nil, nil, notice]
     end
   end
@@ -104,7 +147,19 @@ private
   end
   
   def cant_find_binary
-    ["Can't find gpg or pgp binary in path"]
+    ["Can't find gpg binary in path."]
+  end
+
+  def format_payload payload
+    payload.to_s.gsub(/(^|[^\r])\n/, "\\1\r\n").gsub(/^MIME-Version: .*\r\n/, "")
+  end
+
+  def run_gpg args
+    cmd = "#{@cmd} #{args} 2> /dev/null"
+    #Redwood::log "crypto: running: #{cmd}"
+    output = `#{cmd}`
+    #Redwood::log "crypto: output: #{output.inspect}" unless $?.success?
+    output
   end
 end
 end

data/lib/sup/draft.rb

@@ -23,20 +23,20 @@ class DraftManager
     @source.each do |thisoffset, theselabels|
       m = Message.new :source => @source, :source_info => thisoffset, :labels => theselabels
       Index.sync_message m
-      UpdateManager.relay self, :add, m
+      UpdateManager.relay self, :added, m
       my_message = m if thisoffset == offset
     end
 
     my_message
   end
 
-  def discard mid
-    docid, entry = Index.load_entry_for_id mid
-    raise ArgumentError, "can't find entry for draft: #{mid.inspect}" unless entry
-    raise ArgumentError, "not a draft: source id #{entry[:source_id].inspect}, should be #{DraftManager.source_id.inspect} for #{mid.inspect} / docno #{docid}" unless entry[:source_id].to_i == DraftManager.source_id
+  def discard m
+    docid, entry = Index.load_entry_for_id m.id
+    raise ArgumentError, "can't find entry for draft: #{m.id.inspect}" unless entry
+    raise ArgumentError, "not a draft: source id #{entry[:source_id].inspect}, should be #{DraftManager.source_id.inspect} for #{m.id.inspect} / docno #{docid}" unless entry[:source_id].to_i == DraftManager.source_id
     Index.drop_entry docid
     File.delete @source.fn_for_offset(entry[:source_info])
-    UpdateManager.relay self, :delete, mid
+    UpdateManager.relay self, :single_message_deleted, m
   end
 end
 
@@ -99,6 +99,12 @@ class DraftLoader < Source
     ret
   end
 
+  def each_raw_message_line offset
+    File.open(fn_for_offset(offset)) do |f|
+      yield f.gets until f.eof?
+    end
+  end
+
   def raw_message offset
     IO.readlines(fn_for_offset(offset)).join
   end

data/lib/sup/horizontal-selector.rb

@@ -0,0 +1,47 @@
+module Redwood
+
+class HorizontalSelector
+  attr_accessor :label
+
+  def initialize label, vals, labels, base_color=:horizontal_selector_unselected_color, selected_color=:horizontal_selector_selected_color
+    @label = label
+    @vals = vals
+    @labels = labels
+    @base_color = base_color
+    @selected_color = selected_color
+    @selection = 0
+  end
+
+  def set_to val; @selection = @vals.index(val) end
+
+  def val; @vals[@selection] end
+
+  def line width=nil
+    label =
+      if width
+        sprintf "%#{width}s ", @label
+      else
+        "#{@label} "
+      end
+
+    [[@base_color, label]] + 
+      (0 ... @labels.length).inject([]) do |array, i|
+        array + [
+          if i == @selection
+            [@selected_color, @labels[i]]
+          else
+            [@base_color, @labels[i]]
+          end] + [[@base_color, "  "]]
+      end + [[@base_color, ""]]
+  end
+
+  def roll_left
+    @selection = (@selection - 1) % @labels.length
+  end
+
+  def roll_right
+    @selection = (@selection + 1) % @labels.length
+  end
+end
+
+end

data/lib/sup/imap.rb

@@ -5,39 +5,39 @@ require 'time'
 require 'rmail'
 require 'cgi'
 
-## fucking imap fucking sucks. what the FUCK kind of committee of
-## dunces designed this shit.
+## fucking imap fucking sucks. what the FUCK kind of committee of dunces
+## designed this shit.
 ##
 ## imap talks about 'unique ids' for messages, to be used for
-## cross-session identification. great---just what sup needs! except
-## it turns out the uids can be invalidated every time the
-## 'uidvalidity' value changes on the server, and 'uidvalidity' can
-## change without restriction. it can change any time you log in. it
-## can change EVERY time you log in. of course the imap spec "strongly
-## recommends" that it never change, but there's nothing to stop
-## people from just setting it to the current timestamp, and in fact
-## that's exactly what the one imap server i have at my disposal
-## does. thus the so-called uids are absolutely useless and imap
-## provides no cross-session way of uniquely identifying a
-## message. but thanks for the "strong recommendation", guys!
+## cross-session identification. great---just what sup needs! except it
+## turns out the uids can be invalidated every time the 'uidvalidity'
+## value changes on the server, and 'uidvalidity' can change without
+## restriction. it can change any time you log in. it can change EVERY
+## time you log in. of course the imap spec "strongly recommends" that it
+## never change, but there's nothing to stop people from just setting it
+## to the current timestamp, and in fact that's exactly what the one imap
+## server i have at my disposal does. thus the so-called uids are
+## absolutely useless and imap provides no cross-session way of uniquely
+## identifying a message. but thanks for the "strong recommendation",
+## guys!
 ##
 ## so right now i'm using the 'internal date' and the size of each
 ## message to uniquely identify it, and i scan over the entire mailbox
 ## each time i open it to map those things to message ids. that can be
-## slow for large mailboxes, and we'll just have to hope that there
-## are no collisions. ho ho! a perfectly reasonable solution!
+## slow for large mailboxes, and we'll just have to hope that there are
+## no collisions. ho ho! a perfectly reasonable solution!
 ##
 ## and here's another thing. check out RFC2060 2.2.2 paragraph 5:
 ##
-##   A client MUST be prepared to accept any server response at all times.
-##   This includes server data that was not requested.
+##   A client MUST be prepared to accept any server response at all
+##   times.  This includes server data that was not requested.
 ##
-## yeah. that totally makes a lot of sense. and once again, the idiocy
-## of the spec actually happens in practice. you'll request flags for
-## one message, and get it interspersed with a random bunch of flags
-## for some other messages, including a different set of flags for the
-## same message! totally ok by the imap spec. totally retarded by any
-## other metric.
+## yeah. that totally makes a lot of sense. and once again, the idiocy of
+## the spec actually happens in practice. you'll request flags for one
+## message, and get it interspersed with a random bunch of flags for some
+## other messages, including a different set of flags for the same
+## message! totally ok by the imap spec. totally retarded by any other
+## metric.
 ##
 ## fuck you, imap committee. you managed to design something nearly as
 ## shitty as mbox but goddamn THIRTY YEARS LATER.
@@ -72,11 +72,7 @@ class IMAP < Source
   end
 
   def self.suggest_labels_for path
-    if path =~ /inbox/i
-      [path.intern]
-    else
-      []
-    end
+    path =~ /([^\/]*inbox[^\/]*)/i ? [$1.downcase.intern] : []
   end
 
   def host; @parsed_uri.host; end
@@ -141,6 +137,7 @@ class IMAP < Source
       @ids << id
       @imap_state[id] = { :id => v.seqno, :flags => v.attr["FLAGS"] }
     end
+    Redwood::log "done fetching IMAP headers"
   end
   synchronized :scan_mailbox
 
@@ -208,11 +205,11 @@ private
   def unsafe_connect
     say "Connecting to IMAP server #{host}:#{port}..."
 
-    ## apparently imap.rb does a lot of threaded stuff internally and
-    ## if an exception occurs, it will catch it and re-raise it on the
-    ## calling thread. but i can't seem to catch that exception, so
-    ## i've resorted to initializing it in its own thread. surely
-    ## there's a better way.
+    ## apparently imap.rb does a lot of threaded stuff internally and if
+    ## an exception occurs, it will catch it and re-raise it on the
+    ## calling thread. but i can't seem to catch that exception, so i've
+    ## resorted to initializing it in its own thread. surely there's a
+    ## better way.
     exception = nil
     ::Thread.new do
       begin
@@ -220,9 +217,9 @@ private
         @imap = Net::IMAP.new host, port, ssl?
         say "Logging in..."
 
-        ## although RFC1730 claims that "If an AUTHENTICATE command
-        ## fails with a NO response, the client may try another", in
-        ## practice it seems like they can also send a BAD response.
+        ## although RFC1730 claims that "If an AUTHENTICATE command fails
+        ## with a NO response, the client may try another", in practice
+        ## it seems like they can also send a BAD response.
         begin
           raise Net::IMAP::NoResponseError unless @imap.capability().member? "AUTH=CRAM-MD5"
           @imap.authenticate 'CRAM-MD5', @username, @password
@@ -273,7 +270,23 @@ private
     imap_id = @imap_state[id][:id]
     result = fetch(imap_id, (fields + ['RFC822.SIZE', 'INTERNALDATE']).uniq).first
     got_id = make_id result
-    raise OutOfSyncSourceError, "IMAP message mismatch: requested #{id}, got #{got_id}." unless got_id == id
+
+    ## I've turned off the following sanity check because Microsoft
+    ## Exchange fails it.  Exchange actually reports two different
+    ## INTERNALDATEs for the exact same message when queried at different
+    ## points in time.
+    ##
+    ## RFC2060 defines the semantics of INTERNALDATE for messages that
+    ## arrive via SMTP for via various IMAP commands, but states that
+    ## "All other cases are implementation defined.". Great, thanks guys,
+    ## yet another useless field.
+    ## 
+    ## Of course no OTHER imap server I've encountered returns DIFFERENT
+    ## values for the SAME message. But it's Microsoft; what do you
+    ## expect? If their programmers were any good they'd be working at
+    ## Google.
+
+    # raise OutOfSyncSourceError, "IMAP message mismatch: requested #{id}, got #{got_id}." unless got_id == id
 
     fields.map { |f| result.attr[f] or raise FatalSourceError, "empty response from IMAP server: #{f}" }
   end

data/lib/sup/index.rb

@@ -171,17 +171,24 @@ EOS
       end
 
     to = (m.to + m.cc + m.bcc).map { |x| x.email }.join(" ")
+    snippet = 
+      if m.snippet_contains_encrypted_content? && $config[:discard_snippets_from_encrypted_messages]
+        ""
+      else
+        m.snippet
+      end
+
     d = {
       :message_id => m.id,
       :source_id => source_id,
       :source_info => m.source_info,
       :date => m.date.to_indexable_s,
       :body => m.content,
-      :snippet => m.snippet,
+      :snippet => snippet,
       :label => m.labels.uniq.join(" "),
       :from => m.from ? m.from.email : "",
       :to => (m.to + m.cc + m.bcc).map { |x| x.email }.join(" "),
-      :subject => wrap_subj(Message.normalize_subj(m.subj)),
+      :subject => wrap_subj(m.subj),
       :refs => (m.refs + m.replytos).uniq.join(" "),
     }
 
@@ -236,6 +243,7 @@ EOS
   ## true, stops loading any thread if a message with a :killed flag
   ## is found.
   SAME_SUBJECT_DATE_LIMIT = 7
+  MAX_CLAUSES = 1000
   def each_message_in_thread_for m, opts={}
     #Redwood::log "Building thread for #{m.id}: #{m.subj}"
     messages = {}
@@ -264,13 +272,16 @@ EOS
 
     until pending.empty? || (opts[:limit] && messages.size >= opts[:limit])
       q = Ferret::Search::BooleanQuery.new true
+      # this disappeared in newer ferrets... wtf.
+      # q.max_clause_count = 2048
 
-      pending.each do |id|
+      lim = [MAX_CLAUSES / 2, pending.length].min
+      pending[0 ... lim].each do |id|
         searched[id] = true
         q.add_query Ferret::Search::TermQuery.new(:message_id, id), :should
         q.add_query Ferret::Search::TermQuery.new(:refs, id), :should
       end
-      pending = []
+      pending = pending[lim .. -1]
 
       q = build_query :qobj => q
 
@@ -313,7 +324,7 @@ EOS
       "date" => Time.at(doc[:date].to_i),
       "subject" => unwrap_subj(doc[:subject]),
       "from" => doc[:from],
-      "to" => doc[:to],
+      "to" => doc[:to].split(/\s+/).join(", "), # reformat
       "message-id" => doc[:message_id],
       "references" => doc[:refs].split(/\s+/).map { |x| "<#{x}>" }.join(" "),
     }
@@ -382,19 +393,67 @@ protected
 
   ## do any specialized parsing
   ## returns nil and flashes error message if parsing failed
-  def parse_user_query_string str
-    result = str.gsub(/\b(to|from):(\S+)\b/) do
+  def parse_user_query_string s
+    extraopts = {}
+
+    ## this is a little hacky, but it works, at least until ferret changes
+    ## its api. we parse the user query string with ferret twice: the first
+    ## time we just turn the resulting object back into a string, which has
+    ## the next effect of transforming the original string into a nice
+    ## normalized form with + and - instead of AND, OR, etc. then we do some
+    ## string substitutions which depend on this normalized form, re-parse
+    ## the string with Ferret, and return the resulting query object.
+
+    norms = @qparser.parse(s).to_s
+    Redwood::log "normalized #{s.inspect} to #{norms.inspect}" unless s == norms
+
+    subs = norms.gsub(/\b(to|from):(\S+)\b/) do
       field, name = $1, $2
       if(p = ContactManager.contact_for(name))
         [field, p.email]
+      elsif name == "me"
+        [field, "(" + AccountManager.user_emails.join("||") + ")"]
       else
         [field, name]
       end.join(":")
     end
-    
+
+    ## if we see a label:deleted or a label:spam term anywhere in the query
+    ## string, we set the extra load_spam or load_deleted options to true.
+    ## bizarre? well, because the query allows arbitrary parenthesized boolean
+    ## expressions, without fully parsing the query, we can't tell whether
+    ## the user is explicitly directing us to search spam messages or not.
+    ## e.g. if the string is -(-(-(-(-label:spam)))), does the user want to
+    ## search spam messages or not?
+    ##
+    ## so, we rely on the fact that turning these extra options ON turns OFF
+    ## the adding of "-label:deleted" or "-label:spam" terms at the very
+    ## final stage of query processing. if the user wants to search spam
+    ## messages, not adding that is the right thing; if he doesn't want to
+    ## search spam messages, then not adding it won't have any effect.
+    extraopts[:load_spam] = true if subs =~ /\blabel:spam\b/
+    extraopts[:load_deleted] = true if subs =~ /\blabel:deleted\b/
+
+    ## gmail style "is" operator
+    subs = subs.gsub(/\b(is):(\S+)\b/) do
+      field, label = $1, $2
+      case label
+      when "read"
+        "-label:unread"
+      when "spam"
+        extraopts[:load_spam] = true
+        "label:spam"
+      when "deleted"
+        extraopts[:load_deleted] = true
+        "label:deleted"
+      else
+        "label:#{$2}"
+      end
+    end
+
     if $have_chronic
       chronic_failure = false
-      result = result.gsub(/\b(before|on|in|after):(\((.+?)\)\B|(\S+)\b)/) do
+      subs = subs.gsub(/\b(before|on|in|during|after):(\((.+?)\)\B|(\S+)\b)/) do
         break if chronic_failure
         field, datestr = $1, ($3 || $4)
         realdate = Chronic.parse(datestr, :guess => false, :context => :none)
@@ -411,15 +470,19 @@ protected
             "date:(<= #{sprintf "%012d", realdate.end.to_i}) date:(>= #{sprintf "%012d", realdate.begin.to_i})"
           end
         else
-          BufferManager.flash "Don't understand date #{datestr.inspect}!"
+          BufferManager.flash "Can't understand date #{datestr.inspect}!"
           chronic_failure = true
         end
       end
-      result = nil if chronic_failure
+      subs = nil if chronic_failure
     end
     
-    Redwood::log "translated #{str.inspect} to #{result}" unless result == str
-    @qparser.parse result if result
+    Redwood::log "translated #{norms.inspect} to #{subs.inspect}" unless subs == norms
+    if subs
+      [@qparser.parse(subs), extraopts]
+    else
+      nil
+    end
   end
 
   def build_query opts