slowfat 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6abcf48f837234179e5df0d15ad3897130d20113
+  data.tar.gz: abd92e3c770f993e954555310073319b587fd314
+SHA512:
+  metadata.gz: 2aac85c59372730819e52971a32ddb4965e0446c17b24714e1e9abc305c78224848dee6ac49b6ef93f0bdc867279ef4399a5e38f3f5cfc38c0dc625ad5ee921e
+  data.tar.gz: e912068bef784900cbffdc7a760165646e66a39125f37b592a0f03ec8df09935af228dc4ce69a64f283462f627fb2152c16aedfa31050edade8babe4c26e12d5

data/README.md

@@ -0,0 +1,2 @@
+# ruby-slowfat
+FAT library for Ruby, designed to perform minimum I/O for use on slow links such as serial connections.

data/Rakefile

@@ -0,0 +1,38 @@
+require 'bundler'
+Bundler.setup
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "slowfat/version"
+require "yard"
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+  t.options = %w(--markup-provider=redcarpet --markup=markdown --main=README.md)
+end
+
+desc "Builds the gem"
+task :gem => :build
+task :build => :yard do
+  system "gem build slowfat.gemspec"
+  Dir.mkdir("pkg") unless Dir.exists?("pkg")
+  system "mv slowfat-#{SlowFat::VERSION}.gem pkg/"
+end
+
+task :install => :build do
+  system "sudo gem install pkg/slowfat-#{SlowFat::VERSION}.gem"
+end
+
+desc "Release the gem - Gemcutter"
+task :release => :build do
+  system "git tag -a v#{SlowFat::VERSION} -m 'Tagging #{SlowFat::VERSION}'"
+  system "git push --tags"
+  system "gem push pkg/slowfat-#{SlowFat::VERSION}.gem"
+end
+
+task :default => [:spec]

data/lib/slowfat.rb

@@ -0,0 +1,6 @@
+require 'slowfat/filesystem.rb'
+require 'slowfat/bootsect.rb'
+require 'slowfat/file_alloc_table.rb'
+require 'slowfat/dir.rb'
+require 'slowfat/data.rb'
+require 'slowfat/fat_file.rb'

data/lib/slowfat/bootsect.rb

@@ -0,0 +1,52 @@
+module SlowFat
+  class BootSector
+    attr_reader :oem_name
+
+    class DataError < StandardError
+    end
+
+    def initialize(data)
+      (@jmp, @oem_name, @bpb, @ebpb, @boot_code, @boot_signature) = data.unpack('a3a8a25a26a448v')
+      raise DataError, "Invalid boot signature in boot sector." if(@boot_signature != 0xAA55)
+    end
+
+    def bios_parameter_block
+      BiosParameterBlock.new @bpb
+    end
+
+    def extended_bios_parameter_block
+      ExtendedBiosParameterBlock.new @ebpb
+    end
+  end
+
+  class BiosParameterBlock
+    attr_reader :bytes_per_logsect, :logsects_per_cluster, :reserved_logsects, :fats, :root_entries, :logsects, :media_descriptor, :logsects_per_fat, :physects_per_track, :heads, :hidden_logsects, :large_total_logsects
+
+    def initialize(data)
+      (@bytes_per_logsect, @logsects_per_cluster, @reserved_logsects, @fats, @root_entries, @total_logsects, @media_descriptor, @logsects_per_fat, @physects_per_track, @heads, @hidden_logsects, @large_total_logsects) = data.unpack('vCvCvvCvvvVV')
+    end
+
+    def media_descriptor_type
+      case @media_descriptor_id
+        when 0xE5
+          :floppy_8inch
+        when 0xF0
+          :floppy_35inch_hd
+        when 0xF8
+          :fixed_disk
+        when 0xFD
+          :floppy_525inch_ld
+        else
+          :unknown
+      end
+    end
+  end
+  
+  class ExtendedBiosParameterBlock
+    attr_reader :physical_drive_nbr, :boot_signature, :volume_serial, :volume_label, :fs_type
+
+    def initialize(data)
+      (@physical_drive_nbr, @flags, @boot_signature, @volume_serial, @volume_label, @fs_type) = data.unpack('CCCVa11a8')
+    end
+  end
+end

data/lib/slowfat/data.rb

