manageiq-smartstate 0.1.0

data/lib/fs/modules/LinuxMountProbe.rb

@@ -0,0 +1,29 @@
+require 'fs/MiqFS/MiqFS'
+
+module LinuxMountProbe
+  LINUX_FS_TYPES   = %w( Ext3 ext3 Ext4 ext4 ReiserFS XFS )
+  LINUX_ROOT_DIRS  = ["bin", "dev", "etc", "lib", "proc", "sbin", "usr"]
+  LINUX_ROOT_FILES = ["/etc/fstab"]
+
+  def self.probe(fs)
+    unless LINUX_FS_TYPES.include?(fs.fsType)
+      $log.info "LinuxMountProbe << FALSE because file system (#{fs.fsType}) is not supported" if $log
+      return false
+    end
+
+    if (fs.dirEntries & LINUX_ROOT_DIRS).length != LINUX_ROOT_DIRS.length
+      $log.debug "LinuxMountProbe << FALSE because root directories (#{LINUX_ROOT_DIRS.inspect}) missing in: #{fs.dirEntries.inspect}" if $log
+      return false
+    end
+
+    LINUX_ROOT_FILES.each do |f|
+      unless fs.fileExists?(f)
+        $log.info "LinuxMountProbe << FALSE because file #{f} does not exist" if $log
+        return false
+      end
+    end
+
+    $log.debug "LinuxMountProbe << TRUE" if $log
+    true
+  end
+end

data/lib/fs/modules/WinMount.rb

@@ -0,0 +1,97 @@
+require 'sys-uname'
+require 'fs/MiqFS/MiqFS'
+require 'metadata/util/win32/boot_info_win'
+
+module WinMount
+  def fs_init
+    @guestOS = "Windows"
+
+    @rootFS = MiqFS.getFS(@rootVolume)
+    raise MiqException::MiqVmMountError, "WinMount: could not mount root volume" unless @rootFS
+    @allFileSystems << @rootFS
+
+    #
+    # Build volume ID to drive letter mapping.
+    #
+    idToDriveLetter = {}
+    drives = Win32::SystemPath.driveAssignment(@rootFS)
+    if drives.empty?
+      idToDriveLetter["#{@rootVolume.diskSig}-#{@rootVolume.lbaStart}"] = "C:"
+      $log.debug "WinMount.fs_init: [@rootVolume.diskSig}-@rootVolume.lbaStart] = [#{@rootVolume.diskSig}-#{@rootVolume.lbaStart}]"
+    else
+      drives.each do |da|
+        idToDriveLetter["#{da[:serial_num]}-#{da[:starting_sector]}"] = da[:name].upcase
+        $log.debug "WinMount.fs_init: [da[:serial_num]}-da[:starting_sector] = [#{da[:serial_num]}-#{da[:starting_sector]}]"
+      end
+    end
+
+    #
+    # Build drive letter to file system mapping.
+    #
+    @driveToFS = {}
+    if (lvObj = @rootVolume.dInfo.lvObj) && lvObj.driveHint
+      key = lvObj.lvId
+      @rootDriveLetter = lvObj.driveHint
+      $log.debug "WinMount.fs_init: @rootDriveLetter = lvObj.driveHint = #{@rootDriveLetter}"
+    else
+      key = "#{@rootVolume.diskSig}-#{@rootVolume.lbaStart}"
+      @rootDriveLetter = idToDriveLetter[key]
+      $log.debug "WinMount.fs_init: @rootDriveLetter = idToDriveLetter[#{key}] = #{@rootDriveLetter}"
+    end
+    raise MiqException::MiqVmMountError, "Could not determine root drive letter." unless @rootDriveLetter
+    @driveToFS[@rootDriveLetter] = @rootFS
+    saveFs(@rootFS, @rootDriveLetter, key)
+
+    @osNames = {}
+    @volumes.each do |v|
+      if (lvObj = v.dInfo.lvObj) && lvObj.driveHint
+        key = lvObj.lvId
+        dl = lvObj.driveHint
+      else
+        key = "#{v.diskSig}-#{v.lbaStart}"
+        next unless (dl = idToDriveLetter[key])
+      end
+      @osNames[v.dInfo.hardwareId + ':' + v.partNum.to_s] = dl
+      next if v == @rootVolume
+      next unless (fs = MiqFS.getFS(v))
+      @allFileSystems << fs
+      @driveToFS[dl] = fs
+      saveFs(fs, dl, key)
+    end
+
+    @cwd = "#{@rootDriveLetter}/"
+  end # def fs_init
+
+  private
+
+  def normalizePath(p)
+    if Sys::Platform::OS == :unix
+      return p if p[1..1] == ':' # fully qualified path
+      p = p.slice(1..-1) if p[0, 1] == '/'
+      # On Linux, protect the drive letter with a '/', then remove it.
+      return File.expand_path(p, '/' + @cwd).slice(1..-1)
+    end
+    File.expand_path(p, @cwd)
+  end
+
+  #
+  # Mount indirection look up.
+  # Given a path, return its corresponding file system
+  # and the part of the path relative to that file system.
+  #
+  def getFsPath(path)
+    if path.kind_of? Array
+      if path.length == 0
+        localPath = @cwd.dup
+      else
+        localPath = normalizePath(path[0].dup)
+      end
+    else
+      localPath = normalizePath(path.dup)
+    end
+
+    dl = localPath.slice!(0..1).upcase
+    raise MiqException::MiqVmMountError, "Unknown drive letter - #{dl}" unless (fs = @driveToFS[dl])
+    return fs, localPath
+  end
+end # module WinMount

