resilience 0.0.2 → 0.1.1

data/lib/resilience/constants.rb

@@ -2,9 +2,9 @@
 # ReFS Constants
 # Copyright (C) 2015 Red Hat Inc.
 
-FIRST_PAGE_ID =  0x1e
+FS_SIGNATURE  = [0x00, 0x00, 0x00, 0x52, 0x65, 0x46, 0x53, 0x00] # ...ReFS.
+
 PAGE_SIZE     =  0x4000
-FIRST_PAGE_ADDRESS = FIRST_PAGE_ID * PAGE_SIZE
 
 ROOT_DIR_ID   = [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0]
 DIR_ENTRY     = 0x20030
@@ -14,19 +14,43 @@ DIR_TREE      = 0x301
 DIR_LIST      = 0x200
 #DIR_BRANCH    = 0x000 ?
 
+PAGES = {
+  # page id's:
+  :first        => 0x1e,
+
+  # virtual page numbers:
+  :root         => 0x00,
+  :object_table => 0x02,
+  :object_tree  => 0x03
+}
+
 ADDRESSES  = {
+  # size / bounds
+  :bytes_per_sector    => 0x20,
+  :sectors_per_cluster => 0x24,
+
   # page
+  :page_sequence       => 0x08, # shadow pages share the same virtual page number
   :virtual_page_number => 0x18,
   :first_attr          => 0x30,
 
-  # page 0x1e
+  # on page 0x1e:
   :system_table_page   => 0xA0,
 
-  # system table
+  # on system table:
   :system_pages        => 0x58,
 
-  # generic table
-  :num_objects         => 0x20, # referenced from start of first attr
+  # generic table:
+  # referenced from start of first attr
+  :object_id           => 0x0C,
+  :num_objects         => 0x20,
+
+  # referenced from start of table header
+  :table_length        => 0x04,
 
-  :table_length        => 0x04  # referenced from start of table header
+  # object tree:
+  :object_tree_start1 => 0x10,
+  :object_tree_end1   => 0x1F,
+  :object_tree_start2 => 0x20,
+  :object_tree_end2   => 0x2F
 }

data/lib/resilience/core_ext.rb

@@ -0,0 +1,39 @@
+# Resilience Core Ruby Extensions
+#
+# Licensed under the MIT license
+# Copyright (C) 2015 Red Hat, Inc.
+
+class String
+  def indented(places=1)
+    rjust(places, '0').upcase
+  end
+end
+
+class Fixnum
+  def indented(places=1)
+    '0x' + to_s(16).rjust(places, '0').upcase
+  end
+
+  def big_endian_str
+    [self].big_endian_str
+  end
+end
+
+class NilClass
+  def indented(places=1)
+    '0x' + ('0' * places)
+  end
+end
+
+class Array
+  def big_endian_str
+    str = '0x'
+    value = false
+    reverse_each { |b|
+      next if b == 0 && !value
+      value = true
+      str += b.to_s(16)
+    }
+    str
+  end
+end

data/lib/resilience/fs_dir.rb

@@ -4,3 +4,6 @@
 
 require 'resilience/fs_dir/dir_base'
 require 'resilience/fs_dir/record'
+
+require 'resilience/fs_dir/dir_entry'
+require 'resilience/fs_dir/file_entry'

data/lib/resilience/fs_dir/dir_base.rb

@@ -3,6 +3,8 @@
 # Copyright (C) 2014-2015 Red Hat Inc.
 
 require 'fileutils'
+require 'resilience/collections/dirs'
+require 'resilience/collections/files'
 
 module Resilience
   module FSDir
@@ -14,8 +16,8 @@ module Resilience
 
       def parse_dir_obj(object_id, prefix)
         object_table   = image.object_table
-        @dirs        ||= {}
-        @files       ||= {}
+        @dirs        ||= Dirs.new
+        @files       ||= Files.new
       
         page_id      = object_table.pages[object_id]
         page_address = page_id * PAGE_SIZE
@@ -90,15 +92,23 @@ module Resilience
         if entry_type == DIR_ENTRY
           dir_name = key_bytes[4..-1].pack('L*')
           dir_obj = value.unpack('C*')[0...8]
