hermeneutics 1.10 → 1.13

data/lib/hermeneutics/cli/imap/parser.rb

@@ -0,0 +1,245 @@
+#
+#  hermeneutics/cli/imap/parser.rb  --  Parsing IMAP responses
+#
+
+require "supplement"
+
+require "hermeneutics/cli/imap/utf7imap"
+
+
+module Hermeneutics
+
+  module Cli
+
+    module ImapTools
+
+      class StringReader
+        def initialize src
+          @src = src.lines
+          @src.each { |l| l.chomp! }
+        end
+        def readline
+          @src.shift
+        end
+        def eof? ; @src.empty? ; end
+      end
+
+
+      class Parser
+
+        RE = %r/\A\s*(?:
+          (\()|
+          (\))|
+          ("(?:[^\\"]|\\.)*")|
+          (\{\d+\}\z)|
+          ((?:\[[^\]]*\]|[^ \t)])+)|
+        )/x
+
+        class <<self
+
+          def run input
+            p = new
+            l = input.readline
+            loop do
+              if l.empty? then
+                break if p.closed?
+                l = input.readline
+              end
+              l.slice! RE
+              case
+                when $1 then
+                  p.step_in
+                when $2 then
+                  p.step_out
+                when $3 then
+                  r = UTF7.decode $3
+                  p.add r
+                when $4 then
+                  n = $4[1,$4.length-2].to_i
+                  r = ""
+                  while n > 0 do
+                    l = input.readline
+                    l or raise "No more data after {#$4}"
+                    m = l.length
+                    if n <= m then
+                      r << (l.slice! 0, n)
+                    else
+                      r << l << "\n"
+                      l.clear
+                      n -= 2
+                    end
+                    n -= m
+                  end
+                  p.add r
+                when $5 then
+                  r = $5.nil_if "NIL"
+                  r = UTF7.decode r if r
+                  p.add r
+                else
+                  raise "Error reading '#$''"
+              end
+            end
+            p
+          end
+
+          def compile input, compiler
+            p = run input
+            p.walk compiler
+            compiler.result
+          end
+
+        end
+
+        def initialize
+          @list = []
+        end
+
+        def step_in
+          if @sub then
+            @sub.step_in
+          else
+            @sub = self.class.new
+          end
+        end
+
+        def step_out
+          if @sub.closed? then
+            @list.push @sub
+            @sub = nil
+          else
+            @sub.step_out
+          end
+        end
+
+        def add token
+          if @sub then
+            @sub.add token
+          else
+            @list.push token
+          end
+        end
+
+        def closed?
+          not @sub
+        end
+
+        def walk compiler
+          closed? or raise "Object was not fully parsed. Rest: #@sub"
+          @list.each { |x|
+            case x
+              when self.class then compiler.step do x.walk compiler end
+              else                 compiler.add x
+            end
+          }
+          compiler.finish
+        end
+
+      end
+
+
+      class Data
+
+        class <<self
+          alias [] new
+        end
+
+        attr_reader :name, :params
+
+        def initialize name, *params
+          @name, @params = name, params
+        end
+
+        def stream_lines r, &block
+          r << " " << @name.to_s
+          add_to_stream r, @params, &block
+          yield [r]
+        end
+
+        private
+
+        # If you think this is too complicated, then complain to
+        # the designers of IMAP.
+        #
+        def add_to_stream r, ary, &block
+          ary.each { |a|
+            r << " " unless @opened
+            @opened = false
+            case a
+              when Array then
+                r << "("
+                @opened = true
+                add_to_stream r, a, &block
+                r << ")"
+                @opened = false
+              else
+                a = a.to_s
+                s = a.notempty? ? (a.split /\r?\n/, -1) : [""]
+                l = s.length - 1
+                if l > 0 then
+                  m = 0
+                  s.each { |e| m += e.length }
+                  m += l*2
+                  r << "{#{m}}"
+                  _ = yield [r]
+                  r.clear
+                  yield s
+                else
+                  r << (UTF7.encode a).to_s
+                end
+            end
+          }
+        end
+
+        public
+
+        class Compiler
+
+          def initialize
+            @list = []
+          end
+
+          def result
+            Data.new @name, *@list
+          end
+
+          def step
+            list_, @list = @list, []
+            sub_, @sub = @sub, true
+            yield
+          ensure
+            list_.push @list
+            @list, @sub = list_, sub_
+          end
+
+          def add x
+            if @sub then
+              @list.push x
+            else
+              if not @name then
+                is_name? x or raise "Not an item name: #{x}"
+                @name = x.to_sym
+              else
+                @list.push x
+              end
+            end
+          end
+
+          def finish
+          end
+
+          private
+
+          def is_name? x
+            x =~ /\A[A-Z]+\z/
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/hermeneutics/cli/imap/utf7imap.rb

