manageiq-smartstate 0.1.0

data/lib/fs/ReiserFS/block.rb

@@ -0,0 +1,209 @@
+require 'fs/ReiserFS/utils'
+
+module ReiserFS
+  class Block
+    BLOCK_HEADER = BinaryStruct.new([
+      'v',   'level',             # Level of the block in the tree
+      'v',   'nitems',            # The number of items in the block
+      'x20', nil                  # Ignoring the following, as they are not presently used
+      #  'v',  'free_space', # Free space left in the block
+      #  'a2', 'reserved',
+      #  'a16','right_key',  # right delimiting key for the block
+    ])
+    SIZEOF_BLOCK_HEADER = BLOCK_HEADER.size
+
+    attr_reader :blockNum, :data
+
+    def initialize(data, bnum)
+      @blockNum = bnum
+      @data     = data
+      @bh       = BLOCK_HEADER.decode(@data)
+      @nitems   = @bh['nitems']
+      @level    = @bh['level']
+      @iHeaders = {}
+    end
+
+    def nkeys
+      @nitems
+    end
+
+    def npointers
+      return 0 if isLeaf?
+      @nitems + 1
+    end
+
+    KEY = BinaryStruct.new([
+      'V',  'directory_id',
+      'V',  'object_id',
+      'V',  'offset',
+      'V',  'type'
+    ])
+    SIZEOF_KEY = KEY.size
+
+    def data2key(keydata)
+      key = KEY.decode(keydata)
+      key['type'] = Utils.type2integer(key['type'])
+      key
+    end
+
+    # Keys are 1-based
+    def getKey(k)
+      return nil if k > @nitems || k <= 0
+      pos = SIZEOF_BLOCK_HEADER + (SIZEOF_KEY * (k - 1))
+      keydata = @data[pos, SIZEOF_KEY]
+      data2key(keydata)
+    end
+
+    POINTER = BinaryStruct.new([
+      'V',  'block_number',
+      'v',  'size',
+      'a2', 'reserved',
+    ])
+    SIZEOF_POINTER = POINTER.size
+
+    # Pointers are 0-based
+    def getPointer(p)
+      # puts "getPointer >> p=#{p}"
+      return nil if p > @nitems || p < 0
+      pos = SIZEOF_BLOCK_HEADER + (SIZEOF_KEY * @nitems) + (SIZEOF_POINTER * p)
+      ptrdata = @data[pos, SIZEOF_POINTER]
+      POINTER.decode(ptrdata)
+    end
+
+    def findPointer(searchKey)
+      # puts "findPointer >> #{dumpKey(searchKey, "searchKey")}"
+      (1..@nitems).each do |i|
+        currentKey = getKey(i)
+        compare = Utils.compareKeys(searchKey, currentKey)
+        # puts dumpKey(currentKey, "currentKey(#{i})")
+        next                   if compare > 0
+        return getPointer(i - 1) if compare <= 0
+      end
+      getPointer(@nitems)
+    end
+
+    def findPointers(searchKey)
+      pointers = []
+      compare  = nil
+
+      (1..@nitems).each do |i|
+        currentKey = getKey(i)
+        compare = Utils.compareKeys(searchKey, currentKey)
+        # puts dumpKey(currentKey, "currentKey(#{i})")
+        next  if compare > 0
+        pointers << getPointer(i - 1)
+        break if compare < 0
+      end
+      pointers << getPointer(@nitems) if pointers.size == 0 || compare == 0
+
+      pointers
+    end
+
+    ITEM_HEADER = BinaryStruct.new([
+      'a16',  'key',
+      'v',    'count',
+      'v',    'length',
+      'v',    'location',
+      'v',    'version'
+    ])
+    SIZEOF_ITEM_HEADER = ITEM_HEADER.size
+
+    def getItemHeaders(key = nil)
+      return @iHeadersAll if key.nil? && !@iHeadersAll.nil?
+
+      did = Utils.getKeyDirectoryID(key) if key
+      oid = Utils.getKeyObjectID(key)    if key
+
+      iHeaders = []
+      (1..nkeys).each do |i|
+        iheader = getItemHeader(i)
+        if key
+          curKey = iheader['key']
+          next if did != Utils.getKeyDirectoryID(curKey)
+          next if oid != Utils.getKeyObjectID(curKey)
+        end
+
+        iHeaders << iheader
+      end
+
+      @iHeadersAll = iHeaders if key.nil?
+
+      iHeaders
+    end
+
+    def getItemHeader(i)
+      return @iHeaders[i] if @iHeaders.key?(i)
+      return nil if i > @nitems || i <= 0
+
+      pos = SIZEOF_BLOCK_HEADER + (SIZEOF_ITEM_HEADER * (i - 1))
+      iheaddata = @data[pos, SIZEOF_ITEM_HEADER]
+      keydata   = iheaddata[0, SIZEOF_KEY]
+      key       = data2key(keydata)
+      iheader   = ITEM_HEADER.decode(iheaddata)
+      iheader['key'] = key
+      @iHeaders[i] = iheader
+    end
+
+    def getItemVersion(iheader)
+      iheader['version']
+    end
+
+    def getItemCount(iheader)
+      iheader['count']
+    end
+
+    def getItemType(iheader)
+      iheader['key']['type']
+    end
+
+    def getItem(iheader)
+      offset = iheader['location']
+      length = iheader['length']
+      @data[offset, length]
+    end
+
+    def isLeaf?
+      @level == 1
+    end
+
+    def dump
+      out = dumpHeader
+
+      if isLeaf?
+        (1..@nitems).each do |i|
+          ihead = getItemHeader(i)
+          out += dumpItemHeader(ihead, "Item Header #{i}")
+        end
+      else
+        (1..@nitems).each do |i|
+          key  = getKey(i)
+          out += dumpKey(key, "Key #{i}")
+        end
+        out += "\n"
+        (0..@nitems).each do |i|
+          ptr  = getPointer(i)
+          out += dumpPointer(ptr, "Ptr #{i}")
+        end
+      end
+      out
+    end
+
+    def dumpHeader
+      "Block Header: blockNum=#{@blockNum} nitems=#{@bh['nitems']} level=#{@bh['level']}\n"
+    end
+
+    def dumpKey(key, label = nil)
+      "#{Utils.dumpKey(key, label)}\n"
+    end
+
+    def dumpPointer(ptr, label = nil)
+      "#{label}:\t\{#{ptr['block_number']},#{ptr['size']}\}\n"
+    end
+
+    def dumpItemHeader(ihead, label = nil)
+      key = ihead['key']
+      keystring = "\{#{key['directory_id']},#{key['object_id']},#{key['offset']},#{key['type']}\}"
+      "#{label}:\t\{#{keystring},#{ihead['count']},#{ihead['length']},#{ihead['location']},#{ihead['version']}\}\n"
+    end
+  end
+end