data/lib/fs/modules/WinMountProbe.rb

@@ -0,0 +1,24 @@
+require 'fs/MiqFS/MiqFS'
+require 'metadata/util/win32/system_path_win'
+
+module WinMountProbe
+  WIN_FS_TYPES   = ["FAT32", "NTFS", "ntfs"]
+
+  def self.probe(fs)
+    unless WIN_FS_TYPES.include?(fs.fsType)
+      $log.debug "WinMountProbe << FALSE because file system (#{fs.fsType}) is not supported" if $log
+      return false
+    end
+
+    begin
+      si = Win32::SystemPath.systemIdentifier(fs)
+      # This method will raise an error if it does not find the file system boot markers
+      Win32::SystemPath.systemRoot(fs, si)
+      return true
+    rescue
+      $log.debug "WinMountProbe << FALSE because #{$!} was found" if $log
+    end
+
+    false
+  end
+end

data/lib/fs/ntfs/attrib_attribute_list.rb

@@ -0,0 +1,131 @@
+require 'fs/ntfs/utils'
+require 'binary_struct'
+require 'util/miq-unicode'
+
+module NTFS
+  #
+  # ATTR_LIST_ENTRY - Attribute: Attribute list (0x20).
+  #
+  # - Can be either resident or non-resident.
+  # - Value consists of a sequence of variable length, 8-byte aligned,
+  # ATTR_LIST_ENTRY records.
+  # - The attribute list attribute contains one entry for each attribute of
+  # the file in which the list is located, except for the list attribute
+  # itself. The list is sorted: first by attribute type, second by attribute
+  # name (if present), third by instance number. The extents of one
+  # non-resident attribute (if present) immediately follow after the initial
+  # extent. They are ordered by lowest_vcn and have their instance set to zero.
+  # It is not allowed to have two attributes with all sorting keys equal.
+  # - Further restrictions:
+  #  - If not resident, the vcn to lcn mapping array has to fit inside the
+  #    base mft record.
+  #  - The attribute list attribute value has a maximum size of 256kb. This
+  #    is imposed by the Windows cache manager.
+  # - Attribute lists are only used when the attributes of mft record do not
+  # fit inside the mft record despite all attributes (that can be made
+  # non-resident) having been made non-resident. This can happen e.g. when:
+  #  - File has a large number of hard links (lots of file name
+  #    attributes present).
+  #  - The mapping pairs array of some non-resident attribute becomes so
+  #    large due to fragmentation that it overflows the mft record.
+  #  - The security descriptor is very complex (not applicable to
+  #    NTFS 3.0 volumes).
+  #  - There are many named streams.
+  #
+
+  ATTRIB_ATTRIBUTE_LIST = BinaryStruct.new([
+    'L',  'attrib_type',    # Type of referenced attribute
+    'S',  'length',         # Byte size of this entry
+    'C',  'name_length',    # Size in Unicode chars of the name of the attribute or 0 if unnamed
+    'C',  'name_offset',    # Byte offset (from start of entry) to beginning of attribute name
+    'Q',  'first_vcn',      # Lowest virtual cluster number of this portion of the attribute value.
+    # This is usually 0. It is non-zero for the case where one attribute
+    # does not fit into one mft record and thus several mft records are
+    # allocated to hold this attribute. In the latter case, each mft
+    # record holds one extent of the attribute and there is one attribute
+    # list entry for each extent.
+    # NOTE: This is DEFINITELY a signed value! The windows driver uses cmp, followed
+    # by jg when comparing this, thus it treats it as signed.
+    'Q',  'mft_reference',  # The reference of the mft record holding the ATTR_RECORD for this
+    # portion of the attribute value
+    'S',  'attrib_id',      # If lowest_vcn = 0, the instance of the attribute being referenced; otherwise 0.
+
+  ])
+  SIZEOF_ATTRIB_ATTRIBUTE_LIST = ATTRIB_ATTRIBUTE_LIST.size
+
+  # One $ATTRIBUTE_LIST attribute.
+  class AttributeList
+    attr_reader :list
+
+    def initialize(buf, boot_sector)
+      @boot_sector = boot_sector
+      buf          = buf.read(buf.length) if buf.class.kind_of?(DataRun)
+
+      # Start an attribute list.
+      pos   = 0
+      @list = []
+
+      # Keep it up til we hit an AT_END type
+      # OR until no more data - apparently the end of a list is not always marked.
+      loop do
+        break if pos + SIZEOF_ATTRIB_ATTRIBUTE_LIST > buf.length
+        # Decode this attrib specifier.
+        aal = ATTRIB_ATTRIBUTE_LIST.decode(buf[pos, SIZEOF_ATTRIB_ATTRIBUTE_LIST])
+
+        break if aal['attrib_type'] == AT_END
+
+        # If there's a name get it.
+        len = aal['name_length'] * 2
+        aal['name'] = buf[pos + aal['name_offset'], len].UnicodeToUtf8 if len > 0
+
+        # Log instances of funky references.
+        aal['mft'] = NTFS::Utils.MkRef(aal['mft_reference'])[1]
+
+        # Store (if not bad)
+        @list << aal  if aal['mft'] <= @boot_sector.maxMft
+
+        # advance to next attribute
+        pos += aal['length']
+      end
+    end
+
+    def to_s
+      super
+    end
+
+    # Load attributes of requested type
+    def loadAttributes(attribType)
+      result = []
+
+      # ad is an attribute descriptor.
+      @list.each do |ad|
+        next unless ad['attrib_type'] == attribType
+
+        # Load referenced attribute and add it to parent.
+        result += @boot_sector.mftEntry(ad['mft']).loadAttributes(attribType)
+      end
+
+      result
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>, #{@list.size} attributes:\n"
+      @list.each { |at| out << dumpElement(at) }
+      out
+    end
+
+    def dumpElement(at)
+      ref = NTFS::Utils.MkRef(at['mft_reference'])
+      out = "\#<#{at.class}:0x#{'%08x' % at.object_id}> (#{TypeName[at['attrib_type']]} - #{at['name'] ? at['name'] : '[unnamed]'})\n"
+      out << "Type    : 0x#{'%08x' % at['attrib_type']}\n"
+      out << "Length  : 0x#{'%04x' % at['length']}\n"
+      out << "NameLen : #{at['name_length']}\n"
+      out << "NameOfs : #{at['name_offset']}\n"
+      out << "FirstVCN: 0x#{'%016x' % at['first_vcn']}\n"
+      out << "BaseRef : #{ref[0]}, #{ref[1]}\n"
+      out << "BaseRef : 0x#{'%016x' % ref[1]}\n"
+      out << "AttribID: #{at['attrib_id']}\n\n"
+      out
+    end
+  end # class AttributeList
+end # module NTFS