@@ -0,0 +1,75 @@
+#
+#  hermeneutics/cli/imap/utf7imap.rb  --  IMAP's UTF-7
+#
+
+require "supplement"
+
+module Hermeneutics
+
+  module Cli
+
+    module ImapTools
+
+      class UTF7
+
+        class <<self
+
+          def encode str
+            e = str.gsub /&|([^ -~]+)/ do
+              if $1 then
+                b64 = [($1.encode Encoding::UTF_16BE)].pack "m0"
+                b64.slice! %r/=+\z/
+                b64.tr! "/", ","
+              end
+              "&#{b64}-"
+            end
+            if e.empty? or e =~ %r/[ "]/ then
+              e = %Q["#{e.gsub /(["\\])/ do "\\#$1" end}"]
+            end
+            new e
+          end
+
+          def decode txt
+            (new txt).decode
+          end
+
+        end
+
+        def initialize txt
+          @txt = txt
+        end
+
+        def to_s ; @txt ; end
+
+        def decode
+          t = @txt
+          if t =~ /\A"(.*)"\z/ then
+            t = $1
+            t.gsub! /\\(.)/ do $1 end
+          end
+          t.gsub /&(.*?)-/ do
+            if $1.empty? then
+              "&"
+            else
+              r = $1
+              r.tr! ",", "/"
+              f = -r.length % 4
+              if f.nonzero? then
+                r << "=" * f
+              end
+              r, = r.unpack "m"
+              r.force_encoding Encoding::UTF_16BE
+              r.encode! Encoding.default_external
+              r
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/hermeneutics/cli/imap.rb