-          dirs["#{prefix}\\#{dir_name}"] = dir_obj
+          dirs << DirEntry.new(:prefix   => prefix,
+                               :name     => dir_name,
+                               :metadata => dir_obj,
+                               :record   => record)
 
           dir_obj = [0, 0, 0, 0, 0, 0, 0, 0].concat(dir_obj)
           parse_dir_obj(dir_obj, "#{prefix}\\#{dir_name}")
       
         elsif entry_type == FILE_ENTRY
-          file_name = key_bytes[4..-1].pack('L*')
-          prefixed  = "#{prefix}\\#{file_name}"
-          files[prefixed] = value
+          filename = key_bytes[4..-1]
+          filename.delete(0)
+          filename = filename.pack('C*')
+
+          files <<  FileEntry.new(:prefix   => prefix,
+                                  :name     => filename,
+                                  :metadata => value,
+                                  :record   => record)
         end
       end
     end # class DirBase

data/lib/resilience/fs_dir/dir_entry.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/ruby
+# ReFS Directory Dir Entry
+# Copyright (C) 2014-2015 Red Hat Inc.
+
+require 'fileutils'
+
+module Resilience
+  module FSDir
+    class DirEntry
+      attr_accessor :prefix
+      attr_accessor :name
+      attr_accessor :metadata
+
+      # metadata record
+      attr_accessor :record
+
+      def initialize(args={})
+        @prefix   = args[:prefix]
+        @name     = args[:name]
+        @metadata = args[:metadata]
+        @record   = args[:record]
+      end
+
+      def fullname
+        "#{prefix}\\#{name}"
+      end
+
+      def disk_offset
+        image.offset + dir.record.attribute.pos
+      end
+    end # class DirEntry
+  end # module FSDir
+end # module Resilience

data/lib/resilience/fs_dir/file_entry.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/ruby
+# ReFS Directory File Entry
+# Copyright (C) 2014-2015 Red Hat Inc.
+
+require 'fileutils'
+
+module Resilience
+  module FSDir
+    class FileEntry
+      attr_accessor :prefix
+      attr_accessor :name
+      attr_accessor :metadata
+
+      # metadata record
+      attr_accessor :record
+
+      # known metadata attributes
+      attr_accessor :metadata_attrs
+
+      def initialize(args={})
+        @prefix   = args[:prefix]
+        @name     = args[:name]
+        @metadata = args[:metadata]
+        @record   = args[:record]
+        parse_attrs
+      end
+
+      def fullname
+        "#{prefix}\\#{name}"
+      end
+
+      def total_offset
+        image.offset + record.attribute.pos
+      end
+
+      def parse_attrs
+        metadata_bytes  = @metadata.unpack('C*')
+        metadata_dwords = @metadata.unpack('L*')
+        attr1_length    = metadata_dwords[0]
+        attr1_dwords    = attr1_length/4
+        attr2_length    = metadata_dwords[attr1_dwords]
+        attr2_dwords    = attr2_length/4
+        attr3_length    = metadata_dwords[attr1_dwords + attr2_dwords]
+        # there may be other attrs after this point...
+
+        attr1 = metadata_bytes[0..attr1_length]
+        attr2 = metadata_bytes[attr1_length..attr1_length+attr2_length]
+        attr3 = metadata_bytes[attr1_length+attr2_length..attr1_length+attr2_length+attr3_length]
+        @metadata_attrs = [attr1, attr2, attr3]
+      end
+    end # class FileEntry
+  end # module FSDir
+end # module Resilience

data/lib/resilience/image.rb

@@ -4,22 +4,41 @@
 
 module Resilience
   class Image
+    include Conf
+
     attr_accessor :file
     attr_accessor :offset
     attr_accessor :opts
 
+    attr_accessor :bytes_per_sector
+    attr_accessor :sectors_per_cluster
+
+    def cluster_size
+      @cluster_size ||= bytes_per_sector * sectors_per_cluster
+    end
+
     attr_accessor :root_dir
     attr_accessor :system_table
     attr_accessor :object_table
+    attr_accessor :object_tree
+
+    # all pages including shadow pages
+    attr_accessor :pages
 
     def initialize(args={})
       @file         = args[:file] || []
     end
 
     def parse
+      parse_bounds
+
+      # each of these is a seperate parsing process,
+      # though later ones may depend on former
+      @pages        = Resilience::Page.extract_all  if conf.pages?
       @system_table = Resilience::SystemTable.parse
       @object_table = Resilience::ObjectTable.parse
       @root_dir     = Resilience::RootDir.parse
+      @object_tree  = Resilience::ObjectTree.parse  if conf.object_tree?
     end
 
     def seek(position)
@@ -30,8 +49,22 @@ module Resilience
       @file.pos - offset
     end
 
+    def total_pos
+      @file.pos
+    end
+
     def read(len)
       @file.read(len)
     end
+
+    private
+
+    def parse_bounds
+      seek(ADDRESSES[:bytes_per_sector])
+      @bytes_per_sector = read(4).unpack('L').first
+
+      seek(ADDRESSES[:sectors_per_cluster])
+      @sectors_per_cluster = read(4).unpack('L').first
+    end
   end
 end # module Resilience

data/lib/resilience/mixins/on_image.rb

@@ -12,14 +12,39 @@ module Resilience
       @image ||= Resilience::Image.new
     end
 
+    def self.store_pos
+      @image_pos ||= []
+      @image_pos.unshift image.pos
+    end
+
+    def self.restore_pos
+      image.seek @image_pos.shift
+    end
+
     def image
       OnImage.image
     end
 
+    def store_pos
+      OnImage.store_pos
+    end
+
+    def restore_pos
+      OnImage.restore_pos
+    end
+
     module ClassMethods
       def image
         OnImage.image
       end
+
+      def store_pos
+        OnImage.store_pos
+      end
+
+      def restore_pos
+        OnImage.restore_pos
+      end
     end
   end # module OnImage
 end # module Resilience

data/lib/resilience/page.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/ruby
+# ReFS Page Representation
+# Copyright (C) 2015 Red Hat Inc.
+
+require 'resilience/collections/pages'
+
+module Resilience
+  class Page
+    include OnImage
+
+    attr_accessor :id
+    attr_accessor :contents
+
+    attr_accessor :sequence
+    attr_accessor :virtual_page_number
+
+    attr_accessor :attributes
+
+    attr_accessor :object_id
+    attr_accessor :entries
+
+    def initialize
+      @attributes ||= []
+    end
+
+    def self.extract_all
+      page_id     = PAGES[:first]
+      pages       = Pages.new
+
+      image.seek(page_id * PAGE_SIZE)
+      while contents = image.read(PAGE_SIZE)
+        # only pull out metadata pages currently
+        extracted_id   = id_from_contents(contents)
+        is_metadata    = extracted_id == page_id
+        pages[page_id] = Page.parse(page_id, contents) if is_metadata
+        page_id       += 1
+      end
+
+      pages
+    end
+
+    def self.id_from_contents(contents)
+      contents.unpack('S').first
+    end
+
+    def offset
+      id * PAGE_SIZE
+    end
+
+    def attr_start
+      offset + ADDRESSES[:first_attr]
+    end
+
+    def root?
+      virtual_page_number == PAGES[:root]
+    end
+
+    def object_table?
+      virtual_page_number == PAGES[:object_table]
+    end
+
+    def self.parse(id, contents)
+      store_pos
+
+      page          = new
+      page.id       = id
+      page.contents = contents
+
+      image.seek(page.offset + ADDRESSES[:page_sequence])
+      page.sequence = image.read(4).unpack('L').first
+
+      image.seek(page.offset + ADDRESSES[:virtual_page_number])
+      page.virtual_page_number = image.read(4).unpack('L').first
+
+      unless page.root? || page.object_table?
+        # TODO:
+        #page.parse_attributes
+        #page.parse_metadata
+      end
+
+      restore_pos
+
+      page
+    end
+
+    def has_attributes?
+      !@attributes.nil? && !@attributes.empty?
+    end
+
+    def parse_attributes
+      image.seek(attr_start)
+      while true
+        attr = Attribute.read
+        break if attr.empty?
+        @attributes << attr
+      end
+    end
+
+    def parse_metadata
+      @object_id = @attributes.first.unpack("C*")[ADDRESSES[:object_id]]
+      @entries   = @attributes.first.unpack("C*")[ADDRESSES[:num_objects]]
+    end
+  end # class Page
+end # module Resilience