dstruct 0.0.1

data/lib/rex/ui/text/input.rb

@@ -0,0 +1,119 @@
+# -*- coding: binary -*-
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# This class acts as a base for all input mediums.  It defines
+# the interface that will be used by anything that wants to
+# interact with a derived class.
+#
+###
+class Input
+
+  require 'rex/ui/text/input/stdio'
+  require 'rex/ui/text/input/readline'
+  require 'rex/ui/text/input/socket'
+  require 'rex/ui/text/input/buffer'
+  require 'rex/ui/text/color'
+
+  include Rex::Ui::Text::Color
+
+  def initialize
+    self.eof = false
+    @config = {
+      :color => :auto, # true, false, :auto
+    }
+    super
+  end
+
+  #
+  # Whether or not the input medium supports readline.
+  #
+  def supports_readline
+    true
+  end
+
+  #
+  # Stub for tab completion reset
+  #
+  def reset_tab_completion
+  end
+
+  #
+  # Calls the underlying system read.
+  #
+  def sysread(len)
+    raise NotImplementedError
+  end
+
+  #
+  # Gets a line of input
+  #
+  def gets
+    raise NotImplementedError
+  end
+
+  #
+  # Has the input medium reached end-of-file?
+  #
+  def eof?
+    return eof
+  end
+
+  #
+  # Returns a pollable file descriptor that is associated with this
+  # input medium.
+  #
+  def fd
+    raise NotImplementedError
+  end
+
+  #
+  # Indicates whether or not this input medium is intrinsicly a
+  # shell provider.  This would indicate whether or not it
+  # already expects to have a prompt.
+  #
+  def intrinsic_shell?
+    false
+  end
+
+  def update_prompt(new_prompt = '', new_prompt_char = '')
+    self.prompt = new_prompt + new_prompt_char
+  end
+
+  attr_reader :config
+
+  def disable_color
+    return if not @config
+    @config[:color] = false
+  end
+
+  def enable_color
+    return if not @config
+    @config[:color] = true
+  end
+
+  def auto_color
+    return if not @config
+    @config[:color] = :auto
+  end
+
+  def update_prompt(prompt)
+    substitute_colors(prompt, true)
+  end
+
+  def reset_color
+  end
+
+  attr_accessor :eof, :prompt, :prompt_char, :config
+
+end
+
+end
+end
+end
+

data/lib/rex/ui/text/input/buffer.rb

@@ -0,0 +1,79 @@
+# -*- coding: binary -*-
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+require 'rex/io/stream_abstraction'
+
+###
+#
+# This class implements input against a socket.
+#
+###
+class Input::Buffer < Rex::Ui::Text::Input
+
+  class BufferSock
+    include Rex::IO::StreamAbstraction
+    def write(buf, opts={})
+      syswrite(buf)
+    end
+  end
+
+  def initialize
+    @sock = BufferSock.new
+    @sock.initialize_abstraction
+  end
+
+  def close
+    @sock.cleanup_abstraction
+  end
+
+  def sysread(len = 1)
+    @sock.rsock.sysread(len)
+  end
+
+  def put(msg, opts={})
+    @sock.lsock.write(msg)
+  end
+
+  #
+  # Wait for a line of input to be read from a socket.
+  #
+  def gets
+    # Initialize the line buffer
+    line = ''
+
+    # Read data one byte at a time until we see a LF
+    while (true)
+      break if line.include?("\n")
+
+      # Read another character of input
+      char = @sock.rsock.getc
+
+      # Append this character to the string
+      line << char
+    end
+
+    return line
+  end
+
+  #
+  # Returns whether or not EOF has been reached on stdin.
+  #
+  def eof?
+    @sock.lsock.closed?
+  end
+
+  #
+  # Returns the file descriptor associated with a socket.
+  #
+  def fd
+    return @sock.rsock
+  end
+end
+
+end
+end
+end

data/lib/rex/ui/text/input/readline.rb