@@ -0,0 +1,240 @@
+#
+#  hermeneutics/cli/imap.rb  --  IMAP client
+#
+
+require "hermeneutics/cli/protocol"
+require "hermeneutics/cli/imap/commands"
+
+
+module Hermeneutics
+
+  module Cli
+
+    class IMAP < Protocol
+
+      CRLF = true
+
+      PORT, PORT_SSL = 143, 993
+
+      class Error          < StandardError ; end
+      class UnspecResponse < Error         ; end
+      class ServerBye      < Error         ; end
+      class ServerError    < Error         ; end
+      class NotOk          < Error         ; end
+
+      class <<self
+        private :new
+        def open host, port = nil, timeout: nil, ssl: false
+          port ||= ssl ? PORT_SSL : PORT
+          super host, port, timeout: timeout, ssl: ssl do |i|
+            yield i
+            i.stop_watch
+          end
+        end
+      end
+
+      TAG_PREFIX = "H"
+
+      def initialize *args
+        super
+        @tag = "H%04d" % 0
+        @info = [ get_response]
+        start_watch
+      end
+
+      attr_reader :info
+
+      def auths data = nil
+        a = []
+        (data||@info.first.data).params.each { |p|
+          p =~ /\AAUTH=/ and a.push $'.to_s
+        }
+        a
+      end
+
+      def command cmd, *args, &block
+        c = cmd.new *args
+        r = write_request c, &block
+        r.ok? or raise NotOk, r.text
+        c.responses
+      end
+
+
+      include ImapTools
+
+      alias readline! readline
+      private :readline!
+
+      def peekline
+        @peek ||= readline!
+      end
+
+      def readline
+        @peek or readline!
+      ensure
+        @peek = nil
+      end
+
+
+      def get_response_plain
+        Response.create @tag, self
+      end
+
+      def get_response
+        r = get_response_plain
+        r.bye? and raise ServerBye, "Server closed the connection"
+        r
+      end
+
+
+      def start_watch
+        @watch = Thread.new do
+          Thread.current.abort_on_exception = true
+          Thread.current.report_on_exception = false
+          while @socket.wait do
+            r = get_response
+            @info.push r
+          end
+        end
+      end
+
+      def stop_watch
+        @watch or return
+        @watch.kill if @watch.alive?
+        @watch.value
+        @watch = nil
+      end
+
+      def write_request cmd
+        stop_watch
+        @tag.succ!
+        r = nil
+        cmd.stream_lines "#@tag" do |a|
+          a.each { |l| writeline l.to_s }
+          r = get_response_plain
+          r.wait? or break
+          if block_given? then  # does only make sense for the IDLE command
+            begin
+              start_watch
+              yield
+            ensure
+              stop_watch
+            end
+          end
+          r.text
+        end
+        until r.done? do
+          bye ||= r.bye?
+          cmd.add_response r
+          r = get_response_plain
+          r or raise ServerError, cmd.responses.last.to_s
+        end
+        bye or start_watch
+        r
+      end
+
+    end
+
+    module ImapTools
+
+      class Response
+        class <<self
+          private :new
+          def create tag, reader
+            p = reader.peekline
+            p and p.slice! /\A(\S+) +/ or return
+            case $1
+              when tag then ResponseFinish.create reader
+              when "+" then ResponseWait.  create reader
+              when "*" then ResponseStatus.create reader or
+                            ResponseData.  create reader
+              else          raise UnspecResponse, reader.readline
+            end
+          end
+          private
+          def compile_string str
+            r = StringReader.new str
+            compile_stream r
+          end
+          def compile_stream reader
+            c = Data::Compiler.new
+            Parser.compile reader, c
+          end
+        end
+        def done? ; false ; end
+        def wait? ; false ; end
+        def bye?  ; false ; end
+      end
+
+      class ResponseWait < Response
+        class <<self
+          def create reader
+            new reader.readline
+          end
+        end
+        attr_reader :text
+        def initialize text ; @text = text ; end
+        def wait? ; true  ; end
+        def to_s ; "#{text}" ; end
+      end
+
+      class ResponseData < Response
+        class <<self
+          def create reader
+            if reader.peekline.slice! /\A(\d+) +/ then
+              n = $1.to_i
+            end
+            data = compile_stream reader
+            new n, data
+          end
+        end
+        attr_reader :num, :data
+        def initialize num, data
+          @num, @data = num, data
+        end
+        def to_s ; "#{num} #{data}" ; end
+      end
+
+      class ResponseStatus < Response
+        class <<self
+          def create reader
+            l = compile_line reader
+            new *l if l
+          end
+          private
+          def compile_line reader
+            if reader.peekline.slice! /\A(OK|NO|BAD|BYE|PREAUTH) +/ then
+              status = $1.to_sym
+              if reader.peekline.slice! /\[(.*)\] +/ then
+                data = compile_string $1
+              end
+              [ status, data, reader.readline]
+            end
+          end
+        end
+        attr_reader :status, :data, :text
+        def initialize status, data, text
+          @status, @data, @text = status, data, text
+        end
+        def ok?  ; @status == :OK  ; end
+        def bye? ; @status == :BYE ; end
+        def to_s ; "#{status} #{data} #{text}" ; end
+      end
+
+      class ResponseFinish < ResponseStatus
+        class <<self
+          def create reader
+            l = compile_line reader
+            new *l if l
+          end
+        end
+        def done? ; true  ; end
+        def to_s ; "finished" ; end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/hermeneutics/cli/openssl.rb

@@ -0,0 +1,11 @@
+require "openssl"
+
+module OpenSSL
+  module SSL
+    class SSLSocket
+      def wait timeout = :read ; @io.wait timeout ; end
+      def ready?               ; @io.ready?       ; end
+    end
+  end
+end
+