scriptty 0.5.0-java

data/examples/telnet-nego.rb

@@ -0,0 +1,55 @@
+# Telnet negotiation example
+#
+# NOTE: This would cause an infinite loop if two ends of the connection ran
+# this algorithm, but it appears to be safe on the client-side only with a
+# smarter server.
+
+# Options we WILL (in response to DO)
+supported_will_options = [
+  "\000",     # Binary Transmission
+  "\003",     # Suppress Go Ahead
+]
+
+# Options we DO (in response to WILL)
+supported_do_options = [
+  "\000",     # Binary Transmission
+  "\001",     # Echo
+  "\003",     # Suppress Go Ahead
+]
+
+# Initial send
+supported_do_options.each do |opt|
+  send "\377\375#{opt}"   # IAC DO <option>
+end
+supported_will_options.each do |opt|
+  send "\377\373#{opt}"   # IAC WILL <option>
+end
+
+done_telnet_nego = false
+until done_telnet_nego
+  expect {
+    on(/\377([\373\374\375\376])(.)/n) { |m|   # IAC WILL/WONT/DO/DONT <option>
+      cmd = {"\373" => :will, "\374" => :wont, "\375" => :do, "\376" => :dont}[m[1]]
+      opt = m[2]
+      puts "IAC #{cmd} #{opt.inspect}"
+      if cmd == :do
+        if supported_will_options.include?(opt)
+          send "\377\373#{opt}"    # IAC WILL <option>
+        else
+          send "\377\374#{opt}"    # IAC WONT <option>
+        end
+      elsif cmd == :will
+        if supported_do_options.include?(opt)
+          send "\377\375#{opt}"    # IAC DO <option>
+        else
+          send "\377\376#{opt}"    # IAC DONT <option>
+        end
+      elsif cmd == :dont
+        send "\377\374#{opt}"    # IAC WONT <option>
+      elsif cmd == :wont
+        send "\377\376#{opt}"    # IAC DONT <option>
+      end
+    }
+    on(/[^\377]/n) { puts "DONE"; done_telnet_nego = true }    # We're done TELNET negotiation when we receive something that's not IAC
+  }
+end

data/lib/scriptty/apps/capture_app/console.rb

@@ -0,0 +1,104 @@
+require 'scriptty/apps/capture_app'
+
+module ScripTTY
+  module Apps
+    class CaptureApp  # reopen
+      class Console
+        IAC_WILL_ECHO = "\377\373\001"
+        IAC_WONT_ECHO = "\377\374\001"
+        IAC_DO_ECHO = "\377\375\001"
+        IAC_DONT_ECHO = "\377\376\001"
+
+        IAC_WILL_SUPPRESS_GA = "\377\373\003"
+        IAC_WONT_SUPPRESS_GA = "\377\374\003"
+        IAC_DO_SUPPRESS_GA = "\377\375\003"
+        IAC_DONT_SUPPRESS_GA = "\377\376\003"
+
+        def initialize(conn, app)
+          @conn = conn
+          @app = app
+          conn.on_receive_bytes { |bytes| handle_receive_bytes(bytes) }
+          conn.on_close { |bytes| handle_close }
+          conn.write(IAC_WILL_ECHO + IAC_DONT_ECHO)   # turn echoing off
+          conn.write(IAC_WILL_SUPPRESS_GA + IAC_DO_SUPPRESS_GA)   # turn line-buffering off (RFC 858)
+          conn.write("\ec") # reset terminal (clear screen; reset attributes)
+          @refresh_in_progress = false
+          @need_another_refresh = false
+          @prompt_input = ""
+        end
+
+        def refresh!
+          if @refresh_in_progress
+            @need_another_refresh = true
+            return
+          end
+          screen_lines = []
+          screen_lines << "# #{@prompt_input}"  # prompt
+          if @app.term
+            term_width = @app.term.width
+            screen_lines << "Cursor position: #{@app.term.cursor_pos.inspect}"
+            screen_lines << "+" + "-"*term_width + "+"
+            @app.term.text.each do |line|
+              screen_lines << "|#{line}|"
+            end
+            screen_lines << "+" + "-"*term_width + "+"
+          else
+            term_width = 80
+            screen_lines << "[ No terminal ]"
+          end
+          if @app.respond_to?(:log_messages)
+            screen_lines << ""
+            @app.log_messages.each do |line|
+              if line.length > term_width
+                line = line[0,term_width-1]
+                line += ">"
+              end
+              screen_lines << ":#{line}"
+            end
+          end
+          output = []
+          output << "\e[H"
+          output << screen_lines.map{|line| line + "\e[K" + "\r\n"}.join   # erase to end of line after each line
+          output << "\e[;#{3+@prompt_input.length}H" # return to prompt
+          @refresh_in_progress = true
+          @conn.write(output.join) {
+            @refresh_in_progress = false
+            if @need_another_refresh
+              @need_another_refresh = false
+              refresh!
+            end
+          }
+          nil
+        end
+
+        private
+
+          def handle_receive_bytes(bytes)
+            bytes.split("").each do |byte|
+              if byte =~ /\A[\x20-\x7e]\Z/m # printable
+                @prompt_input << byte
+              elsif byte == "\b" or byte == "\x7f"  # backspace or DEL
+                @prompt_input = @prompt_input[0..-2] || ""
+              elsif byte == "\r"
+                handle_command_entered(@prompt_input)
+                @prompt_input = ""
+              elsif byte == "\n"
+                # ignore
+              else
+                @conn.write("\077") # beep
+              end
+            end
+            refresh!
+          end
+
+          def handle_command_entered(cmd)
+            @app.handle_console_command_entered(cmd) if @app.respond_to?(:handle_console_command_entered)
+          end
+
+          def handle_close
+            @app.detach_console(self)
+          end
+      end
+    end
+  end
+end

