heapinfo 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ba7cc3de8a173a616d298c30836fa0bb5a2800a
-  data.tar.gz: 792feedd7e5a6deea7b956082150cb7b4609d887
+  metadata.gz: 546784a7f3d841d2505b517a355afc2e1e914e5d
+  data.tar.gz: 166efbf709763a0a5a5a68d3e0f13515839bc125
 SHA512:
-  metadata.gz: d97610801e28487dd52e3e100558e746e8d23784a7925be2f99e4e35dd101c9976cbb526e1f18c18105b4a6bef2b00a305139f5406bd02021cedb75df6394749
-  data.tar.gz: 434774059d8ff5f5fcebc1fb81788a8fd9e78856f295c5bbfd3a045ae1b8b28cfa5237d4bd5cd330f71b319e1333efb65cfaffc557263721836a90f48687480f
+  metadata.gz: fb5882bc6a55e02abcfc7f11e646952ee50c1622cb8020103c6f1753163b49984d2be00e320eb0d61d601d3d30eb1a90d5dbd2b8053c83d80c9324159dc80f1e
+  data.tar.gz: 8789e7be0d5336870fc75100df74c5ea9151c0d4a9f6f7f9553756623915a4eef70b802f4a8511443f8a90322f50dfbfc0b60c697ebaab9400d1491705142901

data/README.md

