ruby-macho 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 686c8eeee9cd964f7c1112259c64ba6f37650262
+  data.tar.gz: 9c7a05e36acc9b2120263e3847ca0dbb8e8f9fd9
+SHA512:
+  metadata.gz: ff579faa1788421e587e995b4434ff2e8ef0f5491b33c4d599577ea70fff6ac7ce3b3e4eea166d5e5e94cd5128f3050adab90b38949fdc854419fbacfa059aa2
+  data.tar.gz: 107c76d944b6aa7987ac1c0299f2d49ee8e48eb8a4b8a9fa046ea9fbd6821586910c0892792c14c3aefb094b02d0a2a60c8d811cddc2c3f73309933f330c6b2c

data/lib/cstruct.rb

@@ -0,0 +1,346 @@
+# Struct does some trickery with custom allocators so we can't
+# subclass it without writing C.  Instead we define a CStruct class
+# that does something similar enough for our purpose.  It is
+# subclassed just like any other class.  A nice side-effect of this
+# syntax is that it is always clear that a CStruct is just a class and
+# instances of the struct are objects.
+#    
+# Some light metaprogramming is used to make the following syntax possible:
+#
+# class MachHeader < CStruct
+#   uint :magic
+#   int  :cputype
+#   int  :cpusubtype
+#    ...
+#   int  :flags
+# end
+#
+# Inheritance works as you would expect.
+#
+# class LoadCommand < CStruct
+#   uint32 :cmd
+#   uint32 :cmdsize
+# end
+# 
+# # inherits cmd and cmdsize as the first 2 fields
+# class SegmentCommand < LoadCommand
+#   string :segname, 16
+#   uint32 :vmaddr
+#   uint32 
+# end
+#
+# Nothing tricky or confusing there.  Members of a CStruct class are
+# declared in the class definition.  A different definition using a
+# more static approach probably wouldn't be very hard...  if
+# performance is critical ... but then why are you using Ruby? ;-)
+#
+#
+# TODO support bit fields
+#
+# Bit fields should be supported by passing the number of bits a field
+# should occupy. Perhaps we could use the size 'pack' for the rest of
+# the field.
+#
+# class RelocationInfo < CStruct
+#   int32  :address
+#   uint32 :symbolnum, 24
+#   pack   :pcrel,      1
+#   pack   :length,     2
+#   pack   :extern,     1
+#   pack   :type,       4
+# end
+
+class CStruct
+
+
+  ###################
+  # Class Constants #
+  ###################
+  
+  # Size in bytes.
+  SizeMap = {
+    :int8   => 1,
+    :uint8  => 1,
+    :int16  => 2,
+    :uint16 => 2,
+    :int32  => 4,
+    :uint32 => 4,
+    :int64  => 8,
+    :uint64 => 8,
+    :string => lambda { |*opts| opts.first }, # first opt is size
+    # the last 3 are to make the language more C-like
+    :int    => 4,
+    :uint   => 4,
+    :char   => 1
+  }
+
+  # 32-bit
+  PackMap = {
+    :int8   => 'c',
+    :uint8  => 'C',
+    :int16  => 's',
+    :uint16 => 'S',
+    :int32  => 'i',
+    :uint32 => 'I',
+    :int64  => 'q',
+    :uint64 => 'Q',
+    :string => lambda do |str, *opts|
+                        len = opts.first
+                        str.ljust(len, "\0")[0, len]
+                      end,
+    # a few C-like names
+    :int    => 'i',
+    :uint   => 'I',
+    :char   => 'C'
+  }
+  
+  # Only needed when unpacking is different from packing, i.e. strings w/ lambdas in PackMap.
+  UnpackMap = {
+    :string => lambda do |str, *opts|
+                        len = opts.first
+                        val = str[0, len-1].sub(/\0*$/, '')
+                        str.slice!((len-1)..-1)
+                        val
+                      end
+  }
+  
+  ##########################
+  # Class Instance Methods #
+  ##########################
+  
+  # Note: const_get and const_set are used so the constants are bound
+  #       at runtime, to the real class that has subclassed CStruct.
+  #       I figured Ruby would do this but I haven't looked at the
+  #       implementation of constants so it might be tricky.
+  #
+  #       All of this could probably be avoided with Ruby 1.9 and
+  #       private class variables.  That is definitely something to
+  #       experiment with.
+  
+  class <<self
+    
+    def inherited(subclass)
+      subclass.instance_eval do
+        
+        # These "constants" are only constant references.  Structs can
+        # be modified.  After the struct is defined it is still open,
+        # but good practice would be not to change a struct after it
+        # has been defined.
+        # 
+        # To support inheritance properly we try to get these
+        # constants from the enclosing scope (and clone them before
+        # modifying them!), and default to empty, er, defaults.
+        
+        members = const_get(:Members).clone rescue []
+        member_index = const_get(:MemberIndex).clone rescue {}
+        member_sizes = const_get(:MemberSizes).clone rescue {}
+        member_opts = const_get(:MemberOptions).clone rescue {}
+        
+        const_set(:Members, members)
+        const_set(:MemberIndex, member_index)
+        const_set(:MemberSizes, member_sizes)
+        const_set(:MemberOptions, member_opts)
+        
+      end
+    end
+
+
+    # Define a method for each size name, and when that method is called it updates
+    # the struct class accordingly.
+    SizeMap.keys.each do |type|
+      
+      define_method(type) do |name, *args|
+        name = name.to_sym
+        const_get(:MemberIndex)[name] = const_get(:Members).size
+        const_get(:MemberSizes)[name] = type
+        const_get(:MemberOptions)[name] = args
+        const_get(:Members) << name
+      end
+      
+    end
+    
+    
+    # Return the number of members.
+    def size
+      const_get(:Members).size
+    end
+    alias_method :length, :size
+    
+    # Return the number of bytes occupied in memory or on disk.
+    def bytesize
+      const_get(:Members).inject(0) { |size, name| size + sizeof(name) }
+    end
+        
+    def sizeof(name)
+      value = SizeMap[const_get(:MemberSizes)[name]]
+      value.respond_to?(:call) ? value.call(*const_get(:MemberOptions)[name]) : value
+    end
+
+    def new_from_bin(bin)
+      new_struct = new
+      new_struct.unserialize(bin)
+    end
+
+  end
+  
+
+  ####################
+  # Instance Methods #
+  ####################
+  
+  attr_reader :values
+  
+  def initialize(*args)
+    @values = args
+  end
+
+  def serialize
+    vals = @values.clone
+    membs = members.clone
+    pack_pattern.map do |patt|
+      name = membs.shift
+      if patt.is_a?(String)
+        [vals.shift].pack(patt)
+      else
+        patt.call(vals.shift, *member_options[name])
+      end      
+    end.join
+  end
+
+  def unserialize(bin)
+    bin = bin.clone
+    @values = []
+    membs = members.clone
+    unpack_pattern.each do |patt|
+      name = membs.shift
+      if patt.is_a?(String)
+        @values += bin.unpack(patt)
+        bin.slice!(0, sizeof(name))
+      else
+        @values << patt.call(bin, *member_options[name])
+      end
+    end
+    self
+  end
+  
+  def pack_pattern
+    members.map { |name| PackMap[member_sizes[name]] }
+  end
+  
+  def unpack_pattern
+    members.map { |name| UnpackMap[member_sizes[name]] || PackMap[member_sizes[name]] }
+  end
+  
+  def [](name_or_idx)
+    case name_or_idx
+      
+    when Numeric
+      idx = name_or_idx
+      @values[idx]
+      
+    when String, Symbol
+      name = name_or_idx.to_sym
+      @values[member_index[name]]
+      
+    else
+      raise ArgumentError, "expected name or index, got #{name_or_idx.inspect}"
+    end
+  end
+  
+  def []=(name_or_idx, value)
+    case name_or_idx
+      
+    when Numeric
+      idx = name_or_idx
+      @values[idx] = value
+      
+    when String, Symbol
+      name = name_or_idx.to_sym
+      @values[member_index[name]] = value
+      
+    else
+      raise ArgumentError, "expected name or index, got #{name_or_idx.inspect}"
+    end
+  end
+  
+  def ==(other)
+    puts @values.inspect
+    puts other.values.inspect
+    other.is_a?(self.class) && other.values == @values
+  end
+
+  # Some of these are just to quack like Ruby's built-in Struct.  YAGNI, but can't hurt either.
+
+  def each(&block)
+    @values.each(&block)
+  end
+  
+  def each_pair(&block)
+    members.zip(@values).each(&block)
+  end
+  
+  def size
+    members.size
+  end
+  alias_method :length, :size
+  
+  def sizeof(name)
+    self.class.sizeof(name)
+  end
+
+  def bytesize
+    self.class.bytesize
+  end
+
+  alias_method :to_a, :values
+
+
+  # A few convenience methods.
+
+  def members
+    self.class::Members
+  end
+  
+  def member_index
+    self.class::MemberIndex
+  end
+  
+  def member_sizes
+    self.class::MemberSizes
+  end
+ 
+  def member_options
+    self.class::MemberOptions
+  end
+ 
+  # The last expression is returned, so return self instead of junk.
+  self  
+end
+
+
+# a small test
+if $0 == __FILE__
+  class MachHeader < CStruct
+    uint :magic
+    int  :cputype
+    int  :cpusubtype
+    string :segname, 16
+  end
+  puts MachHeader::Members.inspect
+  puts MachHeader::MemberIndex.inspect
+  puts MachHeader::MemberSizes.inspect
+  puts "# of MachHeader members: " + MachHeader.size.to_s + ", size in bytes: " + MachHeader.bytesize.to_s
+  mh = MachHeader.new(0xfeedface, 7, 3, "foobar")
+  %w[magic cputype cpusubtype segname].each do |field|
+    puts "#{field}(#{MachHeader.sizeof(field.to_sym)}):      #{mh[field.to_sym].inspect}"
+  end
+  puts mh.pack_pattern.inspect
+  binstr = mh.serialize
+  puts "values: " + mh.values.inspect
+  newmh = MachHeader.new_from_bin(binstr)
+  puts "new values: " + newmh.values.inspect
+  newbinstr = newmh.serialize
+  puts "serialized:   " + binstr.inspect
+  puts "unserialized: " + newbinstr.inspect
+  puts "new == old ? " + (newbinstr == binstr).to_s
+end

