gdb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f32294dfb015b22fbc1fbdfa8a8babb257cd336
-  data.tar.gz: d8ea3ac19cad4184677fbb55831443b51acccac8
+  metadata.gz: f9b16e3cec333997d16a2400dacc343110aec6a4
+  data.tar.gz: dc486d72d111cfaeac7928402ee1e39a57552bd1
 SHA512:
-  metadata.gz: 582e43a9d160827b8787124ffb48d2e7658ce2bd1f152dfd07227a4cc84eda9ef6cbad2c367ce90669e4b886ab71863b771c902035ceb912c525a3f0f1e9452b
-  data.tar.gz: '034946046228f22c23838f7ef4b5b69a90dc198cc946335eaf29e1e7ff380d2a0567167947c7dee0cc07e2b9517b687dcb379de309685b2981a737165cb6c0f8'
+  metadata.gz: 3e8c780fe48de70df13df78fb9f987afab66d268f6f4b27b85665279f4fed43abdc512806a7b7467e77006f5e8c95f2069532fa717134503568c3f65842b9dbb
+  data.tar.gz: 92dda6f5248627108645bc55c9e3d5a3f7d476bfa2cc3295e4edc7a53e2815ca9f488712109422608fca88fdb29c9f0edec7ad8f8b88647fbf85b5007e277770

data/README.md