data/lib/scriptty/apps/capture_app/password_prompt.rb

@@ -0,0 +1,65 @@
+require 'scriptty/apps/capture_app'
+
+module ScripTTY
+  module Apps
+    class CaptureApp  # reopen
+      class PasswordPrompt
+        IAC_WILL_ECHO = "\377\373\001"
+        IAC_WONT_ECHO = "\377\374\001"
+        IAC_DO_ECHO = "\377\375\001"
+        IAC_DONT_ECHO = "\377\376\001"
+
+        def initialize(conn, prompt="Password: ")
+          @conn = conn
+          @conn.write(IAC_WILL_ECHO + IAC_DONT_ECHO) if prompt    # echo off
+          @conn.write(prompt) if prompt
+          @conn.on_receive_bytes { |bytes|
+            bytes.split("").each { |byte|
+              handle_received_byte(byte) unless @done   # XXX - This doesn't work well with pipelining; we throw away bytes after the prompt is finished.
+            }
+          }
+          @password_buffer = ""
+          @done = false
+        end
+
+        def authenticate(&block)
+          raise ArgumentError.new("no block given") unless block
+          @authenticate_proc = block
+          nil
+        end
+
+        def on_fail(&block)
+          raise ArgumentError.new("no block given") unless block
+          @fail_proc = block
+          nil
+        end
+
+        def on_success(&block)
+          raise ArgumentError.new("no block given") unless block
+          @success_proc = block
+          nil
+        end
+
+        private
+          def handle_received_byte(byte)
+            @password_buffer << byte
+            if byte == "\r" or byte == "\n"
+              @done = true
+              @conn.write(IAC_DO_ECHO + "\r\n") if @password_buffer =~ /#{Regexp.escape(IAC_DO_ECHO)}|#{Regexp.escape(IAC_WILL_ECHO)}/ # echo on, send newline
+              password = @password_buffer
+              password.gsub!(/\377[\373-\376]./m, "")   # Strip IAC DO/DONT/WILL/WONT option from password
+              password.chomp!   # strip trailing newline
+              if @authenticate_proc.call(password)
+                # success
+                @success_proc.call if @success_proc
+              else
+                # Failure
+                @fail_proc.call if @fail_proc
+              end
+            end
+            nil
+          end
+      end
+    end
+  end
+end

data/lib/scriptty/apps/capture_app.rb

