libmspack 0.0.1

data/lib/libmspack/mschm.rb

@@ -0,0 +1,301 @@
+module LibMsPack
+    module MsChm
+        module Constants
+
+            MSCHMC_ENDLIST = 0
+            MSCHMC_UNCOMP = 1
+            MSCHMC_MSCOMP = 2
+
+            MSCHMC_PARAM_TIMESTAMP = 0
+            MSCHMC_PARAM_LANGUAGE = 1
+            MSCHMC_PARAM_LZXWINDOW = 2
+            MSCHMC_PARAM_DENSITY = 3
+            MSCHMC_PARAM_INDEX = 4
+
+        end
+
+        class MsChmcFile < FFI::Struct
+            layout({
+                :section => :int,
+                :filename => :string,
+                :chm_filename => :string,
+                :length => :off_t
+            })
+
+            def section
+                self[:section]
+            end
+
+            def filename
+                self[:filename]
+            end
+
+            def chm_filename
+                self[:chm_filename]
+            end
+
+            def length
+                self[:length]
+            end
+        end
+
+        class MsChmdHeader < FFI::Struct
+        end
+
+        class MsChmdSection < FFI::Struct
+            layout({
+                :chm => MsChmdHeader.ptr,
+                :id => :uint
+            })
+
+            def chm
+                return nil if self[:chm].pointer.address.zero?
+                self[:chm]
+            end
+
+            def id
+                self[:id]
+            end
+        end
+
+        class MsChmdFile < FFI::Struct
+            layout({
+                :next => MsChmdFile.ptr,
+                :section => MsChmdSection.ptr,
+                :offset => :off_t,
+                :length => :off_t,
+                :filename => :string
+            })
+
+            def next
+                return nil if self[:next].pointer.address.zero?
+                self[:next]
+            end
+
+            def section
+                return nil if self[:section].pointer.address.zero?
+                self[:section]
+            end
+
+            def offset
+                self[:offset]
+            end
+
+            def length
+                self[:length]
+            end
+
+            def filename
+                self[:filename]
+            end
+        end
+
+        class MsChmdSecUncompressed < FFI::Struct
+            layout({
+                :base => MsChmdSection,
+                :offset => :off_t
+            })
+
+            def base
+                self[:base]
+            end
+
+            def offset
+                self[:offset]
+            end
+        end
+
+        class MsChmdSecMscompressed < FFI::Struct
+            layout({
+                :base => MsChmdSection,
+                :content => MsChmdFile.ptr,
+                :control => MsChmdFile.ptr,
+                :rtable => MsChmdFile.ptr,
+                :spaninfo => MsChmdFile.ptr
+            })
+
+            def base
+                self[:base]
+            end
+
+            def content
+                return nil if self[:content].pointer.address.zero?
+                self[:content]
+            end
+
+            def control
+                return nil if self[:control].pointer.address.zero?
+                self[:control]
+            end
+
+            def rtable
+                return nil if self[:rtable].pointer.address.zero?
+                self[:rtable]
+            end
+
+            def spaninfo
+                return nil if self[:spaninfo].pointer.address.zero?
+                self[:spaninfo]
+            end
+        end
+
+        class MsChmdHeader < FFI::Struct
+            layout({
+                :version => :uint,
+                :timestamp => :uint,
+                :language => :uint,
+                :filename => :string,
+                :length => :off_t,
+                :files => MsChmdFile.ptr,
+                :sysfiles => MsChmdFile.ptr,
+                :sec0 => MsChmdSecUncompressed,
+                :sec1 => MsChmdSecMscompressed,
+                :dir_offset => :off_t,
+                :num_chunks => :uint,
+                :chunk_size => :uint,
+                :density => :uint,
+                :depth => :uint,
+                :index_root => :uint,
+                :first_pmgl => :uint,
+                :last_pmgl => :uint,
+                :chunk_cache => :pointer
+            })
+
+            def version
+                self[:version]
+            end
+
+            def timestamp
+                self[:timestamp]
+            end
+
+            def language
+                self[:language]
+            end
+
+            def filename
+                self[:filename]
+            end
+
+            def length
+                self[:length]
+            end
+
+            def files
+                return nil if self[:files].pointer.address.zero?
+                self[:files]
+            end
+
+            def sysfiles
+                return nil if self[:sysfiles].pointer.address.zero?
+                self[:sysfiles]
+            end
+
+            def sec0
+                self[:sec0]
+            end
+
+            def sec1
+                self[:sec1]
+            end
+
+            def dir_offset
+                self[:dir_offset]
+            end
+
+            def num_chunks
+                self[:num_chunks]
+            end
+
+            def chunk_size
+                self[:chunk_size]
+            end
+
+            def density
+                self[:density]
+            end
+
+            def depth
+                self[:depth]
+            end
+
+            def index_root
+                self[:index_root]
+            end
+
+            def first_pmgl
+                self[:first_pmgl]
+            end
+
+            def last_pmgl
+                self[:last_pmgl]
+            end
+
+            def chunk_cache
+                return nil if self[:chunk_cache].pointer.address.zero?
+                self[:chunk_cache]
+            end
+        end
+
+        class MsChmCompressor < FFI::Struct
+            layout({
+                :generate => callback([ MsChmCompressor.ptr, MsChmcFile.ptr, :string ], :int),
+                :use_temporary_file => callback([ MsChmCompressor.ptr, :int, :string ], :int),
+                :set_param => callback([ MsChmCompressor.ptr, :int, :uint ], :int),
+                :last_error => callback([ MsChmCompressor.ptr ], :int)
+            })
+
+            def generate(compressor, fileList, outputFile)
+                self[:generate].call(compressor, fileList, outputFile)
+            end
+
+            def use_temporary_file(compressor, useTempFile, tempFile)
+                self[:use_temporary_file].call(compressor, useTempFile, tempFile)
+            end
+
+            def set_param(compressor, param, value)
+                self[:set_param].call(compressor, param, value)
+            end
+
+            def last_error(compressor)
+                self[:last_error].call(compressor)
+            end
+        end
+
+        class MsChmDecompressor < FFI::Struct
+            layout({
+                :open => callback([ MsChmDecompressor.ptr, :string ], MsChmdHeader.ptr),
+                :close => callback([ MsChmDecompressor.ptr, MsChmdHeader.ptr ], :void),
+                :extract => callback([ MsChmDecompressor.ptr, MsChmdFile.ptr, :string ], :int),
+                :last_error => callback([ MsChmDecompressor.ptr ], :int),
+                :fast_open => callback([ MsChmDecompressor.ptr, :string ], MsChmdHeader.ptr),
+                :fast_find => callback([ MsChmDecompressor.ptr, MsChmdHeader.ptr, :string, MsChmdFile.ptr, :int ], :int)
+            })
+
+            def open(decompressor, filename)
+                self[:open].call(decompressor, filename)
+            end
+
+            def close(decompressor, chm)
+                self[:close].call(decompressor, chm)
+            end
+
+            def extract(decompressor, file, filename)
+                self[:extract].call(decompressor, file, filename)
+            end
+
+            def last_error(decompressor)
+                self[:last_error].call(decompressor)
+            end
+
+            def fast_open(decompressor, filename)
+                self[:fast_open].call(decompressor, filename)
+            end
+
+            def fast_find(decompressor, chm, filename, file, size)
+                self[:fast_find].call(decompressor, chm, filename, file, size)
+            end
+        end
+
+    end
+end