@@ -0,0 +1,30 @@
+module SlowFat
+  class Data
+    attr_reader :base, :size
+
+    def initialize(backing:, base:, cluster_size:)
+      @backing = backing
+      @base = base
+      @cluster_size = cluster_size
+    end
+
+    def cluster_contents(cluster:, size:)
+      @backing.seek @base + @cluster_size * cluster
+      @backing.read size
+    end
+
+    def cluster_chain_contents(chain:, size:)
+      data = ""
+      chain.each_index do |idx|
+        cluster = chain[idx]
+        # read the whole cluster by default
+        read_size = @cluster_size
+        # on the last cluster of the file, read only as many
+        # bytes as we need to get the rest of the file, skip the padding
+        read_size = size % @cluster_size if idx == chain.length-1
+        data += cluster_contents(cluster: cluster, size: read_size)
+      end
+      data
+    end
+  end
+end

data/lib/slowfat/dir.rb

@@ -0,0 +1,103 @@
+module SlowFat
+  class Directory
+    attr_reader :entries
+
+    def initialize(backing:, base:, max_entries:)
+      @backing = backing
+      @entries = []
+      (0..max_entries-1).each do |idx|
+        @backing.seek base+idx*32
+        dir_data = @backing.read(32)
+        entry = Dentry.new(dir_data)
+        break if entry.type == :end_of_dentries
+        @entries << entry
+      end
+    end
+
+    def file_entry(filename)
+      @entries.each do |dentry|
+        full_dentry_filename = dentry.extension.length > 0 ? "#{dentry.filename}.#{dentry.extension}".downcase : dentry.filename.downcase
+        return dentry if dentry.type == :file and filename.downcase == full_dentry_filename
+      end
+
+      nil
+    end
+
+    def dir_entry(filename)
+      @entries.each do |dentry|
+        full_dentry_filename = dentry.extension.length > 0 ? "#{dentry.filename}.#{dentry.extension}".downcase : dentry.filename.downcase
+        return dentry if dentry.type == :directory and filename.downcase == full_dentry_filename
+      end
+
+      nil
+    end
+
+    class Dentry
+      attr_reader :filename, :extension, :start_cluster, :size, :type
+
+      def initialize(dir_data)
+        case dir_data[0].ord
+          when 0x00
+            # end of directory entries
+            @type = :end_of_dentries
+            return
+          when 0x2E
+            # dot entry
+            @dotdir = true
+          when 0xE5
+            # deleted file
+            @deleted = true
+        end
+        (@filename, @extension, attrib_bits, reserved, mod_date, mod_time, @start_cluster, @size) = dir_data.unpack('A8A3Ca10vvvV')
+
+        @read_only  = attrib_bits & 0x01 > 0
+        @hidden     = attrib_bits & 0x02 > 0
+        @system     = attrib_bits & 0x04 > 0
+        @archive    = attrib_bits & 0x20 > 0
+        @device     = attrib_bits & 0x40 > 0
+
+        @type = :file
+        @type = :volume_label if attrib_bits & 0x08 > 0
+        @type = :directory if attrib_bits & 0x10 > 0
+      end
+
+      def read_only?
+        @hidden
+      end
+
+      def hidden?
+        @hidden
+      end
+
+      def system?
+        @system
+      end
+      
+      def archive?
+        @archive
+      end
+
+      def device?
+        @device
+      end
+
+      def deleted?
+        @deleted
+      end
+
+      def dotdir?
+        @dotdir
+      end
+    end
+
+    def dump
+      @entries.each do |dentry|
+        if(dentry.type == :file) then
+          printf("%-8s %-3s   %d\n", dentry.filename, dentry.extension, dentry.size)
+        elsif(dentry.type == :directory)
+          printf("%-8s %-3s   <DIR>\n", dentry.filename, dentry.extension)
+        end
+      end
+    end
+  end
+end

data/lib/slowfat/fat_file.rb

@@ -0,0 +1,13 @@
+module SlowFat
+  class FatFile
+    def initialize(filesystem:, dentry:)
+      @filesystem = filesystem
+      @dentry = dentry
+      @data = Data.new(backing: filesystem.backing, base: filesystem.data_base, cluster_size: filesystem.cluster_size)
+    end
+
+    def contents
+      @data.cluster_chain_contents chain: @filesystem.fats[0].chain_starting_at(@dentry.start_cluster), size: @dentry.size
+    end
+  end
+end

data/lib/slowfat/file_alloc_table.rb