data/lib/fs/ReiserFS/directory.rb

@@ -0,0 +1,136 @@
+# encoding: US-ASCII
+
+require 'fs/ReiserFS/utils'
+require 'fs/ReiserFS/directory_entry'
+
+module ReiserFS
+  class Directory
+    ROOT_DIR = {'directory_id' => 1, 'object_id' => 2, 'offset' => 0, 'type' => 0}
+
+    attr_accessor :key, :sb
+
+    ###################################################################
+    # A directory is composed of 2 things: Key and BlockNum
+    #  Key is in the form of {doid,oid,offset,type}
+    #  BlockNum is what is used to actually instantiate the Block object
+    #
+    # Note:  BlockNum can always be computed from Key and the ROOT_DIR
+    ###################################################################
+    def initialize(sb, key = nil)
+      raise "Nil superblock" if sb.nil?
+      @sb        = sb
+      @key       = key.nil? ? ROOT_DIR : key
+      @leaves    = @sb.getLeafNodes(@key)
+      @dirEntry  = nil
+      @dirItems  = nil
+
+      raise "Key #{Utils.dumpKey(@key)} NOT found" if @leaves.nil?
+
+      @leaves.each do |leaf|
+        leaf.getItemHeaders.each do |iheader|
+          @dirEntry = DirectoryEntry.new(leaf, iheader, @key)  if Utils.typeIsStat?(leaf.getItemType(iheader))
+        end
+      end
+    end
+
+    def findKey(name)
+      initDirItems
+      if @dirItems.key?(name)
+        hash = @dirItems[name]
+        return hash['key']
+      end
+
+      nil
+    end
+
+    def findEntry(name)
+      initDirItems
+      if @dirItems.key?(name)
+        hash = @dirItems[name]
+        unless hash.key?('dirEntry')
+          hash['dirEntry'] = createDirectoryEntry(hash['key'])
+          @dirItems[name] = hash
+        end
+        return hash['dirEntry']
+      end
+
+      nil
+    end
+
+    def globNames
+      if @names.nil?
+        initDirItems
+        @names = @dirItems.keys
+        @names.sort!
+      end
+
+      @names
+    end
+
+    #################
+
+    private
+
+    def createDirectoryEntry(key)
+      @sb.getLeafNodes(key).each do |leaf|
+        leaf.getItemHeaders(key).each do |iheader|
+          return DirectoryEntry.new(leaf, iheader, key)   if Utils.typeIsStat?(leaf.getItemType(iheader))
+        end
+      end
+      nil
+    end
+
+    def initDirItems
+      return @dirItems unless @dirItems.nil?
+
+      @dirItems = {}
+      @leaves.each do |leaf|
+        leaf.getItemHeaders(@key).each do |ih|
+          if Utils.typeIsDirectory?(leaf.getItemType(ih))
+            getDirItems(leaf, ih).each do |item|
+              name  = item['name']
+              @dirItems[name] = item
+            end
+          end
+        end
+      end
+    end
+
+    ITEM_DIRECTORY = BinaryStruct.new([
+      'V',  'offset',
+      'V',  'directory_id',
+      'V',  'object_id',
+      'v',  'location',
+      'v',  'state',
+    ])
+    SIZEOF_ITEM_DIRECTORY = ITEM_DIRECTORY.size
+
+    def getDirItems(b, i)
+      item  = b.getItem(i)
+      count = b.getItemCount(i)
+      last  = 0
+
+      dirItems = []
+      (1..count).each do |d|
+        offset      = SIZEOF_ITEM_DIRECTORY * (d - 1)
+        length      = SIZEOF_ITEM_DIRECTORY
+        dir         = ITEM_DIRECTORY.decode(item[offset, length])
+        gen, hash   = item[offset, 4].unpack('B7B24')
+        dir['gen']  = gen.to_i(2)
+        dir['hash'] = hash.to_i(2)
+        dir['key']  = {'directory_id' => dir['directory_id'], 'object_id' => dir['object_id'], 'offset' => 0, 'type' => 0}
+        dir['name'] = getASCIIZ(item[dir['location']..(last - 1)])
+        last        = dir['location']
+
+        dirItems << dir
+      end
+      dirItems
+    end
+
+    def getASCIIZ(data)
+      i = data.index("\0")
+      return data if i.nil?
+      data[0..i - 1]
+    end
+  end
+end