data/lib/libmspack/mshlp.rb

@@ -0,0 +1,15 @@
+module LibMsPack
+    module MsHlp
+        class MsHlpCompressor < FFI::Struct
+            layout({
+                :dummy => :int
+            })
+        end
+
+        class MsHlpDecompressor < FFI::Struct
+            layout({
+                :dummy => :int
+            })
+        end
+    end
+end

data/lib/libmspack/mskwaj.rb

@@ -0,0 +1,124 @@
+module LibMsPack
+    module MsKwaj
+        module Constants
+
+            MSKWAJC_PARAM_COMP_TYPE = 0
+            MSKWAJC_PARAM_INCLUDE_LENGTH = 1
+
+            MSKWAJ_COMP_NONE = 0
+            MSKWAJ_COMP_XOR = 1
+            MSKWAJ_COMP_SZDD = 2
+            MSKWAJ_COMP_LZH = 3
+            MSKWAJ_COMP_MSZIP = 4
+
+            MSKWAJ_HDR_HASLENGTH = 0x01
+            MSKWAJ_HDR_HASUNKNOWN1 = 0x02
+            MSKWAJ_HDR_HASUNKNOWN2 = 0x04
+            MSKWAJ_HDR_HASFILENAME = 0x08
+            MSKWAJ_HDR_HASFILEEXT = 0x10
+            MSKWAJ_HDR_HASEXTRATEXT = 0x20
+
+        end
+
+        class MsKwajdHeader < FFI::Struct
+            layout({
+                :comp_type => :ushort,
+                :data_offset => :off_t,
+                :headers => :int,
+                :length => :off_t,
+                :filename => :string,
+                :extra => :pointer,
+                :extra_length => :ushort
+            })
+
+            def comp_type
+                self[:comp_type]
+            end
+
+            def data_offset
+                self[:data_offset]
+            end
+
+            def headers
+                self[:headers]
+            end
+
+            def length
+                self[:length]
+            end
+
+            def filename
+                self[:filename]
+            end
+
+            def extra
+                self[:extra]
+            end
+
+            def extra_length
+                self[:extra_length]
+            end
+        end
+
+        class MsKwajCompressor < FFI::Struct
+            layout({
+                :compress => callback([ :pointer, :string, :string, :off_t ], :int),
+                :set_param => callback([ :pointer, :int, :uint ], :int),
+                :set_filename => callback([ :pointer, :string ], :int),
+                :set_extra_data => callback([ :pointer, :pointer, :uint ], :int),
+                :last_error => callback([ :pointer ], :int)
+            })
+
+            def compress
+                self[:compress]
+            end
+
+            def set_param
+                self[:set_param]
+            end
+
+            def set_filename
+                self[:set_filename]
+            end
+
+            def set_extra_data
+                self[:set_extra_data]
+            end
+
+            def last_error
+                self[:last_error]
+            end
+        end
+
+        class MsKwajDecompressor < FFI::Struct
+            layout({
+                :open => callback([ :pointer, :string ], :pointer),
+                :close => callback([ :pointer, :pointer ], :void),
+                :extract => callback([ :pointer, :pointer, :string ], :int),
+                :decompress => callback([ :pointer, :string, :string ], :int),
+                :last_error => callback([ :pointer ], :int)
+            })
+
+            def open
+                self[:open]
+            end
+
+            def close
+                self[:close]
+            end
+
+            def extract
+                self[:extract]
+            end
+
+            def decompress
+                self[:decompress]
+            end
+
+            def last_error
+                self[:last_error]
+            end
+        end
+
+    end
+end