@@ -0,0 +1,213 @@
+# = Capture app
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'optparse'
+require 'scriptty/net/event_loop'
+require 'scriptty/util/transcript/writer'
+require 'scriptty/term'
+require 'logger'
+require 'stringio'
+
+module ScripTTY
+  module Apps
+    class CaptureApp
+      attr_reader :term
+
+      def initialize(argv)
+        @client_connection = nil
+        @server_connection = nil
+        @output_file = nil
+        @options = parse_options(argv)
+        @console_password = ""   # TODO SECURITY FIXME
+        @attached_consoles = []
+        @net = ScripTTY::Net::EventLoop.new
+        @log_stringio = StringIO.new
+        @log = Logger.new(@log_stringio)
+      end
+
+      def detach_console(console)
+        @attached_consoles.delete(console)
+      end
+
+      def log_messages
+        ([""]*10 + @log_stringio.string.split("\n"))[-10..-1].map{|line| line.sub(/^.*?\]/, '')}
+      end
+
+      def main
+        @output_file = Util::Transcript::Writer.new(File.open(@options[:output], @options[:append] ? "a" : "w")) if @options[:output]
+        @output_file.info("--- Capture started #{Time.now} ---") if @output_file
+        @net.on_accept(@options[:console_addrs] || [], :multiple => true) do |conn|
+          p = PasswordPrompt.new(conn, "Console password: ")
+          p.authenticate { |password| password == @console_password }
+          p.on_fail { conn.write("Authentiation failed.\r\n") { conn.close } }
+          p.on_success {
+            @attached_consoles << Console.new(conn, self)
+            @attached_consoles.each { |c| c.refresh! }
+          }
+        end
+        @net.on_accept(@options[:listen_addrs], :multiple => true) do |conn|
+          @output_file.client_open(*conn.remote_address) if @output_file
+          @client_connection = conn
+          @client_connection.on_receive_bytes { |bytes| handle_client_receive_bytes(bytes) }
+          @client_connection.on_close { handle_client_close ; @client_connection = nil }
+          handle_client_connected
+        end
+        @net.main
+      ensure
+        if @output_file
+          @output_file.close
+          @output_file = nil
+        end
+      end
+
+      # Instruct the event loop to exit.
+      #
+      # Can be invoked by another thread.
+      def exit
+        @net.exit
+      end
+
+      def handle_console_command_entered(cmd)
+        case cmd
+        when /^'(.*)$/i    # comment
+          comment = $1.strip
+          @output_file.info("Comment: #{comment}") if @output_file
+          log.info("Comment: #{comment}")
+        else
+          log.warn("Unknown console command: #{cmd}")
+        end
+        @last_command = cmd
+      end
+
+      private
+
+        attr_reader :log
+
+        def handle_client_connected
+          connect_to_server
+        end
+
+        def handle_server_connected
+          @term = ScripTTY::Term.new(@options[:term])
+          @term.on_unknown_sequence do |sequence|
+            @output_file.info("Unknown escape sequence", sequence) if @output_file
+            log.debug("Unknown escape sequence: #{sequence.inspect}")
+          end
+        end
+
+        def handle_server_connect_error(e)
+          @output_file.info("Server connection error #{e}") if @output_file   # TODO - add a separate transcript record
+          @client_connection.close if @client_connection
+        end
+
+        def handle_client_receive_bytes(bytes)
+          return unless @server_connection    # Ignore bytes received from client until server is connected.
+          @output_file.from_client(bytes) if @output_file
+          @server_connection.write(bytes)
+        end
+
+        def handle_server_receive_bytes(bytes)
+          return unless @client_connection    # Ignore bytes received from client until server is connected.
+          @output_file.from_server(bytes) if @output_file
+          @client_connection.write(bytes)
+          @term.feed_bytes(bytes)
+          @attached_consoles.each { |c| c.refresh! }
+        end
+
+        def handle_client_close
+          @output_file.client_close("Client connection closed") if @output_file
+          @server_connection.close if @server_connection
+          @attached_consoles.each { |c| c.refresh! }
+        end
+
+        def handle_server_close
+          @output_file.server_close("Server connection closed") if @output_file
+          @client_connection.close if @client_connection
+          @term = nil
+        end
+
+        def connect_to_server
+          @net.connect(@options[:connect_addr]) do |server_conn|
+            server_conn.on_connect_error { |e| handle_server_connect_error(e) }
+            server_conn.on_connect {
+              @output_file.server_open(*server_conn.remote_address) if @output_file
+              @server_connection = server_conn
+              handle_server_connected
+            }
+            server_conn.on_receive_bytes { |bytes| handle_server_receive_bytes(bytes) }
+            server_conn.on_close { handle_server_close; @server_connection = nil }
+          end
+        end
+
+        def parse_options(argv)
+          args = argv.dup
+          options = {:term => 'xterm'}
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: #{opts.program_name} [options]"
+            opts.separator "Stream capture application"
+            opts.on("-l", "--listen [HOST]:PORT", "Listen on the specified HOST:PORT") do |optarg|
+              addr = parse_hostport(optarg, :allow_empty_host => true, :allow_zero_port => true)
+              options[:listen_addrs] ||= []
+              options[:listen_addrs] << addr
+            end
+            opts.on("-c", "--connect HOST:PORT", "Connect to the specified HOST:PORT") do |optarg|
+              addr = parse_hostport(optarg)
+              options[:connect_addr] = addr
+            end
+            opts.on("-C", "--console [HOST]:PORT", "Debug console on the specified HOST:PORT") do |optarg|
+              addr = parse_hostport(optarg, :allow_empty_host => true, :allow_zero_port => true)
+              options[:console_addrs] ||= []
+              options[:console_addrs] << addr
+            end
+            opts.on("-t", "--term NAME", "Terminal to emulate") do |optarg|
+              raise ArgumentError.new("Unsupported terminal #{optarg.inspect}") unless ScripTTY::Term::TERMINAL_TYPES.include?(optarg)
+              options[:term] = optarg
+            end
+            opts.on("-o", "--output FILE", "Write transcript to FILE") do |optarg|
+              options[:output] = optarg
+            end
+            opts.on("-a", "--[no-]append", "Append to output file instead of overwriting it") do |optarg|
+              options[:append] = optarg
+            end
+          end
+          opts.parse!(args)
+          raise ArgumentError.new("No connect-to address specified") unless options[:connect_addr]
+          options
+        end
+
+        # Parse [HOST:]PORT into separate host and port.  Host is optional, and
+        # might be surrounded by square brackets.
+        def parse_hostport(s, opts={})
+          unless s =~ /\A(\[[^\[\]]*\]|[^\[\]]*):(\d+)\Z/
+            raise ArgumentError.new("Unable to parse host:port")
+          end
+          host, port = [$1, $2]
+          host.gsub!(/\A\[(.*?)\]\Z/, '\1')
+          port = port.to_i
+          raise ArgumentError.new("Invalid port") if port < 0 or port > 0xffff or (port == 0 and !opts[:allow_zero_port])
+          unless opts[:allow_empty_host]
+            raise ArgumentError.new("Host cannot be empty") if host.empty?
+          end
+          [host, port]
+        end
+    end
+  end
+end
+
+require 'scriptty/apps/capture_app/password_prompt'
+require 'scriptty/apps/capture_app/console'

