Added :endian option to MachOStructure#field

Now instead of having types that dictated endianness
like :uint32_net endianness is just an option passed
to the field method.

Ex. field name, :uint64, :endian => :big

I also moved the utils.rb file to the top of the
includes in the macho.rb file to access
Utils#specialize_format in the #field method.

I also changed the :bin_string field type to
:binary to make it more succinct.

Author: apainintheneck

lib/macho.rb

@@ -2,6 +2,7 @@
 
 require "open3"
 
+require_relative "macho/utils"
 require_relative "macho/structure"
 require_relative "macho/view"
 require_relative "macho/headers"
@@ -10,7 +11,6 @@
 require_relative "macho/macho_file"
 require_relative "macho/fat_file"
 require_relative "macho/exceptions"
-require_relative "macho/utils"
 require_relative "macho/tools"
 
 # The primary namespace for ruby-macho.

lib/macho/headers.rb

@@ -505,10 +505,10 @@ module Headers
     # @see MachO::FatArch
     class FatHeader < MachOStructure
       # @return [Integer] the magic number of the header (and file)
-      field :magic, :uint32_net
+      field :magic, :uint32, :endian => :big
 
       # @return [Integer] the number of fat architecture structures following the header
-      field :nfat_arch, :uint32_net
+      field :nfat_arch, :uint32, :endian => :big
 
       # @return [String] the serialized fields of the fat header
       def serialize
@@ -532,19 +532,19 @@ def to_h
     # @see MachO::Headers::FatHeader
     class FatArch < MachOStructure
       # @return [Integer] the CPU type of the Mach-O
-      field :cputype, :uint32_net
+      field :cputype, :uint32, :endian => :big
 
       # @return [Integer] the CPU subtype of the Mach-O
-      field :cpusubtype, :uint32_net, :mask => CPU_SUBTYPE_MASK
+      field :cpusubtype, :uint32, :endian => :big, :mask => CPU_SUBTYPE_MASK
 
       # @return [Integer] the file offset to the beginning of the Mach-O data
-      field :offset, :uint32_net
+      field :offset, :uint32, :endian => :big
 
       # @return [Integer] the size, in bytes, of the Mach-O data
-      field :size, :uint32_net
+      field :size, :uint32, :endian => :big
 
       # @return [Integer] the alignment, as a power of 2
-      field :align, :uint32_net
+      field :align, :uint32, :endian => :big
 
       # @return [String] the serialized fields of the fat arch
       def serialize
@@ -572,13 +572,13 @@ def to_h
     # @see MachO::Headers::FatHeader
     class FatArch64 < FatArch
       # @return [Integer] the file offset to the beginning of the Mach-O data
-      field :offset, :uint64_net
+      field :offset, :uint64, :endian => :big
 
       # @return [Integer] the size, in bytes, of the Mach-O data
-      field :size, :uint64_net
+      field :size, :uint64, :endian => :big
 
       # @return [void]
-      field :reserved, :uint32_net, :default => 0
+      field :reserved, :uint32, :endian => :big, :default => 0
 
       # @return [String] the serialized fields of the fat arch
       def serialize
@@ -733,31 +733,31 @@ def to_h
     # Prelinked kernel/"kernelcache" header structure
     class PrelinkedKernelHeader < MachOStructure
       # @return [Integer] the magic number for a compressed header ({COMPRESSED_MAGIC})
-      field :signature, :uint32_net
+      field :signature, :uint32, :endian => :big
 
       # @return [Integer] the type of compression used
-      field :compress_type, :uint32_net
+      field :compress_type, :uint32, :endian => :big
 
       # @return [Integer] a checksum for the uncompressed data
-      field :adler32, :uint32_net
+      field :adler32, :uint32, :endian => :big
 
       # @return [Integer] the size of the uncompressed data, in bytes
-      field :uncompressed_size, :uint32_net
+      field :uncompressed_size, :uint32, :endian => :big
 
       # @return [Integer] the size of the compressed data, in bytes
-      field :compressed_size, :uint32_net
+      field :compressed_size, :uint32, :endian => :big
 
       # @return [Integer] the version of the prelink format
-      field :prelink_version, :uint32_net
+      field :prelink_version, :uint32, :endian => :big
 
       # @return [void]
-      field :reserved, :bin_string, :size => 40, :unpack => "L>10"
+      field :reserved, :binary, :size => 40, :unpack => "L>10"
 
       # @return [void]
-      field :platform_name, :bin_string, :size => 64
+      field :platform_name, :binary, :size => 64
 
       # @return [void]
-      field :root_path, :bin_string, :size => 256
+      field :root_path, :binary, :size => 256
 
       # @return [Boolean] whether this prelinked kernel supports KASLR
       def kaslr?

lib/macho/load_commands.rb

@@ -367,7 +367,7 @@ def initialize(endianness, alignment)
     # LC_UUID.
     class UUIDCommand < LoadCommand
       # @return [Array<Integer>] the UUID
-      field :uuid, :bin_string, :size => 16, :unpack => "C16"
+      field :uuid, :binary, :size => 16, :unpack => "C16"
 
       # @return [String] a string representation of the UUID
       def uuid_string

lib/macho/structure.rb

@@ -15,13 +15,11 @@ module Fields
       # @api private
       BYTE_SIZE = {
         # Binary slices
-        :bin_string => nil,
+        :binary => nil,
         :string => nil,
         :int32 => 4,
         :uint32 => 4,
-        :uint32_net => 4,
         :uint64 => 8,
-        :uint64_net => 8,
         # Classes
         :view => 0,
         :lcstr => 4,
@@ -38,13 +36,11 @@ module Fields
       # @api private
       FORMAT_CODE = {
         # Binary slices
-        :bin_string => "a",
+        :binary => "a",
         :string => "Z",
         :int32 => "l=",
         :uint32 => "L=",
-        :uint32_net => "L>", # Same as N
         :uint64 => "Q=",
-        :uint64_net => "Q>",
         # Classes
         :view => "",
         :lcstr => "L=",
@@ -137,10 +133,12 @@ def inherited(subclass) # rubocop:disable Lint/MissingSuper
       #   :unpack [String] string format
       #   :default [Value] default value
       #   :to_s [Boolean] flag for generating #to_s
+      #   :endian [Symbol] optionally specify :big or :little endian
       # @api private
       def field(name, type, **options)
         raise ArgumentError, "Invalid field type #{type}" unless Fields::FORMAT_CODE.key?(type)
 
+        # Get field idx for size_list and fmt_list
         idx = if @field_idxs.key?(name)
           @field_idxs[name]
         else
@@ -151,8 +149,13 @@ def field(name, type, **options)
           @field_idxs.size - 1
         end
 
+        # Add to size_list and fmt_list
         @size_list[idx] = Fields::BYTE_SIZE[type] || options[:size]
-        @fmt_list[idx] = Fields::FORMAT_CODE[type]
+        @fmt_list[idx] = if options[:endian]
+          Utils.specialize_format(Fields::FORMAT_CODE[type], options[:endian])
+        else
+          Fields::FORMAT_CODE[type]
+        end
         @fmt_list[idx] += options[:size].to_s if options.key?(:size)
 
         # Generate methods