indis-core 0.1.1 → 0.1.2

data/lib/indis-core.rb

@@ -17,6 +17,7 @@
 ##############################################################################
 
 require 'indis-core/version'
+require 'indis-core/target'
 
 module Indis
 end

data/lib/indis-core/section.rb

@@ -21,13 +21,16 @@ module Indis
   class Section
     attr_reader :name, :segment
     attr_reader :vmaddr, :vmsize, :bytes
+    attr_reader :type, :attributes
     
-    def initialize(seg, name, vmaddr, vmsize, iooff)
+    def initialize(seg, name, vmaddr, vmsize, iooff, type, attrs)
       @segment = seg
       @name = name
       @vmaddr = vmaddr
       @vmsize = vmsize
       @iooff = iooff
+      @type = type
+      @attributes = attrs
     end
     
     def to_vmrange

data/lib/indis-core/symbol.rb

@@ -28,6 +28,10 @@ module Indis
       @format_sym = format_sym
       @vmaddr = vmaddr
     end
+    
+    def to_s
+      "#<Indis::Symbol #{@name} at #{@vmaddr.to_s 16}>"
+    end
   end
   
 end

data/lib/indis-core/target.rb

@@ -38,7 +38,7 @@ module Indis
     # @raise [AttributeError] if the file does not exist
     # @raise [RuntimeError] if there is no known format for magic or there are several matching formats
     def initialize(filename)
-      raise AttributeError, "File does not exist" unless FileTest.file?(filename)
+      raise ArgumentError, "File does not exist" unless FileTest.file?(filename)
       @filename = filename
       @io = StringIO.new(File.open(filename).read().force_encoding('BINARY'))
       
@@ -50,9 +50,23 @@ module Indis
       raise RuntimeError, "Unknown format for magic #{magic.to_s(16)}" if fmts.length == 0
       raise RuntimeError, "Several possible formats: #{fmts}" if fmts.length > 1
       
-      @format = fmts.first.new(self, @io)
+      @format_class = fmts.first
+      @format_load_complete = false
+    end
+    
+    # Perform format load and set up a vm map
+    def load
+      raise RuntimeError, "Already loaded" unless @format_class
+      @format = @format_class.new(self, @io)
+      @format_class = nil
       
       @vmmap = VMMap.new(self)
+
+      @format_load_complete = true
+      replay_queue
+      publish_event :target_load_complete
+      
+      self
     end
     
     # A target can consist of several other targets (e.g. fat mach-o). In such
@@ -63,6 +77,60 @@ module Indis
     def meta?
       @subtargets && @subtargets.length > 0
     end
+    
+    # External class can subscribe for events happening with target
+    #
+    # @param [Symbol] event event name
+    # @param listener event listener
+    def subscribe_for_event(event, listener)
+      subscriptions_array(event) << listener
+    end
+    
+    # Post an event with optional payload. All events queue up until #load ends
+    #
+    # @param [Symbol] event event name
+    def publish_event(event, *args)
+      if @format_load_complete == true
+        subscriptions_array(event).each { |s| s.send(event, *args) }
+      else
+        enqueue_event(event, args)
+      end
+    end
+    
+    # Resolves a symbol at given virtual address. Targe does so by first checking
+    # the locally available symbols, and falls back to format specific resolver
+    # if nothing found
+    #
+    # @param [Fixnum] vmaddr virtual address
+    # @return [Indis::Symbol, nil] resolved symbol or nil if none found
+    def resolve_symbol_at_address(vmaddr)
+      s = @symbols.find { |sym| sym.vmaddr == vmaddr }
+      return s if s
+      return @format.resolve_symbol_at_address(vmaddr) if @format.respond_to?(:resolve_symbol_at_address)
+    end
+    
+    private
+    def enqueue_event(event, args)
+      @event_queue ||= []
+      @event_queue << [event, args]
+    end
+    
+    def replay_queue
+      return unless @event_queue
+      @event_queue.each { |(e, args)| publish_event(e, *args) }
+      @event_queue = nil
+    end
+    
+    def subscriptions_array(event)
+      @subscriptions ||= {}
+      
+      a = @subscriptions[event]
+      unless a
+        a = []
+        @subscriptions[event] = a
+      end
+      a
+    end
   end
   
 end