data/lib/scriptty/apps/dump_screens_app.rb

@@ -0,0 +1,166 @@
+# = Generates a ScripTTY screen dumps from a transcript
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'optparse'
+require 'scriptty/term'
+require 'scriptty/util/transcript/reader'
+require 'scriptty/screen_pattern/generator'
+require 'set'
+require 'digest/sha2'
+
+module ScripTTY
+  module Apps
+    class DumpScreensApp
+      def initialize(argv)
+        @options = parse_options(argv)
+      end
+
+      def main
+        @term = ScripTTY::Term.new(@options[:term])
+        @term.on_unknown_sequence :ignore # DEBUG FIXME
+        #@term.on_unknown_sequence do |seq|
+        #  puts "Unknown escape sequence: #{seq.inspect}"  # DEBUG FIXME
+        #end
+        @screen_pattern_digests = Set.new
+        @prev_screen = nil
+        @next_num = 1
+        @output_file = File.open(@options[:output], "w") if @options[:output]
+        if @options[:output_dir]
+          @output_dir = @options[:output_dir]
+          @next_num = Dir.entries(@output_dir).map{|e| e =~ /\Ap(\d+)\.txt\Z/ && $1.to_i }.select{|e| e}.sort.last || 1
+        end
+        begin
+          @options[:input_files].each do |input_filename|
+            File.open(input_filename, "r") do |input_file|
+              reader = ScripTTY::Util::Transcript::Reader.new(input_file)
+              while (entry = reader.next_entry)
+                timestamp, type, args = entry
+                case type
+                when :from_server
+                  handle_bytes_from_server(args[0])
+                when :server_parsed
+                  handle_bytes_from_server(args[1])
+                when :from_client
+                  handle_bytes_from_client(args[0], timestamp)
+                end
+              end
+            end
+          end
+        ensure
+          @output_file.close if @output_file
+          @output_file = nil
+        end
+      end
+
+      private
+
+        def handle_bytes_from_server(bytes)
+          @term.feed_bytes(bytes)
+        end
+
+        # When we receive bytes from the client, we output a new screen if the
+        # screen hasn't already been generated, and if the screen isn't
+        # different only in the way that it would be if the user type a
+        # single character into a prompt. (See the too_similar method.)
+        def handle_bytes_from_client(bytes, timestamp=nil)
+          ts = too_similar
+          @prev_screen = { :cursor_pos => @term.cursor_pos, :text => @term.text }
+          return if ts
+          pattern = generate_screen_pattern
+          hexdigest = Digest::SHA256.hexdigest(pattern)
+          return if @screen_pattern_digests.include?(hexdigest)
+          @screen_pattern_digests << hexdigest
+          pattern_name = sprintf("p%d", @next_num)
+          @next_num += 1
+          if @output_file
+            @output_file.puts(generate_screen_pattern(pattern_name))
+            @output_file.puts("")
+          end
+          if @output_dir
+            File.open(File.join(@output_dir, pattern_name + ".txt"), "w") do |outfile|
+              outfile.puts(generate_screen_pattern(pattern_name))
+            end
+          end
+        end
+
+        # Return the screen pattern generated from the current state of the
+        # terminal.
+        def generate_screen_pattern(name=nil)
+          matches = []
+          @term.text.each_with_index do |line, row|
+            matches << [[row, 0], line]
+          end
+          ScreenPattern::Generator.generate(name || "no_name", :force_cursor => / /,
+            :size => [@term.height, @term.width],
+            :cursor_pos => @term.cursor_pos,
+            :ignore => @options[:ignore],
+            :matches => matches)
+        end
+
+        def too_similar
+          return false unless @prev_screen
+          prev_row, prev_col = @prev_screen[:cursor_pos]
+          prev_text = @prev_screen[:text].map{|line| line.dup}
+          current_row, current_col = @term.cursor_pos
+          current_text = @term.text
+          return false if current_row != prev_row or current_col != prev_col+1
+          current_text[prev_row][prev_col..prev_col] = " "
+          return (current_text == prev_text)
+        end
+
+        def parse_options(argv)
+          args = argv.dup
+          options = {:term => 'xterm', :input_files => [], :rate => 2}
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: #{opts.program_name} [options] FILE..."
+            opts.separator "Dump screens to a file/directory based on one or more transcript files"
+            opts.separator ""
+            opts.on("-t", "--term NAME", "Terminal to emulate") do |optarg|
+              raise ArgumentError.new("Unsupported terminal #{optarg.inspect}") unless ScripTTY::Term::TERMINAL_TYPES.include?(optarg)
+              options[:term] = optarg
+            end
+            opts.on("-O", "--output-dir DIR", "Write output to DIR") do |optarg|
+              options[:output_dir] = optarg
+            end
+            opts.on("-o", "--output FILE", "Write output to FILE") do |optarg|
+              options[:output] = optarg
+            end
+            opts.on("-I", "--ignore ROW,COL,LENGTH", "Always ignore the specified region") do |optarg|
+              options[:ignore] ||= []
+              row, col, length = optarg.split(",").map{|n|
+                raise ArgumentError.new("Illegal --ignore argument: #{optarg}") unless n =~ /\A\d+\Z/ and n.to_i >= 0
+                n.to_i
+              }
+              options[:ignore] << [row, col..col+length]
+            end
+          end
+          opts.parse!(args)
+          if args.length < 1
+            $stderr.puts "error: No input file(s) specified."
+            exit 1
+          end
+          options[:input_files] = args
+          if (!options[:output] and !options[:output_dir]) or !options[:term]
+            $stderr.puts "error: --term and --output[-dir] are mandatory"
+            exit 1
+          end
+          options
+        end
+    end
+  end
+end