data/lib/fs/ntfs/attrib_bitmap.rb

@@ -0,0 +1,26 @@
+module NTFS
+  class Bitmap
+    # BITMAP_ATTR - Attribute: Bitmap (0xb0).
+    #
+    # Contains an array of bits (aka a bitfield).
+    #
+    # When used in conjunction with the index allocation attribute, each bit
+    # corresponds to one index block within the index allocation attribute. Thus
+    # the number of bits in the bitmap * index block size / cluster size is the
+    # number of clusters in the index allocation attribute.
+    #
+
+    def self.create_from_header(header, buf)
+      return Bitmap.new(buf) if header.containsFileNameIndexes?
+      $log.debug("Skipping #{header.typeName} for name <#{header.name}>") if $log
+      nil
+    end
+
+    attr_reader :data, :length
+
+    def initialize(buf)
+      @data   = buf.kind_of?(DataRun) ? buf.read(buf.length) : buf
+      @length = @data.length
+    end
+  end
+end

data/lib/fs/ntfs/attrib_data.rb

@@ -0,0 +1,74 @@
+require 'binary_struct'
+
+module NTFS
+  class AttribData
+    #
+    # DATA_ATTR - Attribute: Data attribute (0x80)
+    #
+    # NOTE: Can be resident or non-resident.
+    #
+    # Data contents of a file (i.e. the unnamed stream) or of a named stream.
+    #
+    def self.create_from_header(header, buf)
+      return AttribData.new(buf) if header.namelen == 0
+      $log.debug("MFT Alternate Data Stream (#{header.name})") if $log
+      nil
+    end
+
+    attr_reader :data, :length, :run
+
+    def initialize(buf)
+      @run    = buf if buf.kind_of?(NTFS::DataRun)
+      @data   = buf
+      @length = @data.length
+      @pos    = 0
+    end
+
+    def to_s
+      return @data.hex_dump if @data.kind_of?(String)
+
+      raise "MIQ(NTFS::AttribData.to_s) Unexpected data class: #{@data.class}" unless @data.kind_of?(NTFS::DataRun)
+
+      # Must be a Data Run
+      savedPos = @pos
+      seek(0)
+      data = read(@length)
+      seek(savedPos)
+      data
+    end
+
+    # This now behaves exactly like a normal read.
+    def read(bytes = @length)
+      return nil if @pos >= @length
+      bytes = @length - @pos if bytes.nil?
+      bytes = @length - @pos if @pos + bytes > @length
+
+      out = @data[@pos, bytes]      if @data.kind_of?(String)
+      out = @data.read(bytes)       if @data.kind_of?(NTFS::DataRun)
+
+      @pos += out.size
+      out
+    end
+
+    def seek(offset, method = IO::SEEK_SET)
+      @pos = case method
+             when IO::SEEK_CUR then (@pos + offset)
+             when IO::SEEK_END then (@length - offset)
+             when IO::SEEK_SET then offset
+             end
+      @data.seek(offset, method) if @data.kind_of?(NTFS::DataRun)
+      @pos
+    end
+
+    def rewind
+      seek(0)
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out << "  Length: #{@length}\n"
+      out << @data.dumpRunList if @data.class == NTFS::DataRun
+      out << "---\n"
+    end
+  end
+end # module NTFS