data/lib/fs/ReiserFS/directory_entry.rb

@@ -0,0 +1,140 @@
+require 'fs/ReiserFS/utils'
+
+module ReiserFS
+  class DirectoryEntry
+    ITEM_STAT_V1 = BinaryStruct.new([
+      'v',  'mode',
+      'v',  'nlinks',
+      'v',  'uid',
+      'v',  'gid',
+      'V',  'size',
+      'V',  'atime',
+      'V',  'mtime',
+      'V',  'ctime',
+      'V',  'nblocks',
+      'V',  'first'
+    ])
+    SIZEOF_ITEM_STAT_V1 = ITEM_STAT_V1.size
+
+    ITEM_STAT_V2 = BinaryStruct.new([
+      'v',  'mode',
+      'a2', 'reserved',
+      'V',  'nlinks',
+      'Q',  'size',
+      'V',  'uid',
+      'V',  'gid',
+      'V',  'atime',
+      'V',  'mtime',
+      'V',  'ctime',
+      'V',  'nblocks',
+      'V',  'first'
+    ])
+    SIZEOF_ITEM_STAT_V2 = ITEM_STAT_V2.size
+
+    # Bits 0 to 8 of file mode.
+    PF_O_EXECUTE  = 0x0001  # owner execute
+    PF_O_WRITE    = 0x0002  # owner write
+    PF_O_READ     = 0x0004  # owner read
+    PF_G_EXECUTE  = 0x0008  # group execute
+    PF_G_WRITE    = 0x0010  # group write
+    PF_G_READ     = 0x0020  # group read
+    PF_U_EXECUTE  = 0x0040  # user execute
+    PF_U_WRITE    = 0x0080  # user write
+    PF_U_READ     = 0x0100  # user read
+
+    # For accessor convenience.
+    MSK_PERM_OWNER = (PF_O_EXECUTE | PF_O_WRITE | PF_O_READ)
+    MSK_PERM_GROUP = (PF_G_EXECUTE | PF_G_WRITE | PF_G_READ)
+    MSK_PERM_USER  = (PF_U_EXECUTE | PF_U_WRITE | PF_U_READ)
+
+    # Bits 9 to 11 of file mode.
+    DF_STICKY     = 0x0200
+    DF_SET_GID    = 0x0400
+    DF_SET_UID    = 0x0800
+
+    # Bits 12 to 15 of file mode.
+    FM_FIFO       = 0x1000  # fifo device (pipe)
+    FM_CHAR       = 0x2000  # char device
+    FM_DIRECTORY  = 0x4000  # directory
+    FM_BLOCK_DEV  = 0x6000  # block device
+    FM_FILE       = 0x8000  # regular file
+    FM_SYM_LNK    = 0xa000  # symbolic link
+    FM_SOCKET     = 0xc000  # socket device
+
+    # For accessor convenience.
+    MSK_FILE_MODE = 0xf000
+    MSK_IS_DEV    = (FM_FIFO | FM_CHAR | FM_BLOCK_DEV | FM_SOCKET)
+
+    attr_reader :key, :blockObj
+
+    def initialize(blockObj, itemHeader, key)
+      @itemHeader = itemHeader
+      @blockObj   = blockObj
+      @key        = key
+      @data       = @blockObj.getItem(itemHeader)
+      @version    = @blockObj.getItemVersion(itemHeader)
+
+      statStruct = @version == 0 ? ITEM_STAT_V1 : ITEM_STAT_V2
+      statSize   = @version == 0 ? SIZEOF_ITEM_STAT_V1 : SIZEOF_ITEM_STAT_V2
+      raise "Stat Structure Length Inconsistency" if statSize != @data.length
+      @stat = statStruct.decode(@data)
+      @mode = @stat['mode']
+    end
+
+    def isDir?
+      @mode & FM_DIRECTORY == FM_DIRECTORY
+    end
+
+    def isFile?
+      @mode & FM_FILE == FM_FILE
+    end
+
+    def isDev?
+      @mode & MSK_IS_DEV > 0
+    end
+
+    def isSymLink?
+      @mode & FM_SYM_LNK == FM_SYM_LNK
+    end
+
+    def permissions
+      @mode & (MSK_PERM_OWNER | MSK_PERM_GROUP | MSK_PERM_USER)
+    end
+
+    def ownerPermissions
+      @mode & MSK_PERM_OWNER
+    end
+
+    def groupPermissions
+      @mode & MSK_PERM_GROUP
+    end
+
+    def userPermissions
+      @mode & MSK_PERM_USER
+    end
+
+    def uid
+      @stat['uid']
+    end
+
+    def gid
+      @stat['gid']
+    end
+
+    def aTime
+      Time.at(@stat['atime'])
+    end
+
+    def cTime
+      Time.at(@stat['ctime'])
+    end
+
+    def mTime
+      Time.at(@stat['mtime'])
+    end
+
+    def length
+      @stat['size']
+    end
+  end
+end

