jphastings-unrar 0.2.1

data/unrar.rb

@@ -0,0 +1,147 @@
+# = Unrar
+# A pure ruby implementation of unrar.
+# == Features
+# * Allows you to stream data from archives, even if they're not complete
+# * Cross-Platform
+# * No dependencies
+#
+# == Drawbacks
+# * Doesn't yet support compression
+# * Doesn't yet support encryption (though the frame work is in place - does anybody know the spec?)
+# * Doesn't quite support multi-part archives (nearly there tho!)
+
+class Unrar
+  # Flags (in little endian)
+  # Archive flags
+  ARCH_VOLUME     = 0x0100
+  ARCH_LOCKED     = 0x0400
+  ARCH_IS_SOLID   = 0x0800
+  ARCH_NEW_NAMES  = 0x1000
+  ARCH_RECOVERY   = 0x4000
+  ARCH_ENC_HEAD   = 0x8000
+  ARCH_FIRST_PART = 0x0001
+  # File flags
+  FILE_CONTINUED  = 0x0100
+  FILE_CONTINUES  = 0x0200
+  FILE_PASSWORDED = 0x0400
+  FILE_IS_SOLID   = 0x1000
+  FILE_HIGH_PACK  = 0x0001
+  FILE_UNICODED   = 0x0002
+  FILE_IS_SALTED  = 0x0004
+  FILE_EXT_TIME   = 0x0010
+  FILE_MORE_SIZE  = 0x0080
+  # OSes
+  OSes = ['MS DOS','OS/2','Win32','Unix','Mac OS','BeOS']
+  # Attributes
+  Attr = [:packed_size,:real_size,:os,:filename]
+  
+  # Opens a RAR file and parses the header data
+  def initialize(filename)
+    @fh = open(File.expand_path(filename),"r")
+    @eof = false
+    # check marker header
+    parse_header
+  end
+  
+  # Lists the files in this archive
+  def list_contents
+    @fh.seek(7)
+    parse_header # The archive header
+    @files = []
+    begin
+      while
+        file = parse_header(true)
+        @files.push file
+        # Speed past any data in the file
+        @fh.seek(file[:packed_size],IO::SEEK_CUR)
+      end
+    rescue EOFError
+    end
+    @files
+  end
+  
+  # Gets the file id of the filename given in the archive
+  def getid(fname)
+    list_contents if @files.nil?
+    @files.each_index do |n|
+      if @files[n][:filename] == fname
+        fid = n
+        break
+      end
+    end
+    raise StandardError, "That file does not exist" if (fid >= @files.length) or fid.nil?
+    fid
+  end
+  
+  # Gets you the data from a given file (by file id). Allows you to specify to start from a specific point (so you can access the contained file from any point for streaming) and how many bytes you want extracted
+  def extract(fid,offset = 0,amount = nil)
+    list_contents if @files.nil?
+    fid = getid(fid) if fid.class != Fixnum
+    raise StandardError, "That file does not exist" if fid >= @files.length
+    amount = @files[fid][:packed_size] - offset if amount.nil?
+    @fh.seek(@files[fid][:datastart] + offset)
+    @fh.read(amount)
+  end
+  
+  private
+  def parse_header(full = false)
+    @fh.seek(2,IO::SEEK_CUR) # I don't use the CRC
+    details = {}
+    
+    case @fh.readpartial(1)[0]
+    when 0x72
+      raise StandardError, "Not a valid RAR file" if @fh.readpartial(4).unpack("vv") != [6689,7]
+      return true
+    when 0x73
+      block = :archive
+      full = false
+    when 0x74
+      block = :file
+    when 0x7b
+      block = :eof
+      raise EOFError
+      return
+    else
+      raise NotImplementedError, "The HEAD_TYPE encountered is not one this library supports"
+    end
+      
+    details[:blockstart] = @fh.pos - 3
+    @flags  = @fh.readpartial(2).unpack("v")[0]
+    details[:head_size] = @fh.readpartial(2).unpack("v")[0]
+    details[:datastart] = details[:blockstart] + details[:head_size]
+    
+    if ((@flags & FILE_MORE_SIZE != 0) or block == :file)
+      details[:packed_size] = @fh.readpartial(4).unpack("V")[0]
+      if (@flags & FILE_HIGH_PACK != 0)
+        # High packing used (over 2Gb size)
+        @fh.seek(21,IO::SEEK_CUR)
+        details[:packed_size] += @fh.readpartial(4).unpack("V")[0]
+        @fh.seek(-25,IO::SEEK_CUR)
+      end
+    else
+      details[:packed_size] = 0
+    end
+    
+    if full
+      details[:real_size] = @fh.readpartial(4).unpack("V")[0]
+      details[:os]   = OSes[@fh.readpartial(1).unpack("h")[0].to_i]
+      @fh.seek(4,IO::SEEK_CUR) # The file CRC, not used at the moment...
+      # DOS date/time
+      @fh.readpartial(4).unpack("v").collect{|t| ((t & 0xF800) >> 11) + ((t & 0x07E0) >> 5)*60 + ((t & 0x001F) * 3600)}[0] # - just the time section atm
+      @fh.seek(1,IO::SEEK_CUR) # RAR version, ought to check this
+      details[:compression_level] = @fh.readpartial(1)[0] - 0x30
+      fnamelength = @fh.readpartial(2).unpack("v")[0]
+      details[:attributes] = @fh.readpartial(4).unpack("V")[0]
+      if (@flags & FILE_HIGH_PACK != 0)
+        @fh.seek(4,IO::SEEK_CUR) # We already got the full pack size above
+        details[:size] += @fh.readpartial(4).unpack("V")[0] * 0x100000000
+      end
+      details[:filename] = @fh.readpartial(fnamelength).unpack("a*")[0]
+      
+    end
+    
+    # ff to the end of the header
+    @fh.seek(details[:blockstart] + details[:head_size])
+    return details if full
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+name: jphastings-unrar
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- JP Hastings-Spital
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Pure ruby implementation of RarLabs' Unrar software. Doesn't yet support encryption or compression. Written to allow streaming of data from archives.
+email: unrar@projects.kedakai.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- unrar.rb
+has_rdoc: true
+homepage: http://projects.kedakai.co.uk/unrar/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Pure ruby implementation of RarLabs' Unrar software. Doesn't yet support encryption or compression. Written to allow streaming of data from archives.
+test_files: []
+