hermeneutics 1.11 → 1.14

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
+

data/lib/hermeneutics/cli/pop3.rb

@@ -0,0 +1,257 @@
+#
+#  hermeneutics/cli/pop3.rb  --  POP3 client
+#
+
+require "hermeneutics/cli/protocol"
+
+module Hermeneutics
+
+  module Cli
+
+    class POP3 < Protocol
+
+      CRLF = true
+
+      PORT, PORT_SSL = 110, 995
+
+      class Error       < StandardError ; end
+      class UnspecError < Error         ; end
+      class AuthFail    < Error         ; end
+      class Check       < Error         ; end
+      class Unused      < 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
+        end
+      end
+
+      attr_reader :last_response
+
+      def initialize *args
+        super
+        @stamp = get_response.slice /<[!-~]+@[!-~]+>/
+      end
+
+      def authenticate name, pwd
+        if @stamp then
+          apop name, pwd
+        else
+          user name
+          pass pwd
+        end
+      end
+
+      def user name
+        writeline "USER #{name}"
+        get_response
+      end
+
+      def pass pwd
+        writeline "PASS #{pwd}"
+        get_response_auth
+      end
+
+      def apop name, pwd
+        require "digest/md5"
+        hash = Digest::MD5.hexdigest "#@stamp#{pwd}"
+        writeline "APOP #{name} #{hash}"
+        get_response_auth
+      end
+
+      def capa
+        if block_given? then
+          writeline "CAPA"
+          get_response do |_|
+            get_data { |l|
+              c, *rest = l.split
+              yield c, rest
+            }
+          end
+        else
+          r = Hash.new do |h,k| h[k] = [] end
+          capa do |c,v|
+            if v.notempty? then
+              r[c].concat v
+            else
+              r[c] = true
+            end
+          end
+          r
+        end
+      end
+
+      def stat
+        if block_given? then
+          writeline "STAT"
+          n, r = split_num_len get_response
+          yield n, r
+        else
+          stat do |*a| a end
+        end
+      end
+
+      def list n = nil
+        n = n.to_i.nonzero?
+        if block_given? then
+          cmd = "LIST"
+          cmd << " #{n}" if n
+          writeline cmd
+          if n then
+            n_, len = split_num_len get_response
+            n == n_ or raise Check, "Wrong LIST response: #{n} <-> #{n_}"
+            yield n, len
+          else
+            get_response do |_|
+              get_data do |l|
+                n_, len = split_num_len l
+                yield n_, len
+              end
+            end
+          end
+        else
+          if n then
+            list n do |*a| a end
+          else
+            h = {}
+            list n do |n_,len|
+              h[ n_] = len
+            end
+            h
+          end
+        end
+      end
+
+      def uidl n = nil
+        n = n.to_i.nonzero?
+        if block_given? then
+          cmd = "UIDL"
+          cmd << " #{n}" if n
+          writeline cmd
+          if n then
+            n_, id = split_num get_response
+            n == n_ or raise Check, "Wrong UIDL response: #{n} <-> #{n_}"
+            yield n, id
+          else
+            get_response do |_|
+              get_data do |l|
+                n_, id = split_num l
+                yield n_, id
+              end
+            end
+          end
+        else
+          if n then
+            uidl n do |*a| a end
+          else
+            h = {}
+            uidl n do |n_,id|
+              h[ n_] = id
+            end
+            h
+          end
+        end
+      end
+
+      def retr n, &block
+        writeline "RETR #{n}"
+        get_response do |_|
+          get_data_str &block
+        end
+      end
+
+      def top n, x, &block
+        writeline "TOP #{n} #{x}"
+        get_response do |_|
+          get_data_str &block
+        end
+      end
+
+
+      def dele n
+        writeline "DELE #{n}"
+        get_response
+      end
+
+      def rset
+        writeline "RSET"
+        get_response
+      end
+
+      def noop
+        writeline "NOOP"
+        get_response
+      end
+
+      def quit
+        writeline "QUIT"
+        get_response
+      end
+
+      private
+
+      def get_response
+        r = readline
+        a = case r
+          when /^\+OK */  then @last_response = $'.notempty?
+          when /^\-ERR */ then raise Error, $'
+          else                 raise UnspecError, r
+        end
+        if block_given? then
+          yield a
+        else
+          a
+        end
+      ensure
+        unless done? then
+          r = readline
+          r and raise Unused, "Unexpected data: #{r.inspect}"
+        end
+      end
+
+      def get_response_auth
+        begin
+          get_response
+        rescue Error
+          err = $!.message
+        end
+        raise AuthFail, err if err
+      end
+
+      def get_data
+        loop do
+          l = readline
+          break if l == "."
+          l.slice /\A\./
+          yield l
+        end
+      end
+
+      def get_data_str
+        if block_given? then
+          get_data { |l| yield l }
+        else
+          r = ""
+          get_data { |l| r << l << "\n" }
+          r
+        end
+      end
+
+      def split_num str
+        n, r = str.split nil, 2
+        [ n.to_i, r]
+      end
+
+      def split_num_len str
+        n, r = split_num str
+        [ n, r.to_i]
+      end
+
+    end
+
+  end
+
+end
+