@@ -1,2 +1,161 @@
-# gdb-ruby
-Use gdb in ruby!
+[![Build Status](https://travis-ci.org/david942j/gdb-ruby.svg?branch=master)](https://travis-ci.org/david942j/gdb-ruby)
+[![Code Climate](https://codeclimate.com/github/david942j/gdb-ruby/badges/gpa.svg)](https://codeclimate.com/github/david942j/gdb-ruby)
+[![Issue Count](https://codeclimate.com/github/david942j/gdb-ruby/badges/issue_count.svg)](https://codeclimate.com/github/david942j/gdb-ruby)
+[![Test Coverage](https://codeclimate.com/github/david942j/gdb-ruby/badges/coverage.svg)](https://codeclimate.com/github/david942j/gdb-ruby/coverage)
+[![Inline docs](https://inch-ci.org/github/david942j/gdb-ruby.svg?branch=master)](https://inch-ci.org/github/david942j/gdb-ruby)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](http://choosealicense.com/licenses/mit/)
+
+# GDB-Ruby
+
+It's time for Ruby lovers to use Ruby in gdb, and... gdb in Ruby!
+
+# Use Ruby in gdb
+
+We provide a binary `gdb-ruby` with usage exactly same as normal gdb,
+while has two extra commands: `ruby` and `pry`!
+
+See examples below:
+
+```yaml
+$ gdb-ruby -q bash
+Reading symbols from bash...(no debugging symbols found)...done.
+(gdb) help ruby
+Evaluate a Ruby command.
+There's an instance 'gdb' for you. See examples.
+
+Syntax: ruby <ruby code>
+
+Examples:
+    ruby p 'abcd'
+    # "abcd"
+
+Use gdb:
+    ruby puts gdb.break('main')
+    # Breakpoint 1 at 0x41eed0
+
+Method defined will remain in context:
+    ruby def a(b); b * b; end
+    ruby p a(9)
+    # 81
+(gdb) help pry
+Enter Ruby interactive shell.
+Everything works like a charm!
+
+Syntax: pry
+
+Example:
+    pry
+    # [1] pry(#<GDB::EvalContext>)>
+```
+
+## Integrate with other gdb extensions
+
+Completely NO effort if you want to use **gdb-ruby** with other gdb extension.
+
+For example, I usually use [gef](https://github.com/hugsy/gef) for my gdb.
+And everything works as usual when integrated with **gdb-ruby**:
+
+Launching with `$ gdb-ruby -q bash`
+
+![ruby-in-gef](https://i.imgur.com/WMxofSs.png)
+
+# Use gdb in Ruby
+
+Communicate with gdb in your Ruby script.
+
+## Useful methods
+
+Basical usage is use `execute` to do anything you want to execute inside gdb,
+while **gdb-ruby** provides some useful methods listed as following:
+
+* `break`: Set break points. Alias: `b`
+* `run`: Run. Alias: `r`
+* `register`: Get value by register's name. Alias: `reg`
+* `text_base`: Get current running program's text base, useful for a PIE binary.
+* `pid`: Get the process id of running process.
+* `read_memory`: Read process's memory, with friendly type casting. Alias: `readm`
+* `write_memory`: Write process's memory, useful for dynamic analysis. Alias: `writem`
+* `interact`: Back to normal gdb interactive mode.
+
+All of these methods are fully documented at [online doc](http://www.rubydoc.info/github/david942j/gdb-ruby/master/GDB/GDB), go for it!
+
+## Examples
+
+Play with argv using **gdb-ruby**.
+
+This script does:
+1. Set break point at `main`.
+2. Get argv using `register` and `read_memory`.
+3. Change argv using `write_memory`.
+
+```ruby
+require 'gdb'
+
+# launch a gdb instance
+gdb = GDB::GDB.new('bash')
+
+# 1. set breakpoint
+gdb.break('main')
+#=> "Breakpoint 1 at 0x41eed0"
+gdb.run('-c "echo cat"')
+
+# 2. get argv pointers
+rdi = gdb.reg(:rdi)
+#=> 3
+rsi = gdb.reg(:rsi)
+argv = gdb.readm(rsi, rdi, as: :uint64)
+argv.map{ |c|'0x%x' % c }
+#=> ['0x7fffffffe61b', '0x7fffffffe625', '0x7fffffffe628']
+
+# 3. overwrite argv[2]'s 'cat' to 'FAT'
+gdb.writem(argv[2] + 5, 'FAT') # echo FAT
+
+puts gdb.execute('continue')
+# Continuing.
+# FAT
+# [Inferior 1 (process 32217) exited normally]
+```
+
+Set a break point, run it, and back to gdb interactive mode.
+
+```ruby
+require 'gdb'
+
+# launch a gdb instance
+gdb = GDB::GDB.new('bash')
+# set breakpoints
+gdb.break('main')
+gdb.run
+# shows process do running
+gdb.execute('info reg rip')
+#=> "rip            0x41eed0\t0x41eed0 <main>"
+
+# interaction like normal gdb!
+gdb.interact
+```
+
+# Installation
+
+Available on RubyGems.org!
+```
+$ gem install gdb
+```
+
+# Development
+
+```
+git clone https://github.com/david942j/gdb-ruby
+cd gdb-ruby
+bundle
+bundle exec rake
+```
+
+# Bugs & feedbacks
+
+Feel free to file an issue if you find any bugs.
+Any feature requests and suggestions are welcome! :grimacing:
+
+# Growing up
+
+**gdb-ruby** is under developing, give it a star and [watching](https://github.com/david942j/gdb-ruby/subscription)
+for latest updates!

data/bin/gdb-ruby

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'gdb'
+require 'shellwords'
+
+GDB::GDB.new(Shellwords.join(ARGV)).interact

data/lib/gdb.rb

@@ -6,4 +6,5 @@
 module GDB
 end
 
+require 'gdb/gdb'
 require 'gdb/version'

data/lib/gdb/eval_context.rb

@@ -0,0 +1,25 @@
+require 'pry'
+
+module GDB
+  # For evaluation ruby code in gdb.
+  class EvalContext
+    attr_reader :gdb # @return [GDB::GDB]
+
+    def initialize(gdb)
+      @gdb = gdb
+    end
+
+    private
+
+    # Invoke pry, wrapper with some settings.
+    #
+    # @return [void]
+    def invoke_pry
+      org = Pry.config.history.file
+      # this has no effect if gdb is launched by pry
+      Pry.config.history.file = '~/.gdb-pry_history'
+      $stdin.cooked { pry }
+      Pry.config.history.file = org
+    end
+  end
+end

data/lib/gdb/gdb.rb

@@ -0,0 +1,278 @@
+require 'io/console'
+require 'pty'
+require 'readline'
+
+require 'gdb/eval_context'
+require 'gdb/gdb_error'
+require 'gdb/tube/tube'
+require 'gdb/type_io'
+
+module GDB
+  # For launching a gdb process.
+  class GDB
+    # Absolute path to python scripts.
+    SCRIPTS_PATH = File.join(__dir__, 'scripts').freeze
+
+    def initialize(arguments, gdb: 'gdb')
+      arguments = "--command=#{File.join(SCRIPTS_PATH, 'gdbinit.py')}" + ' ' + arguments # XXX
+      @tube = spawn(gdb + ' ' + arguments)
+      @prompt = '(gdb-ruby) '
+      @tube.unget(@tube.readuntil(@prompt))
+    end
+
+    # Execute a command in gdb.
+    #
+    # @param [String] cmd
+    #   Command to be executed.
+    #
+    # @return [String]
+    #   The execution result returned by gdb.
+    #
+    # @example
+    #   gdb = GDB::GDB.new('bash')
+    #   gdb.execute('b main')
+    #   #=> "Breakpoint 1 at 0x41eed0"
+    #   gdb.execute('run')
+    #   gdb.execute('print $rsi')
+    #   #=> "$1 = 0x7fffffffdef8"
+    def execute(cmd)
+      @tube.puts(cmd)
+      @tube.readuntil(@prompt).strip
+    end
+    alias exec execute
+
+    # Set break point.
+    #
+    # This method some magic, see parameters or examples.
+    #
+    # @param [Integer, String] point
+    #   If +Integer+ is given, will be translated as set break point
+    #   at address +point+, i.e. equivalent to +break *<integer>+.
+    #   If +String+ is given, equivalent to invoke +execute("break <point>")+.
+    #
+    # @return [String]
+    #   Returns what gdb displayed after set a break point.
+    #
+    # @example
+    #   gdb = GDB::GDB.new('bash')
+    #   gdb.break('main')
+    #   #=> "Breakpoint 1 at 0x41eed0"
+    #   gdb.break(0x41eed0)
+    #   #=> "Note: breakpoint 1 also set at pc 0x41eed0.\r\nBreakpoint 2 at 0x41eed0"
+    def break(point)
+      case point
+      when Integer then execute("break *#{point}")
+      when String then execute("break #{point}")
+      end
+    end
+    alias b break
+
+    # Run process.
+    #
+    # @param [String] args
+    #   Arguments to pass to run command.
+    #
+    # @return [String]
+    #   Returns what gdb displayed.
+    #
+    # @example
+    #   gdb = GDB::GDB.new('bash')
+    #   puts gdb.run('-c "echo 111"')
+    #   # Starting program: /bin/bash -c "echo 111"
+    #   # 111
+    #   # [Inferior 1 (process 3229) exited normally]
+    #   #=> nil
+    #
+    # @note
+    #   If breakpoints are not set properly and cause gdb hangs,
+    #   this method will hang, too.
+    def run(args = '')
+      execute('run ' + args)
+    end
+    alias r run
+
+    # Get current value of register
+    #
+    # @param [String, Symbol] reg_name
+    #
+    # @return [Integer]
+    #   Value of desired register.
+    #
+    # @todo
+    #   Handle when +reg_name+ is not a general-purpose register.
+    def register(reg_name)
+      check_alive!
+      Integer(python_p("gdb.parse_and_eval('$#{reg_name}')").split.first)
+    end
+    alias reg register
+
+    # Get the process's text base.
+    #
+    # @return [Integer]
+    #   The base address.
+    #
+    # @note
+    #   This will also set a variable +$text+ in gdb.
+    def text_base
+      check_alive!
+      base = Integer(execute('info proc stat').scan(/Start of text: (.*)/).flatten.first)
+      execute("set $text = #{base}")
+      base
+    end
+    alias code_base text_base
+
+    # Is process running?
+    #
+    # Actually judged by if {#pid} returns zero.
+    #
+    # @return [Boolean]
+    #   True for process is running.
+    def alive?
+      !pid.zero?
+    end
+    alias running? alive?
+
+    # Get the process's pid.
+    #
+    # This method implemented by invoking +python print(gdb.selected_inferior().pid)+.
+    #
+    # @return [Integer]
+    #   The pid of process. If process is not running, zero is returned.
+    def pid
+      @pid = python_p('gdb.selected_inferior().pid').to_i
+    end
+
+    # Read current process's memory.
+    #
+    # See {TypeIO#read} for details.
+    #
+    # @param [Mixed] args
+    #   See {TypeIO#read}.
+    #
+    # @return [Object]
+    #   See {TypeIO#read}.
+    #
+    # @yieldparam [IO] io
+    #   See {TypeIO#read}.
+    #
+    # @yieldreturn [Object]
+    #   See {TypeIO#read}.
+    #
+    # @example
+    #   # example of fetching argv
+    #   gdb = GDB::GDB.new('spec/binaries/amd64.elf')
+    #   gdb.break('main')
+    #   gdb.run('pusheen the cat')
+    #   gdb.read_memory(0x400000, 4)
+    #   #=> "\x7fELF"
+    #   argc = gdb.register(:rdi)
+    #   #=> 4
+    #   args = gdb.read_memory(gdb.register(:rsi), argc, as: :uint64)
+    #   Array.new(3) do |i|
+    #     gdb.read_memory(args[i + 1], 1) do |m|
+    #       str = ''
+    #       str << m.read(1) until str.end_with?("\x00")
+    #       str
+    #     end
+    #   end
+    #   #=> ["pusheen\x00", "the\x00", "cat\x00"]
+    #
+    #   # or, use our build-in types listed in {TypeIO::TYPES}
+    #   gdb.read_memory(args[1], 3, as: :cstring)
+    #   #=> ["pusheen\x00", "the\x00", "cat\x00"]
+    def read_memory(*args, &block)
+      check_alive! # this would set @pid
+      File.open("/proc/#{@pid}/mem", 'rb') do |f|
+        ::GDB::TypeIO.new(f).read(*args, &block)
+      end
+    end
+    alias readm read_memory
+
+    # Write a string to process at specific address.
+    #
+    # @param [Integer] addr
+    #   Target address.
+    # @param [String] str
+    #   String to be written.
+    #
+    # @return [Integer]
+    #   Bytes written.
+    def write_memory(addr, str)
+      check_alive! # this would set @pid
+      File.open("/proc/#{@pid}/mem", 'wb') do |f|
+        ::GDB::TypeIO.new(f).write(addr, str)
+      end
+    end
+    alias writem write_memory
+
+    # To simplify the frequency call of +python print(xxx)+.
+    #
+    # @param [String] cmd
+    #   python command.
+    # @return [String]
+    #   Execution result.
+    def python_p(cmd)
+      execute("python print(#{cmd})")
+    end
+
+    # Enter gdb interactive mode.
+    # Gdb will be closed after interaction.
+    #
+    # @return [void]
+    def interact
+      $stdin.raw { @tube.interact(method(:output_hook)) }
+      close
+    end
+
+    # Terminate the gdb process.
+    #
+    # @return [void]
+    def close
+      return if @tube.closed?
+      @tube.close
+      Process.wait(@gdb_pid)
+      nil
+    end
+    alias quit close
+
+    private
+
+    def check_alive!
+      raise GDBError, 'Process is not running' unless alive?
+    end
+
+    TIOCSWINSZ = 0x5414
+
+    def spawn(cmd)
+      output, input, @gdb_pid = PTY.spawn(cmd)
+      output.ioctl(TIOCSWINSZ, [*IO.console.winsize, 0, 0].pack('S*'))
+      ::GDB::Tube::Tube.new(input, output)
+    end
+
+    COMMAND_PREFIX = 'gdb-ruby> '.freeze
+
+    # @param [String] output
+    #
+    # @return [String]
+    def output_hook(output)
+      return output.gsub(@prompt, '') unless output.start_with?(COMMAND_PREFIX)
+      cmd, args = output.slice(COMMAND_PREFIX.size..-1).split(' ', 2)
+      # only support ruby and pry now.
+      return output unless %w[ruby pry].include?(cmd)
+      args = 'send(:invoke_pry)' if cmd == 'pry'
+      # gdb by default set tty
+      # hack it
+      `stty opost onlcr`
+      begin
+        eval_context.instance_eval(args)
+      rescue StandardError, ScriptError => e
+        $stdout.puts("#{e.class}: #{e}")
+      end
+      nil
+    end
+
+    def eval_context
+      @context ||= ::GDB::EvalContext.new(self)
+    end
+  end
+end

data/lib/gdb/gdb_error.rb

@@ -0,0 +1,5 @@
+module GDB
+  # Raise this error if the request will fail in gdb.
+  class GDBError < StandardError
+  end
+end

data/lib/gdb/scripts/gdbinit.py

@@ -0,0 +1,88 @@
+import gdb
+import signal
+
+class GDBRuby():
+    def __init__(self):
+        # with this life is prettier.
+        gdb.execute("set confirm off")
+        gdb.execute("set verbose off")
+        gdb.execute("set pagination off")
+        gdb.execute("set step-mode on")
+        gdb.execute("set print elements 0")
+        gdb.execute("set print pretty on")
+        self.hook_gdb_prompt()
+
+    '''
+    Hook gdb prompt
+    '''
+    def hook_gdb_prompt(self):
+        # don't hook twice
+        if gdb.prompt_hook == self._prompt_hook: return
+        self._original_hook = gdb.prompt_hook
+        gdb.prompt_hook = self._prompt_hook
+
+    def resume_prompt(self):
+        gdb.prompt_hook = self._original_hook
+
+    def _prompt_hook(self, current_prompt):
+        if self._original_hook == None:
+            org = '(gdb) '
+        else:
+            org = self._original_hook(current_prompt)
+        return '(gdb-ruby) ' + org
+
+__commands__ = []
+def register_command(cls):
+    """Decorator for registering new command to GDB."""
+    global __commands__
+    __commands__.append(cls)
+    return cls
+
+class GDBRubyCommand(gdb.Command):
+    def __init__(self, klass):
+        self.klass = klass
+        self.__doc__ = klass._doc_
+        super(GDBRubyCommand, self).__init__(klass._cmdline_, gdb.COMMAND_USER)
+
+    def invoke(self, args, _from_tty):
+        print("gdb-ruby> " + self.klass._cmdline_ + ' ' + args)
+
+@register_command
+class RubyCommand():
+    _doc_ = """Evaluate a Ruby command.
+There's an instance 'gdb' for you. See examples.
+
+Syntax: ruby <ruby code>
+
+Examples:
+    ruby p 'abcd'
+    # "abcd"
+
+Use gdb:
+    ruby puts gdb.break('main')
+    # Breakpoint 1 at 0x41eed0
+
+Method defined will remain in context:
+    ruby def a(b); b * b; end
+    ruby p a(9)
+    # 81
+"""
+    _cmdline_ = 'ruby'
+
+@register_command
+class PryCommand():
+    _doc_ = """Enter Ruby interactive shell.
+Everything works like a charm!
+
+Syntax: pry
+
+Example:
+    pry
+    # [1] pry(#<GDB::EvalContext>)>
+"""
+    _cmdline_ = 'pry'
+
+
+if not 'gdbruby' in globals():
+    [GDBRubyCommand(c) for c in __commands__]
+    gdbruby = GDBRuby()

data/lib/gdb/tube/buffer.rb

@@ -0,0 +1,74 @@
+module GDB
+  module Tube
+    # IO buffer.
+    class Buffer
+      attr_reader :size # @return [Integer] size
+
+      def initialize
+        @data = []
+        @size = 0
+      end
+
+      # Push string into buffer.
+      #
+      # @param [String] str
+      #   String to push.
+      #
+      # @return [Buffer]
+      #   Returns self so this method is chainable.
+      def <<(str)
+        str = str.to_s.dup
+        return self if str.empty?
+        @data << str
+        @size += str.size
+        self
+      end
+
+      def empty?
+        @size.zero?
+      end
+
+      # Retrieves at most +n+ bytes from buffer.
+      #
+      # @param [Integer?] n
+      #   Maximum number of bytes. +n+ equals +nil+ for unlimited.
+      #
+      # @return [String]
+      #   Retrieved string.
+      def get(n = nil)
+        if n.nil? || n >= @size
+          ret = @data.join
+          @data.clear
+          @size = 0
+        else
+          now = 0
+          idx = @data.find_index do |s|
+            if s.size + now >= n
+              true
+            else
+              now += s.size
+              false
+            end
+          end
+          ret = @data.slice!(0, idx + 1).join
+          back = ret.slice!(n..-1)
+          @data.unshift(back) unless back.empty?
+          @size -= n
+        end
+        ret
+      end
+
+      # Push front.
+      #
+      # @param [String] str
+      #   String to be push.
+      #
+      # @return [void]
+      def unshift(str)
+        return if str.nil? || str.empty?
+        @data.unshift(str)
+        @size += str.size
+      end
+    end
+  end
+end

data/lib/gdb/tube/tube.rb

@@ -0,0 +1,111 @@
+require 'gdb/tube/buffer'
+
+module GDB
+  # IO-related classes.
+  module Tube
+    # For simpler IO manipulation.
+    class Tube
+      # Batch read size.
+      READ_SIZE = 4096
+
+      # @param [IO] io_in
+      # @param [IO] io_out
+      def initialize(io_in, io_out)
+        @in = io_in
+        @out = io_out
+        @buffer = ::GDB::Tube::Buffer.new
+      end
+
+      # Read +n+ bytes.
+      #
+      # @param [Integer] n
+      #   Number of bytes.
+      #
+      # @return [String]
+      #   Returns +n+ bytes from current buffer.
+      def readn(n)
+        partial while @buffer.size < n
+        @buffer.get(n)
+      end
+
+      # Receive from +io+ until string +str+ appears.
+      #
+      # @param [String] str
+      #   String to be looking for.
+      # @param [Boolean] drop
+      #   If need keep +str+ in end of returned string.
+      #
+      # @return [Stirng]
+      #   Data.
+      def readuntil(str, drop: true)
+        cur = readn(str.size)
+        cur << readn(1) until cur.index(str)
+        cur.slice!(-str.size..-1) if drop
+        cur
+      end
+
+      # Put to front of buffer.
+      #
+      # @param [String] str
+      #
+      # @return [nil]
+      def unget(str)
+        @buffer.unshift(str)
+        nil
+      end
+
+      # @param [#to_s] data
+      #   Data to be sent.
+      #
+      # @return [void]
+      def puts(data)
+        @in.puts(data)
+        readuntil(data)
+      end
+
+      # Enter interactive mode.
+      #
+      # @param [Proc] output_hook
+      #   Called before flush the output to +$stdout+.
+      #
+      # @return [void]
+      def interact(output_hook = nil)
+        @out.ungetc(@buffer.get)
+        loop do
+          io, = IO.select([$stdin, @out])
+          @in.write($stdin.readpartial(READ_SIZE)) if io.include?($stdin)
+          next unless io.include?(@out)
+          begin
+            recv = @out.readpartial(READ_SIZE)
+            recv = output_hook.call(recv) if output_hook
+            $stdout.write(recv) if recv
+            @out.ungetc(@buffer.get) unless @buffer.empty?
+          rescue Errno::EIO
+            break
+          end
+        end
+      end
+
+      # Close both side.
+      #
+      # @return [void]
+      def close
+        @in.close
+        @out.close
+      end
+
+      # Is {#close} invoked?
+      #
+      # @return [Boolean]
+      def closed?
+        @in.closed? && @out.closed?
+      end
+
+      private
+
+      def partial
+        @buffer << @out.readpartial(READ_SIZE)
+      end
+    end
+  end
+end

data/lib/gdb/type_io.rb

@@ -0,0 +1,148 @@
+module GDB
+  # Support read / write custom defined tpyes.
+  class TypeIO
+    class << self
+      # Read a little endian integer.
+      #
+      # @param [#read] io
+      # @param [Integer] byte
+      # @param [:signed, :unsigned] sign
+      #   Signed or unsigned integer.
+      #
+      # @return [Integer]
+      #   The read integer.
+      #
+      # @example
+      #   read_integer(StringIO.new("\x80"), 1, :signed)
+      #   #=> -128
+      def read_integer(io, byte, sign)
+        str = io.read(byte).reverse # little endian
+        val = str.bytes.reduce(0) { |sum, b| sum * 256 + b }
+        if sign == :signed && val >= (1 << (8 * byte - 1))
+          val -= 1 << (8 * byte)
+        end
+        val
+      end
+
+      # Read until +needle+ appears.
+      #
+      # @param [IO] io
+      # @param [String] needle
+      #
+      # @return [String]
+      def read_until(io, needle)
+        str = ''
+        str << io.read(1) until str.end_with?(needle)
+        str
+      end
+    end
+
+    # Supported built-in types.
+    TYPES = {
+      string: nil, # will be special handled
+
+      cstring: ->(io) { TypeIO.read_until(io, "\x00") }, # read a null-terminated string.
+
+      int8:   ->(io) { TypeIO.read_integer(io, 1, :signed) },
+      int16:  ->(io) { TypeIO.read_integer(io, 2, :signed) },
+      int32:  ->(io) { TypeIO.read_integer(io, 4, :signed) },
+      int64:  ->(io) { TypeIO.read_integer(io, 8, :signed) },
+      int128: ->(io) { TypeIO.read_integer(io, 16, :signed) },
+
+      uint8:   ->(io) { TypeIO.read_integer(io, 1, :unsigned) },
+      uint16:  ->(io) { TypeIO.read_integer(io, 2, :unsigned) },
+      uint32:  ->(io) { TypeIO.read_integer(io, 4, :unsigned) },
+      uint64:  ->(io) { TypeIO.read_integer(io, 8, :unsigned) },
+      uint128: ->(io) { TypeIO.read_integer(io, 16, :unsigned) },
+
+      float: ->(io) { io.read(4).unpack('F').first },
+      double: ->(io) { io.read(8).unpack('D').first }
+    }.freeze
+
+    # Instantiate a {TypeIO} object.
+    #
+    # @param [IO, #pos=, #read, #write] io
+    #   The IO file.
+    def initialize(io)
+      @io = io.binmode
+    end
+
+    # Read data at specific address and cast into desired type.
+    #
+    # @param [Integer] addr
+    #   Address to be read.
+    #
+    # @param [Integer] size
+    #   Number of data to be read. See parameter +as+ for details.
+    #
+    # @param [Symbol] as
+    #   The needed returned type.
+    #   Note that the total bytes be read will be +size * sizeof(as)+.
+    #   For example, if +as+ equals +:int32+, +size * 4+ bytes would be read,
+    #   and returned type is array of 32 bits signed integers.
+    #
+    #   Supported types are listed in {TypeIO::TYPES}, all integer-like types
+    #   are seen as little endian. If you need big endian or other fashion things, pass a block
+    #   instead of using parameter +as+.
+    #
+    # @yieldparam [IO] io
+    #   If block is given, the parameter +as+ would be ignored.
+    #   Block would be invoked +size+ times, and the returned object would be collected into
+    #   one array and returned.
+    #
+    #   This is convenient for reading non-stable size objects, e.g. c++'s string object.
+    #   See examples for clearer usage.
+    #
+    # @yieldreturn [Object]
+    #   Whatever object you like.
+    #
+    # @return [String, Object, Array<Object>]
+    #   If +as+ equals to +:string+, the string with length +size+ would be returned.
+    #   Otherwise, array of objects would be returned.
+    #   An exception is when +size+ equals to 1, the read object would be returned
+    #   instead of create an array with only one element.
+    #
+    # @example
+    #   io = TypeIO.new(StringIO.new("AAAA"))
+    #   io.read(0, 3)
+    #   #=> "AAA"
+    #   io.read(0, 1, as: :uint32)
+    #   #=> 1094795585 # 0x41414141
+    #
+    #   io = TypeIO.new(StringIO.new("\xef\xbe\xad\xde"))
+    #   io.read(0, 4, as: :int8)
+    #   #=> [-17, -66, -83, -34]
+    #
+    #   io = TypeIO.new(StringIO.new("\x04ABCD\x03AAA\x00\x04meow"))
+    #   io.read(0, 4) do |m|
+    #     len = m.read(1).ord
+    #     m.read(len)
+    #   end
+    #   #=> ['ABCD', 'AAA', '', 'meow']
+    def read(addr, size, as: :string)
+      @io.pos = addr
+      if block_given?
+        return yield @io if size == 1
+        Array.new(size) { yield @io }
+      else
+        raise ArgumentError, "Unsupported types #{as.inspect}" unless TYPES.key?(as)
+        return @io.read(size) if as == :string
+        read(addr, size, &TYPES[as])
+      end
+    end
+
+    # Write a string at specific address.
+    #
+    # @param [Integer] addr
+    #   Target address.
+    # @param [String] str
+    #   String to be written.
+    #
+    # @return [Integer]
+    #   Bytes written.
+    def write(addr, str)
+      @io.pos = addr
+      @io.write(str)
+    end
+  end
+end

data/lib/gdb/version.rb

@@ -1,3 +1,4 @@
 module GDB
-  VERSION = '0.1.0'.freeze
+  # The current version of GDB.
+  VERSION = '0.2.0'.freeze
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: gdb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - david942j
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-20 00:00:00.000000000 Z
+date: 2017-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :development
+        version: '0.11'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.11'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: codeclimate-test-reporter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -108,16 +108,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: "  It's time for ruby lovers to use gdb in ruby, and... use ruby in gdb!\n"
+description: 'It''s time for Ruby lovers to use Ruby in gdb, and... gdb in Ruby!
+
+'
 email:
 - david942j@gmail.com
-executables: []
+executables:
+- gdb-ruby
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- Rakefile
+- bin/gdb-ruby
 - lib/gdb.rb
+- lib/gdb/eval_context.rb
+- lib/gdb/gdb.rb
+- lib/gdb/gdb_error.rb
+- lib/gdb/scripts/gdbinit.py
+- lib/gdb/tube/buffer.rb
+- lib/gdb/tube/tube.rb
+- lib/gdb/type_io.rb
 - lib/gdb/version.rb
 homepage: https://github.com/david942j/gdb-ruby
 licenses:
@@ -142,5 +152,5 @@ rubyforge_project:
 rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
-summary: Use gdb in ruby!
+summary: GDB Ruby-binding and Ruby command in GDB
 test_files: []

data/Rakefile

@@ -1,19 +0,0 @@
-require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
-require 'yard'
-
-task default: %i(rubocop spec)
-
-RuboCop::RakeTask.new(:rubocop) do |task|
-  task.patterns = %w[lib/**/*.rb spec/**/*.rb']
-end
-
-RSpec::Core::RakeTask.new(:spec) do |task|
-  task.pattern = './spec/**/*_spec.rb'
-  task.rspec_opts = ['--color', '--require spec_helper', '--order rand']
-end
-
-YARD::Rake::YardocTask.new(:doc) do |t|
-  t.files = ['lib/**/*.rb']
-  t.stats_options = ['--list-undoc']
-end