@@ -0,0 +1,38 @@
+module SlowFat
+  class FileAllocationTable
+    attr_reader :chains, :base, :size
+
+    def initialize(backing:, base:, size:)
+      @backing = backing
+      @base = base
+      @size = size
+    end
+
+    def chain_starting_at(start_cluster)
+      current_cluster = start_cluster
+      current_chain = []
+      while current_cluster < @size/2
+        @backing.seek base + current_cluster * 2
+        (next_cluster, junk) = @backing.read(2).unpack('v')
+        if(current_cluster+1 == size/2) then
+          #printf("current: 0x%02X next: FAT END\n", current_cluster)
+          current_chain << current_cluster
+          return current_chain == [] ? [start_cluster] : current_chain
+        elsif(next_cluster >= 0xFFF8 and next_cluster <= 0xFFFF) then
+          # end of cluster marker
+          #printf("current: 0x%02X next: EOC (0x%02X)\n", current_cluster, current_cluster+1)
+          current_chain << current_cluster
+          return current_chain == [] ? [start_cluster] : current_chain
+        elsif(next_cluster == 0x0000) then
+          #printf("current: 0x%02X next: FREE (0x%02X)\n", current_cluster, current_cluster+1)
+          current_cluster = current_cluster + 1
+        else
+          # link to next cluster
+          #printf("current: 0x%02X next: 0x%02X\n", current_cluster, next_cluster)
+          current_chain << current_cluster
+          current_cluster = next_cluster
+        end
+      end
+    end
+  end
+end

data/lib/slowfat/filesystem.rb

@@ -0,0 +1,63 @@
+module SlowFat
+  class Filesystem
+    attr_reader :backing, :rootdir_base, :rootdir, :data_base, :fats, :cluster_size
+
+    def initialize(backing:)
+      # TODO: this needs to be more flexible
+      @base = 0x0000
+      @backing = backing
+
+      fat_base = @base + 512
+      fat_size = bios_parameter_block.bytes_per_logsect * bios_parameter_block.logsects_per_fat
+      # TODO: shouldn't assume there's always two FATs
+      @fats = []
+      @fats[0] = FileAllocationTable.new(backing: backing, base: fat_base, size: fat_size)
+      @fats[1] = FileAllocationTable.new(backing: backing, base: fat_base + fat_size, size: fat_size)
+
+      # TODO: maybe shouldn't load the whole rootdir by default, I/O-wise?
+      @rootdir_base = fat_base + fat_size*2
+      @rootdir = Directory.new(backing: backing, base: rootdir_base, max_entries: bios_parameter_block.root_entries)
+      @cluster_size = bios_parameter_block.bytes_per_logsect * bios_parameter_block.logsects_per_cluster
+      @data_base = rootdir_base + bios_parameter_block.root_entries * 32 - @cluster_size*2
+    end
+
+    def bootsect
+      @backing.seek @base
+      BootSector.new @backing.read(512)
+    end
+
+    def bios_parameter_block
+      bootsect.bios_parameter_block
+    end
+
+    def extended_bios_parameter_block
+      bootsect.extended_bios_parameter_block
+    end
+
+    def dir(dirname)
+      path_elements = dirname.split('/')
+      current_dir_base = @rootdir_base
+      next_dir = nil
+      max_entries = 32
+      path_elements.each do |path_element|
+        this_dir = Directory.new(backing: @backing, base: current_dir_base, max_entries: max_entries)
+        next_dir = this_dir.dir_entry(path_element)
+        return nil if next_dir == nil
+        next_dir_base = @data_base + next_dir.start_cluster*@cluster_size
+        # all directories except the root have more entries available
+        max_entries = @cluster_size/32
+        current_dir_base = next_dir_base
+      end
+
+      Directory.new(backing: @backing, base: current_dir_base, max_entries: max_entries)
+    end
+
+    def file(path)
+      path_components = path.split('/')
+      dir_components = path_components[0..-2]
+      filename = path_components[-1]
+      dentry = dir(dir_components.join('/')).file_entry(filename)
+      FatFile.new filesystem: self, dentry: dentry
+    end
+  end
+end

data/lib/slowfat/version.rb

@@ -0,0 +1,4 @@
+module SlowFat
+  # The version number of the SlowFat module.
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: slowfat
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- sarahemm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-04-17 00:00:00.000000000 Z
+dependencies: []
+description: FAT filesystem library for use with slow I/O (e.g. serial links)
+email: github@sen.cx
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/slowfat.rb
+- lib/slowfat/bootsect.rb
+- lib/slowfat/data.rb
+- lib/slowfat/dir.rb
+- lib/slowfat/fat_file.rb
+- lib/slowfat/file_alloc_table.rb
+- lib/slowfat/filesystem.rb
+- lib/slowfat/version.rb
+homepage: http://github.com/sarahemm/ruby-slowfat
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Slow I/O FAT interface library
+test_files: []