data/lib/fs/ntfs/attrib_file_name.rb

@@ -0,0 +1,110 @@
+require 'fs/ntfs/utils'
+require 'util/win32/nt_util'
+require 'binary_struct'
+require 'util/miq-unicode'
+require 'fs/ntfs/attrib_standard_information'
+
+module NTFS
+  #
+  # FILE_NAME_ATTR - Attribute: Filename (0x30)
+  #
+  # NOTE: Always resident.
+  # NOTE: All fields, except the parent_directory, are only updated when the
+  #   filename is changed. Until then, they just become out of sync with
+  #   reality and the more up to date values are present in the standard
+  #   information attribute.
+  # NOTE: There is conflicting information about the meaning of each of the time
+  #   fields but the meaning as defined below has been verified to be
+  #   correct by practical experimentation on Windows NT4 SP6a and is hence
+  #   assumed to be the one and only correct interpretation.
+  #
+  # The $FILE_NAME attribute.
+  ATTRIB_FILE_NAME = BinaryStruct.new([
+    'Q',  'ref_to_parent_dir',  # Directory this filename is referenced from
+    'Q',  'time_created',       # Time file was created
+    'Q',  'time_altered',       # Time the data attribute was last modified
+    'Q',  'time_mft_changed',   # Time this mft record    was last modified
+    'Q',  'time_read',          # Last time this mft record was accessed
+    'Q',  'allocated_size',     # Byte size of on-disk allocated space for the data attribute.
+    # So for normal $DATA, this is the allocated_size from the unnamed
+    # $DATA attribute and for compressed and/or sparse $DATA, this is
+    # the compressed_size from the unnamed $DATA attribute.
+    # NOTE: This is a multiple of the cluster size.
+    'Q',  'data_size',          # Byte size of actual data in data attribute
+    'L',  'flags',              # Flags describing the file
+    'L',  'reparse_point_tag',  # Type of reparse point, present only in reparse points and only if there are no EAs
+    'C1', 'name_length',        # Length of file name in (Unicode) characters
+    'C1', 'namespace',          # Namespace of the file name
+  ])
+  # File name (in UNICODE) is appended to the previous structure.
+  SIZEOF_ATTRIB_FILE_NAME = ATTRIB_FILE_NAME.size
+
+  class FileName
+    attr_reader :name, :namespace, :length, :permissions, :refParent
+
+    NS_POSIX  = 0
+    NS_WIN32  = 1
+    NS_DOS    = 2
+    NS_DOSWIN = 3
+
+    UNNAMED = '[unnamed]'.AsciiToUtf8.freeze
+
+    def initialize(buf)
+      raise "MIQ(NTFS::FileName.initialize) Nil buffer" if buf.nil?
+      buf          = buf.read(buf.length) if buf.kind_of?(DataRun)
+      @afn         = ATTRIB_FILE_NAME.decode(buf)
+      buf          = buf[SIZEOF_ATTRIB_FILE_NAME, buf.size]
+
+      # Set accessor data.
+      @permissions = @afn['flags']
+      @length      = @afn['data_size']
+      @namespace   = @afn['namespace']
+      @refParent   = NTFS::Utils.MkRef(@afn['ref_to_parent_dir'])
+
+      # If there's a name get it.
+      len          = @afn['name_length'] * 2
+      @name        = buf[0, len].UnicodeToUtf8 if len > 0
+
+      # If name is nil use NT standard unnamed.
+      @name ||= UNNAMED.dup
+    end
+
+    def to_s
+      @name
+    end
+
+    def mTime
+      @mTime ||= NtUtil.nt_filetime_to_ruby_time(@afn['time_altered'])
+    end
+
+    def aTime
+      @aTime ||= NtUtil.nt_filetime_to_ruby_time(@afn['time_read'])
+    end
+
+    def cTime
+      @cTime ||= NtUtil.nt_filetime_to_ruby_time(@afn['time_created'])
+    end
+
+    # Returns nil if not directory.
+    def isDir?
+      NTFS::Utils.gotBit?(@permissions, StandardInformation.FP_DIRECTORY)
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out << "  Parent dir : seq #{@refParent[0]}, entry #{@refParent[1]}\n"
+      out << "  Created    : #{@cTime}\n"
+      out << "  Modified   : #{@mTime}\n"
+      out << "  MFT changed: #{NtUtil.nt_filetime_to_ruby_time(@afn['time_mft_changed'])}\n"
+      out << "  Accessed   : #{@aTime}\n"
+      out << "  Allocated  : #{@afn['allocated_size']}\n"
+      out << "  Real size  : #{@length}\n"
+      out << "  Flags      : 0x#{'%08x' % @flags}\n"
+      out << "  Reparse    : #{@afn['reparse_point_tag']}\n"
+      out << "  Name length: #{@afn['name_length']}\n"
+      out << "  Namespace  : #{@namespace}\n"
+      out << "  Name       : #{@name}\n"
+      out << "---\n"
+    end
+  end
+end # module NTFS