proof of concept extraction of binary data from SBF files.

extract_sbf_proof.rb

require 'bindata' 

BLOCK_SIZE = 64


class SbfHeader < BinData::Record
  endian :little 
  uint32 :dchain
  uint32 :dcount
  uint32 :serial
  uint32 :num_recs
  uint32 :number_blocks 
  uint16 :block_size
  uint8 :num_users
  uint8 :num_write
  string :reserved_internal_version, :len=>32
  string :version, :len=>2
  uint8 :aversion
  string :padding, :len=>lambda { header_block_length }

  def header_block_length
    self.block_size-60
  end
end

class SbfBlock < BinData::Record

  endian :little
  uint16 :next_record_pointer
  uint8 :next_record_2
  bit1 :first_record
  bit1 :deleted_record 
  bit6 :ignored_bits
  rest :record_data

  def first_record?
    self.first_record
  end

end

class SbfDataItem < BinData::Record
  rest :data

end

@records = []


def read_out_data
  @records.each do |r|
    puts "----"
    puts r.data.unpack("M")
  end
end

def new_data_item(data_item) 
  @records << data_item if data_item
  data_item = SbfDataItem.new
  data_item
end


def bootstrap
  # read_until = 6400
  File.open('./PARTS.SBF') do |io|
    puts io.pos
    data = io.read(BLOCK_SIZE)
    r = SbfHeader.read(data)
    puts "Number Records:#{r.num_recs}"
    puts "Num Blocks: #{r.number_blocks}"
    puts "Block Size: #{r.block_size}"
    puts "Version: #{r.aversion}"
    puts io.pos
    io.pos = 64

    data_item = SbfDataItem.new

    (0..100).each do |block|
      data = io.read(BLOCK_SIZE)
      rec = SbfBlock.read(data) 
      if rec.first_record == 1 
        puts "new block @#{io.pos} because #{rec.first_record?}"
        data_item = new_data_item(data_item) 
      end
      data_item.data += (rec.record_data)
    end
  end
  read_out_data
end


bootstrap