@@ -121,6 +121,8 @@ Provide a searcher of memory, easier to use than in (naive) gdb.
 Support search integer, string, and even regular expression.
 
 ```ruby
+h.find(0xdeadbeef, 'heap+0x10', 0x1000)
+# => 6299664 # 0x602010
 h.find(/E.F/, 0x400000, 4)
 # => 4194305 # 0x400001
 h.find(/E.F/, 0x400000, 3)

data/lib/heapinfo.rb

@@ -12,13 +12,7 @@ module HeapInfo
   # Directory for writing some tmp files when working,
   # make sure /tmp is writable
   TMP_DIR = '/tmp/.heapinfo'
-
-  # Directory for caching files.
-  # e.g. HeapInfo will record main_arena_offset for glibc(s)
-  CACHE_DIR = '~/.cache/heapinfo'
-
-  FileUtils.mkdir_p(TMP_DIR)
-  FileUtils.mkdir_p(CACHE_DIR)
+  FileUtils.mkdir_p TMP_DIR
 
   # Entry point for using HeapInfo.
   # Show segments info of the process after loaded
@@ -65,6 +59,8 @@ end
 
 require 'heapinfo/helper'
 require 'heapinfo/nil'
+require 'heapinfo/cache'
+require 'heapinfo/process_info'
 require 'heapinfo/process'
 require 'heapinfo/segment'
 require 'heapinfo/libc'

data/lib/heapinfo/arena.rb

@@ -11,13 +11,13 @@ module HeapInfo
     def initialize(base, bits, dumper)
       @base, @dumper = base, dumper
       @size_t = bits / 8
-      reload
+      reload!
     end
 
     # Refresh all attributes
     # Retrive data using <tt>@dumper</tt>, load bins, top chunk etc.
     # @return [HeapInfo::Arena] self
-    def reload
+    def reload!
       top_ptr = Helper.unpack(size_t, @dumper.call(@base + 8 + size_t * 10, size_t))
       @fastbin = []
       return self if top_ptr == 0 # arena not init yet
@@ -172,8 +172,8 @@ module HeapInfo
           sz += 1
         end
       end
-      work.call(@fd, :fd_of, lambda{|ptr| list << ptr})
-      work.call(@bk, :bk_of, lambda{|ptr| list.unshift ptr})
+      work.call(@fd, :fd_of, ->(ptr) { list << ptr })
+      work.call(@bk, :bk_of, ->(ptr) { list.unshift ptr })
       list
     end
   end

data/lib/heapinfo/cache.rb

@@ -0,0 +1,67 @@
+require 'digest'
+module HeapInfo
+
+  # Self implment file-base cache manager.
+  #
+  # Values are recorded in files based on <tt>Marshal</tt>
+  module Cache
+    # Directory for caching files.
+    # e.g. HeapInfo will record main_arena_offset for glibc(s)
+    CACHE_DIR = File.join(ENV['HOME'], '.cache/heapinfo')
+
+    # Get the key for store libc offsets
+    #
+    # @param [String] libc_path The realpath to libc file
+    # @return [String] The key for cache read/write.
+    def self.key_libc_offset(libc_path)
+      File.join('libc', Digest::MD5.hexdigest(IO.binread(libc_path)), 'offset')
+    end
+
+    # Write cache to file.
+    #
+    # @param [String] key In file path format, only accept <tt>[\w\/]</tt> to prevent horrible things.
+    # @param [Object] value <tt>value</tt> will be stored with <tt>#Marshal::dump</tt>.
+    # @return [Boolean] true
+    def self.write(key, value)
+      filepath = realpath key
+      FileUtils.mkdir_p(File.dirname filepath)
+      IO.binwrite(filepath, Marshal::dump(value))
+      true
+    end
+
+    # Read cache from file.
+    #
+    # @param [String] key In file path format, only accept <tt>[\w\/]</tt> to prevent horrible things.
+    # @return [Object, NilClass] value that recorded, return <tt>nil</tt> when cache miss.
+    def self.read(key)
+      filepath = realpath key
+      return unless File.file? filepath
+      Marshal::load IO.binread filepath
+    rescue
+      nil # handle if file content invalid
+    end
+
+    # @param [String] key
+    # @return [String] Prepend with <tt>CACHE_DIR</tt>
+    def self.realpath(key)
+      raise ArgumentError.new('Invalid key(file path)') if key =~ /[^\w\/]/
+      File.join(CACHE_DIR, key)
+    end
+
+    # @return [Object] Not important.
+    def self.load
+      FileUtils.mkdir_p(CACHE_DIR)
+    rescue
+      # To prevent ~/ is not writable.
+      self.send :remove_const, :CACHE_DIR
+      self.const_set :CACHE_DIR, File.join(HeapInfo::TMP_DIR, '.cache/heapinfo')
+    end
+
+    # Clear the cache directory.
+    # @return [Object] Not important.
+    def self.clear_all
+      FileUtils.rm_rf CACHE_DIR
+    end
+    self.load
+  end
+end

data/lib/heapinfo/chunk.rb

@@ -17,10 +17,10 @@ module HeapInfo
     # @param [Proc] dumper For dump more information of this chunk
     # @param [Boolean] head For specific if is fake chunk in <tt>arena</tt>. If <tt>head</tt> is <tt>true</tt>, will not load <tt>size</tt> and <tt>prev_size</tt> (since it's meaningless)
     # @example
-    #   HeapInfo::Chunk.new 8, 0x602000, lambda{|addr, len| [0,0x21, 0xda4a].pack("Q*")[addr-0x602000, len]}
+    #   HeapInfo::Chunk.new 8, 0x602000, ->(addr, len) { [0,0x21, 0xda4a].pack("Q*")[addr-0x602000, len] }
     #   # create a chunk with chunk size 0x21
     def initialize(size_t, base, dumper, head: false)
-      fail unless [4, 8].include? size_t 
+      raise ArgumentError.new('size_t can be either 4 or 8') unless [4, 8].include? size_t 
       self.class.send(:define_method, :dump){|*args| dumper.call(*args)}
       @size_t = size_t
       @base = base

data/lib/heapinfo/dumper.rb

@@ -6,10 +6,10 @@ module HeapInfo
 
     # Instantiate a <tt>HeapInfo::Dumper</tt> object
     #
-    # @param [Hash] segments With values <tt>HeapInfo::Segment</tt>
+    # @param [HeapInfo::ProcessInfo] info process info object.
     # @param [String] mem_filename The filename that can be access for dump. Should be <tt>/proc/[pid]/mem</tt>.
-    def initialize(segments, mem_filename)
-      @segments, @filename = segments, mem_filename
+    def initialize(info, mem_filename)
+      @info, @filename = info, mem_filename
       need_permission unless dumpable?
     end
 
@@ -21,20 +21,14 @@ module HeapInfo
     #   # => "\x7fELF"
     def dump(*args)
       return need_permission unless dumpable?
-      base, offset, len = Dumper.parse_cmd(args)
-      if base.instance_of?(Symbol) and @segments[base].instance_of?(Segment)
-        addr = @segments[base].base
-      elsif base.is_a? Integer
-        addr = base
-      else
-        fail # invalid usage
-      end
+      base, len = base_len_of(*args)
       file = mem_f
-      file.pos = addr + offset
-      mem = file.read len
+      file.pos = base
+      mem = file.readpartial len
       file.close
       mem
-    rescue
+    rescue => e
+      raise e if e.is_a? ArgumentError
       nil 
     end
 
@@ -46,7 +40,7 @@ module HeapInfo
     # @param [Mixed] args Same as arguments of <tt>#dump</tt>
     def dump_chunks(*args)
       base = base_of(*args)
-      dump(*args).to_chunks(bits: @segments[:bits], base: base)
+      dump(*args).to_chunks(bits: @info.bits, base: base)
     end
 
     # Show dump results like in gdb's command <tt>x</tt>.
@@ -165,10 +159,18 @@ module HeapInfo
       File.open(@filename)
     end
 
+    def base_len_of(*args)
+      base, offset, len = Dumper.parse_cmd(args)
+      if HeapInfo::ProcessInfo::EXPORT.include?(base) and (segment = @info.send(base)).is_a? Segment
+        base = segment.base
+      elsif not base.is_a? Integer
+        raise ArgumentError.new("Invalid base: #{base}") # invalid usage
+      end
+      [base + offset, len]
+    end
+
     def base_of(*args)
-      base, offset, _ = Dumper.parse_cmd(args)
-      base = @segments[base].base if @segments[base].is_a? Segment
-      base + offset
+      base_len_of(*args)[0]
     end
 
     def find_integer(value, from, length)
@@ -198,7 +200,7 @@ module HeapInfo
       from + idx
     end
     def size_t
-      @segments[:bits] / 8
+      @info.bits / 8
     end
   end
 end

data/lib/heapinfo/ext/string.rb

@@ -5,7 +5,7 @@ module HeapInfo
       module InstanceMethods
         def to_chunk(bits: 64, base: 0)
           size_t = bits / 8
-          dumper = lambda{|addr, len| self[addr-base, len]}
+          dumper = ->(addr, len) { self[addr-base, len] }
           Chunk.new(size_t, base, dumper)
         end
 

data/lib/heapinfo/libc.rb

@@ -1,16 +1,21 @@
 module HeapInfo
   class Libc < Segment
+    def initialize(*args)
+      super
+      @offset = {}
+    end
+
     def main_arena_offset
-      return @_main_arena_offset if @_main_arena_offset
+      return @offset[:main_arena] if @offset[:main_arena]
       return nil unless exhaust_search :main_arena
-      @_main_arena_offset
+      @offset[:main_arena]
     end
 
     def main_arena
-      return @_main_arena.reload if @_main_arena
+      return @main_arena.reload! if @main_arena
       off = main_arena_offset
       return if off.nil?
-      @_main_arena = Arena.new(off + self.base, process.bits, lambda{|*args|process.send(:dumper).dump(*args)})
+      @main_arena = Arena.new(off + self.base, process.bits, ->(*args) { process.dump(*args) })
     end
 
     def self.find(maps, name, process)
@@ -25,11 +30,18 @@ module HeapInfo
     # only for searching offset of main_arena now
     def exhaust_search(symbol)
       return false if symbol != :main_arena
-      # TODO: read from cache
-      @_main_arena_offset = resolve_main_arena_offset
+      read_main_arena_offset
       true
     end
 
+    def read_main_arena_offset
+      key = HeapInfo::Cache::key_libc_offset(self.name)
+      @offset = HeapInfo::Cache::read(key) || {}
+      return @offset[:main_arena] if @offset.key? :main_arena
+      @offset[:main_arena] = resolve_main_arena_offset
+      HeapInfo::Cache::write key, @offset
+    end
+
     def resolve_main_arena_offset
       tmp_elf = HeapInfo::TMP_DIR + "/get_arena"
       libc_file = HeapInfo::TMP_DIR + "/libc.so.6"
@@ -37,8 +49,7 @@ module HeapInfo
       flags = "-w #{@process.bits == 32 ? '-m32' : ''}"
       %x(cp #{self.name} #{libc_file} && \
          cp #{@process.ld.name} #{ld_file} && \
-         chdir #{File.expand_path('../tools', __FILE__)} && \
-         gcc #{flags} get_arena.c -o #{tmp_elf} 2>&1 > /dev/null && \
+         gcc #{flags} #{File.expand_path('../tools/get_arena.c', __FILE__)} -o #{tmp_elf} 2>&1 > /dev/null && \
          #{ld_file} --library-path #{HeapInfo::TMP_DIR} #{tmp_elf} && \
          rm #{tmp_elf} #{libc_file} #{ld_file}).to_i(16)
     end

data/lib/heapinfo/process.rb

@@ -2,7 +2,7 @@
 module HeapInfo
   # Main class of heapinfo.
   class Process
-    # The dafault options of libaries,
+    # The default options of libaries,
     # use for matching glibc and ld segments in <tt>/proc/[pid]/maps</tt>
     DEFAULT_LIB = {
       libc: /libc[^\w]/,
@@ -10,7 +10,6 @@ module HeapInfo
     }
     # @return [Fixnum, NilClass] return the pid of process, <tt>nil</tt> if no such process found
     attr_reader :pid
-    attr_reader :status
 
     # Instantiate a <tt>HeapInfo::Process</tt> object
     # @param [String, Fixnum] prog Process name or pid, see <tt>HeapInfo::heapinfo</tt> for more information
@@ -20,7 +19,6 @@ module HeapInfo
       @options = DEFAULT_LIB.merge options
       load!
       return unless load?
-      @dumper = Dumper.new(@status, mem_filename)
     end
 
     # Use this method to wrapper all HeapInfo methods.
@@ -65,7 +63,7 @@ module HeapInfo
     #   dump('heap-1, 64') # not support '-'
     def dump(*args)
       return Nil.new unless load?
-      @dumper.dump(*args)
+      dumper.dump(*args)
     end
 
     # Return the dump result as chunks.
@@ -75,7 +73,7 @@ module HeapInfo
     # @param [Mixed] args Same as arguments of <tt>#dump</tt>
     def dump_chunks(*args)
       return Nil.new unless load?
-      @dumper.dump_chunks(*args)
+      dumper.dump_chunks(*args)
     end
 
     # Gdb-like command
@@ -100,24 +98,29 @@ module HeapInfo
     #   # 0x400010:       0x00000001003e0002
     def x(count, *commands, io: $stdout)
       return unless load? and io.respond_to? :puts
-      @dumper.x(count, *commands, io: io)
+      dumper.x(count, *commands, io: io)
     end
 
     # Gdb-like command.
     #
     # Search a specific value/string/regexp in memory.
-    # <tt>#find</tt> only return the first matched address, if want to find all adress, use <tt>#find_all</tt> instead.
     # @param [Integer, String, Regexp] pattern The desired search pattern, can be value(<tt>Integer</tt>), string, or regular expression.
     # @param [Integer, String, Symbol] from Start address for searching, can be segment(<tt>Symbol</tt>) or segments with offset. See examples for more information.
     # @param [Integer] length The search length limit, default is unlimited, which will search until pattern found or reach unreadable memory.
     # @return [Integer, NilClass] The first matched address, <tt>nil</tt> is returned when no such pattern found.
     # @example
-    #   h.find(0xdeadbeef, :heap)
     #   h.find(0xdeadbeef, 'heap+0x10', 0x1000)
+    #   # => 6299664 # 0x602010
+    #   h.find(/E.F/, 0x400000, 4)
+    #   # => 4194305 # 0x400001
+    #   h.find(/E.F/, 0x400000, 3)
+    #   # => nil
+    #   sh_offset = h.find('/bin/sh', :libc) - h.libc.base
+    #   # => 1559771 # 0x17ccdb
     def find(pattern, from, length = :unlimited)
       return Nil.new unless load?
       length = 1 << 40 if length.is_a? Symbol
-      @dumper.find(pattern, from, length)
+      dumper.find(pattern, from, length)
     end
 
     # <tt>search</tt> is more intutive to me
@@ -153,15 +156,16 @@ module HeapInfo
     end
 
   private
-    attr_reader :dumper
+    attr_accessor :dumper
     def load?
       @pid != nil
     end
 
-    def load! # force load is not efficient
+    def load! # try to load
+      return if @pid
       @pid = fetch_pid
       return false if @pid.nil? # still can't load
-      load_status @options
+      load_info!
       true
     end
 
@@ -175,28 +179,12 @@ module HeapInfo
       pid
     end
 
-    def load_status(options)
-      elf  = Helper.exe_of pid
-      maps = Helper.parse_maps Helper.maps_of pid
-      @status = {
-        program: Segment.find(maps, File.readlink("/proc/#{pid}/exe")),
-        libc:    Libc.find(maps, match_maps(maps, options[:libc]), self),
-        heap:    Segment.find(maps, '[heap]'),
-        stack:   Segment.find(maps, '[stack]'),
-        ld:      Segment.find(maps, match_maps(maps, options[:ld])),
-        bits:    bits_of(elf),
-      }
-      @status[:elf] = @status[:program] #alias
-      @status.keys.each do |m|
-        self.class.send(:define_method, m) {@status[m]}
+    def load_info!
+      @info = ProcessInfo.new(self)
+      ProcessInfo::EXPORT.each do |m|
+        self.class.send(:define_method, m) {@info.send(m)}
       end
-      @dumper = Dumper.new(@status, mem_filename)
-    end
-    def match_maps(maps, pattern)
-      maps.map{|s| s[3]}.find{|seg| pattern.is_a?(Regexp) ? seg =~ pattern : seg.include?(pattern)}
-    end
-    def bits_of(elf)
-      elf[4] == "\x01" ? 32 : 64
+      @dumper = Dumper.new(@info, mem_filename)
     end
     def mem_filename
       "/proc/#{pid}/mem"

data/lib/heapinfo/process_info.rb

@@ -0,0 +1,54 @@
+#encoding: ascii-8bit
+module HeapInfo
+  # for <tt>Process</tt> to record current info(s)
+  # <tt>Process</tt> has a <tt>process_info</tt> object iff the process found (pid not <tt>nil</tt>).
+  # Mainly records segments' base.
+  class ProcessInfo
+    # Methods to be transparent to <tt>process</tt>.
+    # e.g. <tt>process.libc alias to process.info.libc</tt>
+    EXPORT = %i(libc ld heap elf program stack bits)
+   
+    attr_reader :bits, :program, :stack, :libc, :ld
+    alias :elf :program
+
+    # Instantiate a <tt>ProcessInfo</tt> object
+    #
+    # @param [HeapInfo::Process] process Load information from maps/memory for <tt>process</tt>
+    def initialize(process)
+      @pid = process.pid
+      options = process.instance_variable_get(:@options)
+      maps!
+      @bits = bits_of Helper.exe_of @pid
+      @elf = @program = Segment.find(maps, File.readlink("/proc/#{@pid}/exe"))
+      @stack = Segment.find(maps, '[stack]')
+      # well.. stack is a strange case because it will grow in runtime..
+      # should i detect stack base growing..?
+      @libc = Libc.find(maps, match_maps(maps, options[:libc]), process)
+      @ld = Segment.find(maps, match_maps(maps, options[:ld]))
+    end
+
+    # Heap will not be mmapped if the process not use heap yet, so create a lazy loading method.
+    # Will re-read maps when heap segment not found yet.
+    #
+    # @return [HeapInfo::Segment] The <tt>Segment</tt> of heap
+    def heap # special handle because heap might not be initialized in the beginning
+      @heap ||= Segment.find(maps!, '[heap]')
+    end
+
+  private
+    attr_reader :maps
+
+    # force reload maps
+    def maps!
+      @maps = Helper.parse_maps Helper.maps_of @pid
+    end
+
+    def bits_of(elf)
+      elf[4] == "\x01" ? 32 : 64
+    end
+
+    def match_maps(maps, pattern)
+      maps.map{|s| s[3]}.find{|seg| pattern.is_a?(Regexp) ? seg =~ pattern : seg.include?(pattern)}
+    end
+  end
+end

data/lib/heapinfo/version.rb

@@ -1,3 +1,3 @@
 module HeapInfo
-  VERSION = '0.0.0'.freeze
+  VERSION = '0.0.1'.freeze
 end

data/spec/cache_spec.rb

@@ -0,0 +1,46 @@
+# encoding: ascii-8bit
+require 'heapinfo'
+describe HeapInfo::Cache do
+  before(:all) do
+    @prefix = 'testcx1dd/'
+  end
+  after(:each) do
+    FileUtils.rm_rf File.join(HeapInfo::Cache::CACHE_DIR, @prefix)
+  end
+  it 'handle unwritable' do
+    org = HeapInfo::Cache::CACHE_DIR
+    HeapInfo::Cache.send :remove_const, :CACHE_DIR
+    no = '/tmp/no_permission'
+    FileUtils.mkdir_p no
+    File.chmod 0444, no # no write permission
+    HeapInfo::Cache.const_set :CACHE_DIR, no + '/.cache'
+    HeapInfo::Cache.send :load
+    expect(HeapInfo::Cache::CACHE_DIR).to eq HeapInfo::TMP_DIR + '/.cache/heapinfo'
+    HeapInfo::Cache.send :remove_const, :CACHE_DIR
+    HeapInfo::Cache.const_set :CACHE_DIR, org
+    FileUtils.rm_rf no
+  end
+
+  it 'write' do
+    expect(HeapInfo::Cache::write @prefix + '123', {a: 1}).to be true
+  end
+
+  it 'read' do
+    expect(HeapInfo::Cache::read @prefix + 'z/zzz').to be nil
+  end
+
+  it 'write and read' do
+    key = @prefix + 'fefw/z/zz/xdddd'
+    object = {a: {b: 'string', array: [3, '1', 2]}, 'd' => 3}
+    expect(HeapInfo::Cache::read key).to be nil
+    expect(HeapInfo::Cache::write key, object).to be true
+    expect(HeapInfo::Cache::read key).to eq object
+  end
+
+  it 'file corrupted' do
+    key = @prefix + 'corrupted'
+    HeapInfo::Cache::write key, 'ok'
+    IO.binwrite(File.join(HeapInfo::Cache::CACHE_DIR, key), 'not ok')
+    expect(HeapInfo::Cache::read key).to be nil
+  end
+end

data/spec/dumper_spec.rb

@@ -10,19 +10,19 @@ describe HeapInfo::Dumper do
       expect(dumper.dump(0x400000, 4)).to eq "\x7fELF"
     end
     it 'segment' do
-      segments = {elf: HeapInfo::Segment.new(0x400000, 'elf')}
-      dumper = HeapInfo::Dumper.new(segments, @mem_filename)
+      class S;def elf; HeapInfo::Segment.new(0x400000, 'elf'); end; end
+      dumper = HeapInfo::Dumper.new(S.new, @mem_filename)
       expect(dumper.dump(:elf, 4)).to eq "\x7fELF"
     end
     it 'invalid' do
-      dumper = HeapInfo::Dumper.new({}, @mem_filename)
-      expect(dumper.dump(:zzz, 1)).to be nil
+      dumper = HeapInfo::Dumper.new(HeapInfo::Nil.new, @mem_filename)
+      expect {dumper.dump(:zzz, 1)}.to raise_error ArgumentError
       expect(dumper.dump(0x12345, 1)).to be nil
     end
   end
 
   it 'dumpable?' do
-    dumper = HeapInfo::Dumper.new({}, '/proc/self/mem')
+    dumper = HeapInfo::Dumper.new(HeapInfo::Nil.new, '/proc/self/mem')
     expect(dumper.send(:dumpable?)).to be true
     # a little hack
     dumper.instance_variable_set(:@filename, '/proc/1/mem')
@@ -34,7 +34,8 @@ describe HeapInfo::Dumper do
 
   describe 'find' do
     before(:all) do
-      @dumper = HeapInfo::Dumper.new({elf: HeapInfo::Segment.new(0x400000, ''), bits: 64}, '/proc/self/mem')
+      class S;def elf; HeapInfo::Segment.new(0x400000, ''); end; def bits; 64; end; end
+      @dumper = HeapInfo::Dumper.new(S.new, '/proc/self/mem')
     end
     it 'simple' do
       expect(@dumper.find("ELF", :elf, 4)).to eq 0x400001
@@ -50,6 +51,10 @@ describe HeapInfo::Dumper do
     it 'parser' do
       expect(@dumper.find("ELF", ':elf + 1', 3)).to eq 0x400001
     end
+    it 'reach end' do
+      # check dumper won't return nil when remain readable memory less than one page
+      expect(@dumper.find("\x00", 0x601010, 0x1000).nil?).to be false
+    end
   end
 
   describe 'parse_cmd' do

data/spec/process_spec.rb

@@ -26,6 +26,7 @@ describe HeapInfo::Process do
 
   describe 'victim' do
     before(:all) do
+      HeapInfo::Cache.send :clear_all # force cache miss, to make sure coverage
       @victim = HeapInfo::TMP_DIR + '/victim'
       %x(g++ #{File.expand_path('../files/victim.cpp', __FILE__)} -o #{@victim} 2>&1 > /dev/null)
       pid = fork

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: heapinfo
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - david942j
@@ -10,8 +10,7 @@ bindir: bin
 cert_chain: []
 date: 2016-05-21 00:00:00.000000000 Z
 dependencies: []
-description: create an interactive heap info interface while exploiting binary (with
-  glibc) with ruby
+description: create an interactive memory info interface while pwn / exploiting
 email:
 - david942j@gmail.com
 executables: []
@@ -21,6 +20,7 @@ files:
 - README.md
 - lib/heapinfo.rb
 - lib/heapinfo/arena.rb
+- lib/heapinfo/cache.rb
 - lib/heapinfo/chunk.rb
 - lib/heapinfo/chunks.rb
 - lib/heapinfo/dumper.rb
@@ -29,9 +29,11 @@ files:
 - lib/heapinfo/libc.rb
 - lib/heapinfo/nil.rb
 - lib/heapinfo/process.rb
+- lib/heapinfo/process_info.rb
 - lib/heapinfo/segment.rb
 - lib/heapinfo/tools/get_arena.c
 - lib/heapinfo/version.rb
+- spec/cache_spec.rb
 - spec/chunk_spec.rb
 - spec/chunks_spec.rb
 - spec/dumper_spec.rb
@@ -73,6 +75,7 @@ test_files:
 - spec/files/64bit_maps
 - spec/files/victim.cpp
 - spec/helper_spec.rb
+- spec/cache_spec.rb
 - spec/string_spec.rb
 - spec/spec_helper.rb
 - spec/nil_spec.rb