data/lib/int_helpers.rb

@@ -0,0 +1,17 @@
+module INTHelpers
+	Change = Struct.new("Changes", :old, :new)
+
+	Rpath = Struct.new("Rpaths", :old, :new, :found) do
+		def found?
+			found
+		end
+	end
+
+	AddRpath = Struct.new("AddRpaths", :new)
+
+	DeleteRpath = Struct.new("DeleteRpaths", :old, :found) do
+		def found?
+			found
+		end
+	end
+end

data/lib/macho.rb

@@ -0,0 +1,14 @@
+$:.unshift File.dirname(__FILE__)
+
+require "cstruct"
+require "macho/headers"
+require "macho/structure"
+require "macho/load_commands"
+require "macho/sections"
+require "macho/file"
+require "macho/exceptions"
+require "macho/utils"
+
+module MachO
+	# nothing to see here.
+end

data/lib/macho/exceptions.rb

@@ -0,0 +1,54 @@
+module MachO
+	# generic toplevel error
+	class MachOError < RuntimeError
+	end
+
+	# raised when a file's magic bytes are not valid mach-o magic
+	class MagicError < MachOError
+		def initialize(num)
+			super "Unrecognized Mach-O magic: 0x#{"%02x" % num}"
+		end
+	end
+
+	# raised when a file's magic bytes are those of a fat binary
+	class FatBinaryError < MachOError
+		def initialize(num)
+			super "Unsupported fat binary (magic 0x#{"%02x" % num})"
+		end
+	end
+
+	class CPUTypeError < MachOError
+		def initialize(num)
+			super "Unrecognized CPU type: 0x#{"%02x" % num}"
+		end
+	end
+
+	class CPUSubtypeError < MachOError
+		def initialize(num)
+			super "Unrecognized CPU sub-type: 0x#{"%02x" % num}"
+		end
+	end
+
+	# raised when a mach-o file's filetype field is unknown
+	class FiletypeError < MachOError
+		def initialize(num)
+			super "Unrecognized Mach-O filetype code: 0x#{"%02x" % num}"
+		end
+	end
+
+	# raised when an unknown load command is encountered
+	class LoadCommandError < MachOError
+		def initialize(num)
+			super "Unrecognized Mach-O load command: 0x#{"%02x" % num}"
+		end
+	end
+
+	# raised when load commands are too large to fit in the current file
+	class HeaderPadError < MachOError
+		def initialize(filename)
+			super "Updated load commands do not fit in the header of " +
+			"#{filename}. #{filename} needs to be relinked, possibly with " +
+			"-headerpad or -headerpad_max_install_names"
+		end
+	end
+end