data/lib/indis-core/version.rb

@@ -17,5 +17,5 @@
 ##############################################################################
 
 module Indis
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/indis-core/vmmap.rb

@@ -81,7 +81,7 @@ module Indis
     # Maps an {Indis::Entity entity} (based on its offset).
     # @raise [ArgumentError] if the range is occupied by another entity
     def map(e)
-      raise ArgumentError unless has_unmapped(e.vmaddr, e.size)
+      raise ArgumentError, "Tried to map #{e} at #{e.vmaddr}+#{e.size} on top of #{self[e.vmaddr...(e.vmaddr+e.size)]}" unless has_unmapped(e.vmaddr, e.size)
       @blocks[e.vmaddr] = e
     end
     

data/spec/indis-core/section_spec.rb

@@ -2,13 +2,13 @@ require 'indis-core/section'
 
 describe Indis::Section do
   it "should provide a correct range for its vm region" do
-    sect = Indis::Section.new(double('Segment'), '__text', 0x4096, 120, 0)
+    sect = Indis::Section.new(double('Segment'), '__text', 0x4096, 120, 0, :undef, [])
     sect.to_vmrange.should == (0x4096..0x410e)
   end
   
   it "should provide bytes value from segment based on io offset" do
     seg = double('Segment', bytes: 'qwertyuiop', iooff: 100)
-    sect = Indis::Section.new(seg, '__text', 0x4096, 4, 102)
+    sect = Indis::Section.new(seg, '__text', 0x4096, 4, 102, :undef, [])
     sect.bytes.should == 'erty'
   end
 end

data/spec/indis-core/target_spec.rb

@@ -6,13 +6,58 @@ describe Indis::Target do
   end
   
   it "should load file for known format" do
-    fmt = double('MachO', magic: 0xfeedface, name: 'Mach-O', new: nil)
+    fmt = double('MachO Class', magic: 0xfeedface, name: 'Mach-O', new: double('MachO'))
     Indis::BinaryFormat.stub(:known_formats).and_return([fmt])
     t = Indis::Target.new("spec/fixtures/single-object.o")
+    t.load
     t.io.length.should_not == 0
+    t.format.should_not be_nil
   end
   
   it "should raise if there is no known format to process binary" do
     expect { Indis::Target.new("spec/fixtures/single-object.o") }.to raise_error(RuntimeError)
   end
+  
+  it "should trigger load event" do
+    fmt = double('MachO Class', magic: 0xfeedface, name: 'Mach-O', new: double('MachO'))
+    Indis::BinaryFormat.stub(:known_formats).and_return([fmt])
+    t = Indis::Target.new("spec/fixtures/single-object.o")
+    
+    lis = double('Listener')
+    lis.should_receive(:target_load_complete)
+    
+    t.subscribe_for_event(:target_load_complete, lis)
+    
+    t.load
+  end
+  
+  it "should queue up events that happen before load" do
+    fmt = double('MachO Class', magic: 0xfeedface, name: 'Mach-O', new: double('MachO'))
+    Indis::BinaryFormat.stub(:known_formats).and_return([fmt])
+    t = Indis::Target.new("spec/fixtures/single-object.o")
+    
+    lis = double('Listener')
+    lis.should_receive(:early_event).twice
+    
+    t.subscribe_for_event(:early_event, lis)
+    
+    t.publish_event(:early_event)
+    t.publish_event(:early_event)
+    
+    t.load
+  end
+  
+  it "should pass arguments to event subscriptions" do
+    fmt = double('MachO Class', magic: 0xfeedface, name: 'Mach-O', new: double('MachO'))
+    Indis::BinaryFormat.stub(:known_formats).and_return([fmt])
+    t = Indis::Target.new("spec/fixtures/single-object.o")
+    t.load
+    
+    lis = double('Listener')
+    lis.should_receive(:event_with_args).with(1, 2).once
+    
+    t.subscribe_for_event(:event_with_args, lis)
+    
+    t.publish_event(:event_with_args, 1, 2)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indis-core
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-16 00:00:00.000000000 Z
+date: 2012-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec