virt_disk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 78ec73c22b2c23d9ba2b2e92c673e81017de439a
+  data.tar.gz: 025ee06aa5d102e2f0bcc1c2b27ea419fd4b63d3
+SHA512:
+  metadata.gz: e302b6b3a6d75bba33696d2e246db31516cf4be131ae0959b0f3bdedf55c3b54454834f705daca9973cf3f116d5b30b0fcbae06c6549c82f1fc3039cc95db1ea
+  data.tar.gz: 628a7c6ead32e9b48d37c908992d0347913f75b3c2e20c5cc82e4d619fc242894910394bafb19bc3ba099b335e71f383dcca649825b32501c0320cb8c98a35a1

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.14.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in virtfs.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 ManageIQ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1 @@
+# virt_disk

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+Dir.glob('tasks/**/*.rake').each(&method(:import))
+
+task :test => :spec
+task :default => :spec

data/lib/virt_disk.rb

@@ -0,0 +1,9 @@
+require 'log_decorator'
+require 'virt_disk/export_methods'
+require 'virt_disk/client_head'
+require 'virt_disk/disk'
+require 'virt_disk/partition'
+require 'virt_disk/partition_type'
+require 'virt_disk/partition_type/dos_partition'
+require 'virt_disk/partition_type/gpt_partition'
+require 'virt_disk/file_io'

data/lib/virt_disk/block_file.rb

@@ -0,0 +1,32 @@
+module VirtDisk
+  class BlockFile
+    attr_accessor :path
+
+    def initialize(path)
+      @path = path
+      @file = defined?(VirtFS) ? VirtFS::VFile.open(path) : File.open(path)
+    end
+
+    def block_size
+      1
+    end
+
+    def size
+      @file.size
+    end
+
+    def close
+      @file.close
+    end
+
+    def raw_read(start, len)
+      @file.seek start
+      @file.read len
+    end
+
+    def raw_write(buf, start, len)
+      @file.seek start
+      @file.write buf, len
+    end
+  end # class BlockFile
+end # module VirtDisk

data/lib/virt_disk/client_head.rb

@@ -0,0 +1,56 @@
+module VirtDisk
+  class ClientHead
+    attr_reader :size, :start_byte_addr, :end_byte_addr, :seek_pos
+
+    include ExportMethods
+
+    def initialize(up_stream_module)
+      @up_stream_module = up_stream_module
+      @start_byte_addr  = 0
+      @size             = @up_stream_module.size
+      @end_byte_addr    = @size - 1
+      @seek_pos         = @start_byte_addr
+      self.delegate     = @up_stream_module
+    end
+
+    def close
+      @up_stream_module.close
+    end
+
+    def seek_pos
+      @seek_pos - @start_byte_addr
+    end
+
+    def seek(amt, whence = IO::SEEK_SET)
+      case whence
+      when IO::SEEK_CUR
+        @seek_pos += amt
+      when IO::SEEK_END
+        @seek_pos = @endByteAddr + amt
+      when IO::SEEK_SET
+        @seek_pos = amt + @start_byte_addr
+      end
+      @seek_pos
+    end
+
+    def read(len)
+      rb = mod_read(@seek_pos, len)
+      @seek_pos += rb.length unless rb.nil?
+      rb
+    end
+
+    def write(buf, len)
+      nbytes = @up_stream_module.mod_write(@seek_pos, buf, len)
+      @seek_pos += nbytes
+      nbytes
+    end
+
+    def mod_read(offset, len)
+      @up_stream_module.mod_read(offset, len)
+    end
+
+    def mod_write(offset, buffer, len)
+      @up_stream_module.mod_write(offset, buffer, len)
+    end
+  end
+end

data/lib/virt_disk/disk.rb

@@ -0,0 +1,21 @@
+module VirtDisk
+  class Disk < ClientHead
+    DEFAULT_BLOCK_SIZE = 512
+    DISK_SIG_OFFSET    = 0x1B8
+    DISK_SIG_SIZE      = 4
+
+    def initialize(up_stream_module)
+      super
+    end
+
+    def block_size
+      return @up_stream_module.block_size if @up_stream_module.respond_to?(:block_size)
+      DEFAULT_BLOCK_SIZE
+    end
+    export :block_size
+
+    def disk_sig
+      @disk_sig ||= @up_stream_module.mod_read(DISK_SIG_OFFSET, DISK_SIG_SIZE).unpack('L')[0]
+    end
+  end
+end

data/lib/virt_disk/disk_unicode.rb

@@ -0,0 +1,43 @@
+class String
+  # See Programming Ruby 1.9 - The Pragmatic Programmers’ Guide
+  # Figure 17.1. "Encodings and Their Aliases" in the for available encodings.
+  def UnicodeToUtf8
+    dup.force_encoding("UTF-16LE").encode("UTF-8")
+  end
+
+  def UnicodeToUtf8!
+    force_encoding("UTF-16LE").encode!("UTF-8")
+  end
+
+  def Utf8ToUnicode
+    dup.force_encoding("UTF-8").encode("UTF-16LE")
+  end
+
+  def Utf8ToUnicode!
+    force_encoding("UTF-8").encode!("UTF-16LE")
+  end
+
+  def AsciiToUtf8
+    dup.force_encoding("ISO-8859-1").encode("UTF-8")
+  end
+
+  def AsciiToUtf8!
+    force_encoding("ISO-8859-1").encode!("UTF-8")
+  end
+
+  def Utf8ToAscii
+    dup.force_encoding("UTF-8").encode("ISO-8859-1")
+  end
+
+  def Utf8ToAscii!
+    force_encoding("UTF-8").encode!("ISO-8859-1")
+  end
+
+  def Ucs2ToAscii
+    dup.force_encoding("UTF-16LE").encode("ISO-8859-1")
+  end
+
+  def Ucs2ToAscii!
+    force_encoding("UTF-16LE").encode!("ISO-8859-1")
+  end
+end

data/lib/virt_disk/disk_uuid.rb

@@ -0,0 +1,22 @@
+require 'uuidtools'
+
+module DiskUUID
+  REGEX_FORMAT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+
+  def self.clean_guid(guid)
+    return nil if guid.nil?
+    g = guid.to_s.downcase
+    return nil if g.strip.empty?
+    return g if g.length == 36 && g =~ REGEX_FORMAT
+    g.delete!('^0-9a-f')
+    g.sub!(/^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/, '\1-\2-\3-\4-\5')
+  end
+
+  def self.new_guid
+    UUIDTools::UUID.timestamp_create.to_s
+  end
+
+  def self.method_missing(m, *args)
+    UUIDTools::UUID.send(m, *args)
+  end
+end

data/lib/virt_disk/export_methods.rb

@@ -0,0 +1,74 @@
+module VirtDisk
+  # Utility module used by VirtDisk plug-ins, allowing them to export methods upstream.
+  #
+  # Typically, VirtDisk plug-ins are linked in a chain - each plug-in communicating with
+  # the plug-in immediately upstream from it (where upstream is closer to the source of the data).
+  # The last downstream plug-in (the volume head) is the object accessed directly by the client.
+  #
+  # This module enables upstream plug-ins to export methods, so they can be called directly
+  # from the volume head.
+  #
+  # @note Every plug-in class must include this module, even if they don't export any methods.
+  module ExportMethods
+    module ClassMethods
+      # Export one or more methods, making them callable from the volume head.
+      #
+      # @param syms [Symbol] the names of one or more methods to be exported.
+      # @raise [RuntimeError] if any of the methods aren't defined in the class.
+      def export(*syms)
+        syms.each do |s|
+          sym = s.to_sym
+          raise "Method not defined in class: #{sym}" unless method_defined?(sym)
+          return nil if exports.include?(sym)
+          exports << sym
+        end
+        nil
+      end
+
+      # @return [Array<Symbol>] array of exported methods.
+      def exports
+        @__exported_methods ||= []
+      end
+
+      # @param sym [Symbol]
+      # @return [Boolean] - true if sym is exported by this class, false otherwise.
+      def exported?(sym)
+        exports.include?(sym.to_sym)
+      end
+    end
+
+    def self.included(host_class)
+      host_class.extend(ClassMethods)
+    end
+
+    # Set the module immediately upstream from this one.
+    #
+    # @param obj [Object] the upstream module.
+    def delegate=(obj)
+      @__delegate = obj
+    end
+
+    # The module immediately upstream from this one.
+    #
+    # @return [Object] the module immediately upstream from this one.
+    def delegate
+      @__delegate
+    end
+
+    # @param sym [Symbol]
+    # @return [Boolean] - true if sym is exported by this module's class, false otherwise.
+    def exported?(sym)
+      self.class.exported?(sym)
+    end
+
+    def respond_to_missing?(sym, include_all = false)
+      return false unless @__delegate
+      @__delegate.exported?(sym) || @__delegate.send(:respond_to_missing?, sym, include_all)
+    end
+
+    def method_missing(sym, *args)
+      super unless respond_to_missing?(sym)
+      @__delegate.send(sym, *args)
+    end
+  end
+end

data/lib/virt_disk/file_io.rb

@@ -0,0 +1,42 @@
+module VirtDisk
+  class FileIo
+    attr_accessor :path
+    alias_method :file_name, :path
+
+    include LogDecorator::Logging
+    include ExportMethods
+
+    export :path, :file_name
+
+    def initialize(path, *args)
+      @path      = path
+      @file_lock = Mutex.new
+
+      _log.debug "Opening file - #{path}"
+      @file = File.open(path, *args)
+    end
+
+    def size
+      @file.size
+    end
+    export :size
+
+    def close
+      @file.close
+    end
+
+    def mod_read(start, len)
+      @file_lock.synchronize do
+        @file.seek start
+        @file.read len
+      end
+    end
+
+    def mod_write(buf, start, len)
+      @file_lock.synchronize do
+        @file.seek start
+        @file.write buf, len
+      end
+    end
+  end
+end

data/lib/virt_disk/partition.rb

@@ -0,0 +1,39 @@
+require "binary_struct"
+
+module VirtDisk
+  class Partition < ClientHead
+    attr_reader :start_lba, :end_lba, :ptype, :pnum
+
+    MBR_SIZE = 512
+    DOS_SIG  = "55aa"
+    GPT_SIG  = 238
+
+    DOS_PARTITION_ENTRY = BinaryStruct.new([
+      'C', :bootable,
+      'C', :startCHS0,
+      'C', :startCHS1,
+      'C', :startCHS2,
+      'C', :ptype,
+      'C', :endCHS0,
+      'C', :endCHS1,
+      'C', :endCHS1,
+      'L', :start_lba,
+      'L', :part_size
+    ])
+    PTE_LEN      = DOS_PARTITION_ENTRY.size
+    DOS_PT_START = 446
+
+    def initialize(disk, ptype, pnum, start_lba, end_lba)
+      super(disk)
+
+      @start_lba        = start_lba
+      @end_lba          = end_lba
+      @ptype            = ptype
+      @pnum             = pnum
+      @start_byte_addr  = @start_lba * block_size
+      @end_byte_addr    = @end_lba * block_size
+      @seek_pos         = @start_byte_addr
+      @size             = @end_byte_addr - @start_byte_addr
+    end
+  end
+end

data/lib/virt_disk/partition_type.rb

@@ -0,0 +1,16 @@
+module VirtDisk
+  module PartitionType
+    def self.partition_probe(disk)
+      partition_types.each do |partition_type|
+        partitions = partition_type.discover_partitions(disk)
+        return partitions unless partitions.empty?
+      end
+      []
+    end
+
+    def self.partition_types
+      constants.collect { |sym| const_get(sym) }
+        .find_all { |obj| obj.is_a?(Class) && obj.respond_to?(:discover_partitions) }
+    end
+  end
+end

data/lib/virt_disk/partition_type/dos_partition.rb

@@ -0,0 +1,113 @@
+module VirtDisk
+  module PartitionType
+    class DosPartition < Partition
+      DOS_NPTE      = 4
+      PTYPE_EXT_CHS = 0x05
+      PTYPE_EXT_LBA = 0x0f
+      PTYPE_LDM     = 0x42
+
+      include LogDecorator::Logging
+      include ExportMethods
+
+      def initialize(disk, ptype, pnum, start_lba, size_in_blocks)
+        # Convert partition size to partition end LBA.
+        super(disk, ptype, pnum, start_lba, start_lba + size_in_blocks)
+      end
+
+      def self.discover_partitions(disk) # rubocop:disable AbcSize
+        _log.debug "<#{disk.object_id}> disk file: #{disk.file_name}" if disk.respond_to? :file_name
+        mbr = disk.mod_read(0, MBR_SIZE)
+
+        if mbr.length < MBR_SIZE
+          _log.info "<#{disk.object_id}> disk does not contain a master boot record"
+          return []
+        end
+
+        sig = mbr[510..511].unpack('H4')
+
+        pt_entry = DOS_PARTITION_ENTRY.decode(mbr[DOS_PT_START, PTE_LEN])
+        ptype = pt_entry[:ptype]
+
+        return [] if sig[0] != DOS_SIG || ptype == GPT_SIG
+        discover_dos_pri_partitions(disk, mbr)
+      end
+
+      def self.discover_dos_pri_partitions(disk, mbr) # rubocop:disable AbcSize
+        pte = DOS_PT_START
+        partitions = []
+        (1..DOS_NPTE).each do |n|
+          pt_entry = DOS_PARTITION_ENTRY.decode(mbr[pte, PTE_LEN])
+          pte += PTE_LEN
+          ptype = pt_entry[:ptype]
+
+          #
+          # If this os an LDM (dynamic) disk, then ignore any partitions.
+          #
+          if ptype == PTYPE_LDM
+            _log.debug "<#{disk.object_id}> detected LDM (dynamic) disk"
+            return([])
+          end
+
+          if ptype == PTYPE_EXT_CHS || ptype == PTYPE_EXT_LBA
+            partitions.concat(
+              discover_dos_ext_partitions(
+                disk,
+                pt_entry[:start_lba],
+                pt_entry[:start_lba],
+                DOS_NPTE + 1
+              )
+            )
+            next
+          end
+          partitions.push(new(disk, ptype, n, pt_entry[:start_lba], pt_entry[:part_size])) if ptype != 0
+        end
+        partitions
+      end
+
+      #
+      # Discover secondary file system partitions within a primary extended partition.
+      #
+      # pri_base_lba is the LBA of the primary extended partition.
+      #     All pointers to secondary extended partitions are relative to this base.
+      #
+      # ptBaseLBA is the LBA of the partition table within the current extended partition.
+      #     All pointers to secondary file system partitions are relative to this base.
+      #
+      def self.discover_dos_ext_partitions(disk, pri_base_lba, ptBaseLBA, pnum) # rubocop:disable AbcSize
+        ra = []
+        seek(ptBaseLBA * @blockSize, IO::SEEK_SET)
+        mbr = read(MBR_SIZE)
+
+        #
+        # Create and add disk object for secondary file system partition.
+        # NOTE: the start of the partition is relative to ptBaseLBA.
+        #
+        pte = DOS_PT_START
+        pt_entry = DOS_PARTITION_ENTRY.decode(mbr[pte, PTE_LEN])
+        ra << new(
+          disk,
+          pt_entry[:ptype],
+          pnum,
+          pt_entry[:start_lba] + ptBaseLBA,
+          pt_entry[:part_size]
+        ) if pt_entry[:ptype] != 0
+
+        #
+        # Follow the chain to the next secondary extended partition.
+        # NOTE: the start of the partition is relative to pri_base_lba.
+        #
+        pte += PTE_LEN
+        pt_entry = DOS_PARTITION_ENTRY.decode(mbr[pte, PTE_LEN])
+        ra.concat(
+          discover_dos_ext_partitions(
+            disk,
+            pri_base_lba,
+            pt_entry[:start_lba] + pri_base_lba,
+            pnum + 1
+          )
+        ) if pt_entry[:start_lba] != 0
+        ra
+      end
+    end
+  end
+end