data/lib/fs/ReiserFS/file_data.rb

@@ -0,0 +1,111 @@
+require 'fs/ReiserFS/utils'
+
+module ReiserFS
+  class FileData
+    attr_reader :pos
+
+    # Initialization
+    def initialize(dirEntry, superblock)
+      raise "Nil dirEntry object" if dirEntry.nil?
+      raise "Nil superblock"      if superblock.nil?
+
+      @sb   = superblock
+      @de   = dirEntry
+      @key  = @de.key
+      @len  = @de.length
+      @blocks = []
+
+      # puts "Key=#{Utils.dumpKey(@key)} datalen=#{@len}"
+
+      @sb.getLeafNodes(@key).each do |leaf|
+        leaf.getItemHeaders(@key).each do |ih|
+          next if Utils.typeIsStat?(leaf.getItemType(ih))
+          raise "Directory Node when FileData expected" if Utils.typeIsDirectory?(leaf.getItemType(ih))
+
+          if Utils.typeIsDirect?(leaf.getItemType(ih))
+            @blocks << {:blockNum => leaf.blockNum, :offset => ih['location'], :length => ih['length'], :blockObj => leaf}
+          end
+
+          if Utils.typeIsIndirect?(leaf.getItemType(ih))
+            leaf.getItem(ih).unpack("V*").each do |blockNum|
+              @blocks << {:blockNum => blockNum, :offset => 0, :length => @sb.blockSize}
+            end
+          end
+        end
+      end
+
+      @bpos  = []
+      pos = 0
+      @blocks.each do |b|
+        @bpos << pos
+        pos += b[:length]
+      end
+
+      @blen  = @blocks[0][:length]
+
+      #      @blocks.each { |b| puts "Block(#{b['blockNum']}): len=#{b['length']} offset=#{b['offset']}"   }
+
+      rewind
+    end
+
+    def findIndex(pos)
+      index = pos / @blen
+      index -= 1 while                    @bpos[index] > pos
+      index += 1 while @bpos[index + 1] && (@bpos[index + 1] < pos)
+      index
+    end
+
+    def rewind
+      @pos = 0
+    end
+
+    def seek(offset, method = IO::SEEK_SET)
+      @pos = case method
+             when IO::SEEK_SET then offset
+             when IO::SEEK_CUR then @pos + offset
+             when IO::SEEK_END then @len - offset
+             end
+      @pos = 0    if @pos < 0
+      @pos = @len if @pos > @len
+      @pos
+    end
+
+    def read(bytes = @len)
+      return nil if @pos >= @len
+
+      index = findIndex(@pos)
+      out = ""
+
+      while out.length < bytes
+        b      = @blocks[index]
+        pos    = @bpos[index]
+        index += 1
+
+        blockLength = b[:length]
+        blockLength = (@len - pos) if (pos + blockLength) > @len
+
+        # Do we have to start reading from an offset?
+        byteOffset = (pos < @pos) ? (@pos - pos) : 0
+
+        # Get the block with data
+        b[:blockObj] = @sb.readBlock(b[:blockNum])  unless b.key?(:blockObj)
+        blockObj = b[:blockObj]
+
+        # Extract the data we need out of it
+        blockOffset = b[:offset]
+        out << blockObj.data[blockOffset + byteOffset, blockLength - byteOffset]
+      end
+
+      bytes = out.length if bytes > out.length
+      @pos += bytes
+
+      out[0, bytes]
+    end
+
+    def write(buf, _len = buf.length)
+      raise "Write functionality is not yet supported on ReiserFS."
+    end
+
+    private
+  end # class
+end # module