data/lib/macho/file.rb

@@ -0,0 +1,351 @@
+module MachO
+	class MachOFile
+		attr_reader :header, :load_commands
+
+		def initialize(filename)
+			raise ArgumentError.new("filename must be a String") unless filename.is_a? String
+
+			@filename = filename
+			@raw_data = open(@filename, "rb") { |f| f.read }
+			@header = get_mach_header
+			@load_commands = get_load_commands
+		end
+
+		def magic32?
+			Utils.magic32?(header[:magic])
+		end
+
+		def magic64?
+			Utils.magic64?(header[:magic])
+		end
+
+		# is the file executable?
+		def executable?
+			header[:filetype] == MH_EXECUTE
+		end
+
+		# is the file a dynamically bound shared object?
+		def dylib?
+			header[:filetype] == MH_DYLIB
+		end
+
+		# is the file a dynamically bound bundle?
+		def bundle?
+			header[:filetype] == MH_BUNDLE
+		end
+
+		def magic
+			header[:magic]
+		end
+
+		# string representation of the header's magic bytes
+		def magic_string
+			MH_MAGICS[header[:magic]]
+		end
+
+		# string representation of the header's filetype field
+		def filetype
+			MH_FILETYPES[header[:filetype]]
+		end
+
+		# string representation of the header's cputype field
+		def cputype
+			CPU_TYPES[header[:cputype]]
+		end
+
+		# string representation of the header's cpusubtype field
+		def cpusubtype
+			CPU_SUBTYPES[header[:cpusubtype]]
+		end
+
+		# number of load commands in the header
+		def ncmds
+			header[:ncmds]
+		end
+
+		# size of all load commands
+		def sizeofcmds
+			header[:sizeofcmds]
+		end
+
+		# various execution flags
+		def flags
+			header[:flags]
+		end
+
+		# get load commands by name
+		def command(name)
+			load_commands.select { |lc| lc.to_s == name }
+		end
+
+		alias :[] :command
+
+		# get all segment commands
+		def segments
+			if magic32?
+				command("LC_SEGMENT")
+			else
+				command("LC_SEGMENT_64")
+			end
+		end
+
+		# get the file's dylib id, if it is a dylib
+		def dylib_id
+			if !dylib?
+				return nil
+			end
+
+			dylib_id_cmd = command('LC_ID_DYLIB').first
+
+			cmdsize = dylib_id_cmd.cmdsize
+			offset = dylib_id_cmd.offset
+			stroffset = dylib_id_cmd.name
+
+			dylib_id = @raw_data.slice(offset + stroffset...offset + cmdsize).unpack("Z*").first
+
+			dylib_id
+		end
+
+		def dylib_id=(new_id)
+			if !new_id.is_a?(String)
+				raise ArgumentError.new("argument must be a String")
+			end
+
+			if !dylib?
+				return nil
+			end
+
+			if magic32?
+				cmd_round = 4
+			else
+				cmd_round = 8
+			end
+
+			new_sizeofcmds = header[:sizeofcmds]
+			dylib_id_cmd = command('LC_ID_DYLIB').first
+			old_id = dylib_id
+
+			new_pad = Utils.round(new_id.size, cmd_round) - new_id.size
+			old_pad = Utils.round(old_id.size, cmd_round) - old_id.size
+
+			# pad the old and new IDs with null bytes to meet command bounds
+			old_id << "\x00" * old_pad
+			new_id << "\x00" * new_pad
+
+			# calculate the new size of the DylibCommand and sizeofcmds in MH
+			new_size = DylibCommand.bytesize + new_id.size
+			new_sizeofcmds += new_size - dylib_id_cmd.cmdsize
+
+			# calculate the low file offset (offset to first section data)
+			low_fileoff = 2**64 # ULLONGMAX
+
+			segments.each do |seg|
+				sections(seg).each do |sect|
+					if sect.size != 0 && !sect.flag?(S_ZEROFILL) &&
+							!sect.flag?(S_THREAD_LOCAL_ZEROFILL) &&
+							sect.offset < low_fileoff
+
+						low_fileoff = sect.offset
+					end
+				end
+			end
+
+			if new_sizeofcmds + header.bytesize > low_fileoff
+				raise HeaderPadError.new(@filename)
+			end
+
+			# update sizeofcmds in mach_header
+			set_sizeofcmds(new_sizeofcmds)
+
+			# update cmdsize in the dylib_command
+			@raw_data[dylib_id_cmd.offset + 4, 4] = [new_size].pack("V")
+
+			# delete the old id
+			@raw_data.slice!(dylib_id_cmd.offset + dylib_id_cmd.name...dylib_id_cmd.offset + dylib_id_cmd.cmdsize)
+
+			# insert the new id
+			@raw_data.insert(dylib_id_cmd.offset + dylib_id_cmd.name, new_id)
+
+			# pad/unpad after new_sizeofcmds until offsets are corrected
+			null_pad = old_id.size - new_id.size
+
+			if null_pad < 0
+				@raw_data.slice!(new_sizeofcmds + header.bytesize, null_pad.abs)
+			else
+				@raw_data.insert(new_sizeofcmds + header.bytesize, "\x00" * null_pad)
+			end
+
+			# synchronize fields with the raw data
+			header = get_mach_header
+			load_commands = get_load_commands
+		end
+
+		# get a list of dylib paths linked to this file
+		def linked_dylibs
+			dylibs = []
+			dylib_cmds = command('LC_LOAD_DYLIB')
+
+			dylib_cmds.each do |dylib_cmd|
+				cmdsize = dylib_cmd.cmdsize
+				offset = dylib_cmd.offset
+				stroffset = dylib_cmd.name
+
+				dylib = @raw_data.slice(offset + stroffset...offset + cmdsize).unpack("Z*").first
+
+				dylibs << dylib
+			end
+
+			dylibs
+		end
+
+		# get all sections in a segment by name
+		def sections(segment)
+			sections = []
+
+			if !segment.is_a?(SegmentCommand) && !segment.is_a?(SegmentCommand64)
+				raise ArgumentError.new("not a valid segment")
+			end
+
+			if segment.nsects.zero?
+				return sections
+			end
+
+			offset = segment.offset + segment.class.bytesize
+
+			segment.nsects.times do
+				if segment.is_a? SegmentCommand
+					sections << Section.new_from_bin(@raw_data.slice(offset, Section.bytesize))
+					offset += Section.bytesize
+				else
+					sections << Section64.new_from_bin(@raw_data.slice(offset, Section64.bytesize))
+					offset += Section64.bytesize
+				end
+			end
+
+			sections
+		end
+
+		def write(filename)
+			File.open(filename, "wb") { |f| f.write(@raw_data) }
+		end
+
+		def write!
+			File.open(@filename, "wb") { |f| f.write(@raw_data) }
+		end
+
+		#######
+		private
+
+		def get_mach_header
+			magic = get_magic
+			cputype = get_cputype
+			cpusubtype = get_cpusubtype
+			filetype = get_filetype
+			ncmds = get_ncmds
+			sizeofcmds = get_sizeofcmds
+			flags = get_flags
+			
+			if Utils.magic32?(magic)
+				header = MachHeader.new(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags)
+			else
+				# the reserved field is reserved, so just fill it with 0
+				header = MachHeader64.new(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags, 0)
+			end
+		end
+
+		def get_magic
+			magic = @raw_data[0..3].unpack("N").first
+
+			if !Utils.magic?(magic)
+				raise MagicError.new(magic)
+			end
+			
+			# TODO: support fat (universal) binaries
+			if Utils.fat_magic?(magic)
+				raise FatBinaryError.new(magic)
+			end
+
+			magic
+		end
+
+		def get_cputype
+			cputype = @raw_data[4..7].unpack("V").first
+
+			if !CPU_TYPES.keys.include?(cputype)
+				raise CPUTypeError.new(cputype)
+			end
+
+			cputype
+		end
+
+		def get_cpusubtype
+			cpusubtype = @raw_data[8..11].unpack("V").first
+
+			# this mask isn't documented!
+			cpusubtype &= ~CPU_SUBTYPE_LIB64
+
+			if !CPU_SUBTYPES.keys.include?(cpusubtype)
+				raise CPUSubtypeError.new(cpusubtype)
+			end
+
+			cpusubtype
+		end
+
+		def get_filetype
+			filetype = @raw_data[12..15].unpack("V").first
+
+			if !MH_FILETYPES.keys.include?(filetype)
+				raise FiletypeError.new(filetype)
+			end
+
+			filetype
+		end
+
+		def get_ncmds
+			ncmds = @raw_data[16..19].unpack("V").first
+
+			ncmds
+		end
+
+		def get_sizeofcmds
+			sizeofcmds = @raw_data[20..23].unpack("V").first
+
+			sizeofcmds
+		end
+
+		# TODO: parse flags, maybe?
+		def get_flags
+			flags = @raw_data[24..27].unpack("V").first
+
+			flags
+		end
+
+		def get_load_commands
+			offset = header.bytesize
+			load_commands = []
+
+			header[:ncmds].times do
+				cmd = @raw_data.slice(offset, 4).unpack("V").first
+
+				if !LC_STRUCTURES.has_key?(cmd)
+					raise LoadCommandError.new(cmd)
+				end
+
+				# why do I do this? i don't like declaring constants below
+				# classes, and i need them to resolve...
+				klass = Object.const_get "MachO::#{LC_STRUCTURES[cmd]}"
+				command = klass.new_from_bin(offset, @raw_data.slice(offset, klass.bytesize))
+
+				load_commands << command
+				offset += command.cmdsize
+			end
+
+			load_commands
+		end
+
+		def set_sizeofcmds(size)
+			new_size = [size].pack("V")
+			@raw_data[20..23] = new_size
+		end
+	end
+end