@@ -0,0 +1,129 @@
+# -*- coding: binary -*-
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+begin
+
+  ###
+  #
+  # This class implements standard input using readline against
+  # standard input.  It supports tab completion.
+  #
+  ###
+  class Input::Readline < Rex::Ui::Text::Input
+
+    #
+    # Initializes the readline-aware Input instance for text.
+    #
+    def initialize(tab_complete_proc = nil)
+      if(not Object.const_defined?('Readline'))
+        begin
+          require 'readline'
+        rescue ::LoadError
+          require 'readline_compatible'
+        end
+      end
+
+      self.extend(::Readline)
+
+      if (tab_complete_proc)
+        ::Readline.basic_word_break_characters = "\x00"
+        ::Readline.completion_proc = tab_complete_proc
+        @rl_saved_proc = tab_complete_proc
+      end
+    end
+
+    #
+    # Reattach the original completion proc
+    #
+    def reset_tab_completion(tab_complete_proc = nil)
+      ::Readline.basic_word_break_characters = "\x00"
+      ::Readline.completion_proc = tab_complete_proc || @rl_saved_proc
+    end
+
+    #
+    # Whether or not the input medium supports readline.
+    #
+    def supports_readline
+      true
+    end
+
+    #
+    # Calls sysread on the standard input handle.
+    #
+    def sysread(len = 1)
+      begin
+        self.fd.sysread(len)
+      rescue ::Errno::EINTR
+        retry
+      end
+    end
+
+    #
+    # Read a line from stdin
+    #
+    def gets()
+      begin
+        self.fd.gets()
+      rescue ::Errno::EINTR
+        retry
+      end
+    end
+
+    #
+    # Stick readline into a low-priority thread so that the scheduler doesn't slow
+    # down other background threads. This is important when there are many active
+    # background jobs, such as when the user is running Karmetasploit
+    #
+    def pgets()
+
+      line = nil
+      orig = Thread.current.priority
+
+      begin
+        Thread.current.priority = -20
+
+        output.prompting
+        line = ::Readline.readline(prompt, true)
+        ::Readline::HISTORY.pop if (line and line.empty?)
+      ensure
+        Thread.current.priority = orig || 0
+      end
+
+      line
+    end
+
+    #
+    # Returns the output pipe handle
+    #
+    def fd
+      $stdin
+    end
+
+    #
+    # Indicates that this input medium as a shell builtin, no need
+    # to extend.
+    #
+    def intrinsic_shell?
+      true
+    end
+
+    #
+    # The prompt that is to be displayed.
+    #
+    attr_accessor :prompt
+    #
+    # The output handle to use when displaying the prompt.
+    #
+    attr_accessor :output
+
+  end
+rescue LoadError
+end
+
+end
+end
+end

data/lib/rex/ui/text/input/socket.rb

@@ -0,0 +1,96 @@
+# -*- coding: binary -*-
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# This class implements input against a socket.
+#
+###
+class Input::Socket < Rex::Ui::Text::Input
+
+  def initialize(sock)
+    @sock = sock
+  end
+
+  #
+  # Sockets do not currently support readline.
+  #
+  def supports_readline
+    false
+  end
+
+  #
+  # Reads input from the raw socket.
+  #
+  def sysread(len = 1)
+    @sock.sysread(len)
+  end
+
+  #
+  # Wait for a line of input to be read from a socket.
+  #
+  def gets
+
+    # Initialize the line buffer
+    line = ''
+
+    # Read data one byte at a time until we see a LF
+    while (true)
+
+      break if line.include?("\n")
+
+      # Read another character of input
+      char = @sock.getc
+      if char.nil?
+        @sock.close
+        return
+      end
+
+      # Telnet sends 0x04 as EOF
+      if (char == 4)
+        @sock.write("[*] Caught ^D, closing the socket...\n")
+        @sock.close
+        return
+      end
+
+      # Append this character to the string
+      line << char
+
+      # Handle telnet sequences
+      case line
+        when /\xff\xf4\xff\xfd\x06/n
+          @sock.write("[*] Caught ^C, closing the socket...\n")
+          @sock.close
+          return
+
+        when /\xff\xed\xff\xfd\x06/n
+          @sock.write("[*] Caught ^Z\n")
+          return
+      end
+    end
+
+    return line
+  end
+
+  #
+  # Returns whether or not EOF has been reached on stdin.
+  #
+  def eof?
+    @sock.closed?
+  end
+
+  #
+  # Returns the file descriptor associated with a socket.
+  #
+  def fd
+    return @sock
+  end
+end
+
+end
+end
+end

data/lib/rex/ui/text/input/stdio.rb

@@ -0,0 +1,46 @@
+# -*- coding: binary -*-
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# This class implements input against standard in.
+#
+###
+class Input::Stdio < Rex::Ui::Text::Input
+
+  #
+  # Reads text from standard input.
+  #
+  def sysread(len = 1)
+    $stdin.sysread(len)
+  end
+
+  #
+  # Wait for a line of input to be read from standard input.
+  #
+  def gets
+    return $stdin.gets
+  end
+
+  #
+  # Returns whether or not EOF has been reached on stdin.
+  #
+  def eof?
+    $stdin.closed?
+  end
+
+  #
+  # Returns the file descriptor associated with standard input.
+  #
+  def fd
+    return $stdin
+  end
+end
+
+end
+end
+end