data/lib/libmspack/mslit.rb

@@ -0,0 +1,18 @@
+module LibMsPack
+    module MsLit
+        module Constants
+        end
+
+        class MsLitCompressor < FFI::Struct
+            layout({
+                :dummy => :int
+            })
+        end
+
+        class MsLitDecompressor < FFI::Struct
+            layout({
+                :dummy => :int
+            })
+        end
+    end
+end

data/lib/libmspack/msoab.rb

@@ -0,0 +1,36 @@
+module LibMsPack
+    module MsOab
+        class MsoabCompressor < FFI::Struct
+            layout({
+                :compress => callback([ :pointer, :string, :string ], :int),
+                :compress_incremental => callback([ :pointer, :string, :string, :string ], :int)
+            })
+
+            def compress
+                self[:compress]
+            end
+
+            def compress_incremental
+                self[:compress_incremental]
+            end
+
+        end
+
+        class MsoabDecompressor < FFI::Struct
+            layout({
+                :decompress => callback([ :pointer, :string, :string ], :int),
+                :decompress_incremental => callback([ :pointer, :string, :string, :string ], :int)
+            })
+
+            def decompress
+                self[:decompress]
+            end
+
+            def decompress_incremental
+                self[:decompress_incremental]
+            end
+
+        end
+
+    end
+end