data/lib/hermeneutics/cli/protocol.rb

@@ -0,0 +1,141 @@
+#
+#  hermeneutics/cli/protocol.rb  --  Basic communication
+#
+
+require "supplement"
+require "socket"
+
+
+if RUBY_VERSION < "3" then
+  class TCPSocket
+    class <<self
+      alias open_orig open
+      def open host, port, connect_timeout: nil, &block
+        open_orig host, port, &block
+      end
+    end
+  end
+end
+
+module Hermeneutics
+
+  module Cli
+
+    class Protocol
+
+      class <<self
+        private :new
+        def open host, port, timeout: nil, ssl: false
+          open_socket host, port, timeout, ssl do |s|
+            i = new s, timeout
+            yield i
+          end
+        end
+        private
+        def open_socket host, port, timeout, ssl
+          TCPSocket.open host, port, connect_timeout: timeout do |s|
+            if ssl then
+              require "hermeneutics/cli/openssl"
+              if Hash === ssl then
+                if ssl[ :ca_file] || ssl[ :ca_path] then
+                  ssl[ :verify_mode] ||= OpenSSL::SSL::VERIFY_PEER
+                end
+              else
+                vfm = case ssl
+                  when true    then OpenSSL::SSL::VERIFY_NONE
+                  when Integer then ssl
+                  when :none   then OpenSSL::SSL::VERIFY_NONE
+                  when :peer   then OpenSSL::SSL::VERIFY_PEER
+                end
+                ssl = { verify_mode: vfm}
+              end
+              ctx = OpenSSL::SSL::SSLContext.new
+              ctx.set_params ssl
+              s = OpenSSL::SSL::SSLSocket.new s, ctx
+              s.connect
+            end
+            yield s
+          end
+        end
+      end
+
+      CRLF = false
+
+      attr_writer :timeout
+
+      def initialize socket, timeout
+        @socket, @timeout = socket, timeout
+      end
+
+      def trace!
+        @trace = true
+      end
+
+      def writeline l
+        l.chomp!
+        @trace and $stderr.puts "C: #{l}"
+        @socket.write l
+        @socket.write self.class::CRLF ? "\r\n" : "\n"
+      end
+
+      def readline
+        @socket.wait @timeout||0
+        r = @socket.readline
+        r.chomp!
+        @trace and $stderr.puts "S: #{r}"
+        r
+      rescue EOFError
+      end
+
+      def write data
+        @trace and $stderr.puts "C- #{data.inspect}"
+        @socket.write data
+      end
+
+      def read bytes
+        @socket.wait @timeout||0
+        r = @socket.read bytes
+        @trace and $stderr.puts "S- #{r.inspect}"
+        r
+      rescue EOFError
+      end
+
+      def done?
+        not @socket.ready?
+      end
+
+    end
+
+
+    module CramMD5
+
+      class <<self
+        def included cls
+          require "digest/md5"
+        end
+      end
+
+      private
+
+      def crammd5_answer a
+        "#@user #{hmac_md5 a, @passwd}"
+      end
+
+      MASKS = [ 0x36, 0x5c, ]
+      IMASK, OMASK = *MASKS
+
+      def hmac_md5 text, key
+        key = Digest::MD5.digest key if key.length > 64
+        nulls = [ 0]*64
+        k_ip, k_op = *MASKS.map { |m|
+          (nulls.zip key.bytes).map { |n,k| ((k||n) ^ m).chr }.join
+        }
+        Digest::MD5.hexdigest k_op + (Digest::MD5.digest k_ip + text)
+      end
+
+    end
+
+  end
+
+end
+