data/lib/libmspack/mspack.rb

@@ -0,0 +1,208 @@
+module LibMsPack
+    module MsPack
+        module Constants
+            # Pass to #Version to get the overall library version.
+            MSPACK_VER_LIBRARY = 0
+            # Pass to #Version to get the MsPackSystem version.
+            MSPACK_VER_SYSTEM = 1
+            # Pass to #Version to get the MsCabDecompressor version.
+            MSPACK_VER_MSCABD = 2
+            # Pass to #Version to get the MsCabCompressor version.
+            MSPACK_VER_MSCABC = 3
+            # Pass to #Version to get the MsChmDecompressor version.
+            MSPACK_VER_MSCHMD = 4
+            # Pass to #Version to get the MsChmCompressor version.
+            MSPACK_VER_MSCHMC = 5
+            # Pass to #Version to get the MsLitDecompressor version.
+            MSPACK_VER_MSLITD = 6
+            # Pass to #Version to get the MsLitCompressor version.
+            MSPACK_VER_MSLITC = 7
+            # Pass to #Version to get the MsHlpDecompressor version.
+            MSPACK_VER_MSHLPD = 8
+            # Pass to #Version to get the MsHlpCompressor version.
+            MSPACK_VER_MSHLPC = 9
+            # Pass to #Version to get the MsSzddDecompressor version.
+            MSPACK_VER_MSSZDDD = 10
+            # Pass to #Version to get the MsSzddCompressor version.
+            MSPACK_VER_MSSZDDC = 11
+            # Pass to #Version to get the MsKwajDecompressor version.
+            MSPACK_VER_MSKWAJD = 12
+            # Pass to #Version to get the MsKwajCompressor version.
+            MSPACK_VER_MSKWAJC = 13
+            # Pass to #Version to get the MsOabDecompressor version.
+            MSPACK_VER_MSOABD = 14
+            # Pass to #Version to get the MsOabCompressor version.
+            MSPACK_VER_MSOABC = 15
+
+            # MsPackSystem#open mode: open existing file for reading
+            MSPACK_SYS_OPEN_READ = 0
+            # MsPackSystem#open mode: open new file for writing
+            MSPACK_SYS_OPEN_WRITE = 1
+            # MsPackSystem#open mode: open existing file for writing
+            MSPACK_SYS_OPEN_UPDATE = 2
+            # MsPackSystem#open mode: open existing file for writing
+            MSPACK_SYS_OPEN_APPEND = 3
+
+            # MsPackSystem#seek mode: seek relative to start of file
+            MSPACK_SYS_SEEK_START = 0
+            # MsPackSystem#seek mode: seek relative to current offset
+            MSPACK_SYS_SEEK_CUR = 1
+            # MsPackSystem#seek mode: seek relative to end of file
+            MSPACK_SYS_SEEK_END = 2
+
+            # Error code: no error.
+            MSPACK_ERR_OK = 0
+            # Error code: bad arguments to method.
+            MSPACK_ERR_ARGS = 1
+            # Error code: error opening file.
+            MSPACK_ERR_OPEN = 2
+            # Error code: error reading file.
+            MSPACK_ERR_READ = 3
+            # Error code: error writing file.
+            MSPACK_ERR_WRITE = 4
+            # Error code: seek error.
+            MSPACK_ERR_SEEK = 5
+            # Error code: out of memory.
+            MSPACK_ERR_NOMEMORY = 6
+            # Error code: bad "magic id" in file.
+            MSPACK_ERR_SIGNATURE = 7
+            # Error code: bad or corrupt file format.
+            MSPACK_ERR_DATAFORMAT = 8
+            # Error code: bad checksum or CRC.
+            MSPACK_ERR_CHECKSUM = 9
+            # Error code: error during compression.
+            MSPACK_ERR_CRUNCH = 10
+            # Error code: error during decompression.
+            MSPACK_ERR_DECRUNCH = 11
+        end
+
+        # A structure which represents an open file handle.
+        #
+        # The contents of this structure are determined by the implementation of the MsPackSystem#open method.
+        class MsPackFile < FFI::Struct
+            layout({
+                :file => :int,
+                :name => :string
+            })
+
+            def file=(file)
+                self[:file] = file
+            end
+
+            def file
+                self[:file]
+            end
+
+            def name
+                self[:name]
+            end
+        end
+
+        # A structure which abstracts file I/O and memory management.
+        #
+        # The library always uses the MsPackSystem structure for interaction with the file system and to allocate, free and copy all memory. It also uses it to send literal messages to the library user.
+        #
+        # When the library is compiled normally, passing nil to a compressor or decompressor constructor will result in a default MsPackSystem being used, where all methods are implemented with the standard C library. However, all constructors support being given a custom created MsPackSystem structure, with the library user's own methods. This allows for more abstract interaction, such as reading and writing files directly to memory, or from a network socket or pipe.
+        #
+        # Implementors of an MsPackSystem structure should read all documentation entries for every structure member, and write methods which conform to those standards.
+        class MsPackSystem < FFI::Struct
+
+            layout({
+                :open => callback([ MsPackSystem.ptr, :string, :int ], MsPackFile.ptr),
+                :close => callback([ MsPackFile.ptr ], :void),
+                :read => callback([ MsPackFile.ptr, :buffer_inout, :int ], :int),
+                :write => callback([ MsPackFile.ptr, :buffer_inout, :int ], :int),
+                :seek => callback([ MsPackFile.ptr, :off_t, :int ], :int),
+                :tell => callback([ MsPackFile.ptr ], :off_t),
+                :message => callback([ MsPackFile.ptr, :string, :varargs ], :void),
+                :alloc => callback([ MsPackFile.ptr, :size_t ], :pointer),
+                :free => callback([ :pointer ], :void),
+                :copy => callback([:buffer_in, :buffer_out, :size_t ], :void),
+                :null_ptr => :pointer
+            })
+
+            def open=(cb)
+                self[:open] = cb
+            end
+
+            def open
+                self[:open]
+            end
+
+            def close=(cb)
+                self[:close] = cb
+            end
+
+            def close
+                self[:close]
+            end
+
+            def read=(cb)
+                self[:read] = cb
+            end
+
+            def read
+                self[:read]
+            end
+
+            def write=(cb)
+                self[:write] = cb
+            end
+
+            def write
+                self[:write]
+            end
+
+            def seek=(cb)
+                self[:seek] = cb
+            end
+
+            def seek
+                self[:seek]
+            end
+
+            def tell=(cb)
+                self[:tell] = cb
+            end
+
+            def tell
+                self[:tell]
+            end
+
+            def message=(cb)
+                self[:message] = cb
+            end
+
+            def message
+                self[:message]
+            end
+
+            def alloc=(cb)
+                self[:alloc] = cb
+            end
+
+            def alloc
+                self[:alloc]
+            end
+
+            def free=(cb)
+                self[:free] = cb
+            end
+
+            def free
+                self[:free]
+            end
+
+            def copy=(cb)
+                self[:copy] = cb
+            end
+
+            def copy
+                self[:copy]
+            end
+
+        end
+
+        RubyPackSystem = MsPackSystem.new
+    end
+end