ffi-libarchive 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.1.0 / 2011-04-11
+
+* 1 major enhancement
+  * Birthday!

data/README.md

@@ -0,0 +1,70 @@
+ffi-libarchive
+==============
+
+An ffi binding to libarchive.
+
+This library provides ruby-bindings to the well-known
+[libarchive](http://code.google.com/p/libarchive/) library. It should be interface-compatible to libarchive-ruby and libarchive-ruby-swig gems.
+
+Why another binding? Because I often work on workstations without
+development libraries of libarchive installed. An FFI-based gem allows
+to use the library without the hassle of compiling native extensions.
+
+Note that this is not completely true for this library. Two methods,
+``Entry::copy_stat`` and ``Entry::copy_lstat`` require a small native
+extension through ``ffi-inliner``, though this does not require
+development files of libarchive but only of libc.
+
+Features
+--------
+
+* Compatible interface to libarchive-ruby Entry::copy_lstat and
+* Entry::copy_stat require ffi-inliner because of the platform
+  dependence of stat() and lstat() functions of libc
+
+Examples
+--------
+
+require 'ffi-libarchive'
+
+Requirements
+------------
+
+* ``ffi`` >= 1.0.0
+* ``ffi-inliner`` for ``Entry::copy_lstat`` and ``Entry::copy_stat``
+
+Install
+-------
+
+* gem install ffi-libarchive
+
+Author
+------
+
+Original author: Frank Fischer
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2011 Frank Fischer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+
+begin
+    require 'bones'
+rescue LoadError
+    abort '### Please install the "bones" gem ###'
+end
+
+task :default => 'test:run'
+task 'gem:release' => 'test:run'
+
+Bones {
+    name       'ffi-libarchive'
+    authors    'Frank Fischer'
+    email      'frank.fischer@mathematik.tu-chemnitz.de'
+    url        'http://darcsden.com/lyro/ffi-libarchive'
+    depend_on  'ffi', '~> 1.0.0'
+}
+

data/bin/ffi-libarchive-ruby

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib ffi-libarchive-ruby]))
+
+# Put your code here
+

data/lib/ffi-libarchive.rb

@@ -0,0 +1,60 @@
+
+module Archive
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  VERSION = ::File.read(PATH + 'version.txt').strip
+  # :startdoc:
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift LIBPATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift PATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module Archive
+
+Archive.require_all_libs_relative_to(__FILE__)
+

data/lib/ffi-libarchive/archive.rb

@@ -0,0 +1,306 @@
+require 'ffi'
+
+module Archive
+
+    module LibC
+        extend FFI::Library
+        ffi_lib FFI::Library::LIBC
+
+        attach_variable :errno, :int
+        attach_function :strerror, [:int], :string
+    end
+
+    module C
+        def self.attach_function_maybe *args
+            attach_function *args
+        rescue FFI::NotFoundError
+        end
+
+        extend FFI::Library
+        ffi_lib ["archive", "libarchive.so.2"]
+
+        attach_function :archive_version_number, [], :int
+        attach_function :archive_version_string, [], :string
+        attach_function :archive_error_string, [:pointer], :string
+        attach_function :archive_errno, [:pointer], :int
+
+        attach_function :archive_read_new, [], :pointer
+        attach_function :archive_read_open_filename, [:pointer, :string, :size_t], :int
+        attach_function :archive_read_open_memory, [:pointer, :pointer, :size_t], :int
+        attach_function :archive_read_support_compression_program, [:pointer, :string], :int
+        attach_function :archive_read_support_compression_all, [:pointer], :int
+        attach_function :archive_read_support_format_all, [:pointer], :int
+        # TODO: this function has been renamed to :archive_read_free in libarchive 3.0
+        attach_function :archive_read_finish, [:pointer], :int
+        attach_function :archive_read_extract, [:pointer, :pointer, :int], :int
+        attach_function :archive_read_header_position, [:pointer], :int
+        attach_function :archive_read_next_header, [:pointer, :pointer], :int
+        attach_function :archive_read_data, [:pointer, :pointer, :size_t], :size_t
+        attach_function :archive_read_data_into_fd, [:pointer, :int], :int
+
+        attach_function :archive_write_new, [], :pointer
+        attach_function :archive_write_open_filename, [:pointer, :string], :int
+        callback :archive_open_callback, [:pointer, :pointer], :int
+        callback :archive_write_callback, [:pointer, :pointer, :pointer, :size_t], :int
+        callback :archive_close_callback, [:pointer, :pointer], :int
+        attach_function :archive_write_open, [:pointer, :pointer, :archive_open_callback, :archive_write_callback, :archive_close_callback], :int
+        # TODO: catch errors if not defined
+        attach_function :archive_write_set_compression_none, [:pointer], :int
+        attach_function_maybe :archive_write_set_compression_gzip, [:pointer], :int
+        attach_function_maybe :archive_write_set_compression_bzip2, [:pointer], :int
+        attach_function_maybe :archive_write_set_compression_compress, [:pointer], :int
+        attach_function_maybe :archive_write_set_compression_lzma, [:pointer], :int
+        attach_function_maybe :archive_write_set_compression_xz, [:pointer], :int
+        attach_function :archive_write_set_compression_program, [:pointer, :string], :int
+
+        def self.archive_write_set_compression(archive, compression)
+            case compression
+            when String
+                archive_write_set_compression_program archive, compression
+            when COMPRESSION_BZIP2
+                archive_write_set_compression_bzip2 archive
+            when COMPRESSION_GZIP
+                archive_write_set_compression_gzip archive
+            when COMPRESSION_LZMA
+                archive_write_set_compression_lzma archive
+            when COMPRESSION_XZ
+                archive_write_set_compression_xz archive
+            when COMPRESSION_COMPRESS
+                archive_write_set_compression_compress archive
+            when COMPRESSION_NONE
+                archive_write_set_compression_none archive
+            else
+                raise "Unknown compression type: #{compression}"
+            end
+        end
+
+        attach_function :archive_write_set_format, [:pointer, :int], :int
+        attach_function :archive_write_data, [:pointer, :pointer, :size_t], :ssize_t
+        attach_function :archive_write_header, [:pointer, :pointer], :int
+        attach_function :archive_write_finish, [:pointer], :void
+        attach_function :archive_write_get_bytes_in_last_block, [:pointer], :int
+        attach_function :archive_write_set_bytes_in_last_block, [:pointer, :int], :int
+
+        attach_function :archive_entry_new, [], :pointer
+        attach_function :archive_entry_free, [:pointer], :void
+        attach_function :archive_entry_atime, [:pointer], :time_t
+        attach_function :archive_entry_atime_nsec, [:pointer, :time_t, :long], :void
+        attach_function_maybe :archive_entry_atime_is_set, [:pointer], :int
+        attach_function :archive_entry_set_atime, [:pointer, :time_t, :long], :int
+        attach_function_maybe :archive_entry_unset_atime, [:pointer], :int
+        attach_function_maybe :archive_entry_birthtime, [:pointer], :time_t
+        attach_function_maybe :archive_entry_birthtime_nsec, [:pointer, :time_t, :long], :void
+        attach_function_maybe :archive_entry_birthtime_is_set, [:pointer], :int
+        attach_function_maybe :archive_entry_set_birthtime, [:pointer, :time_t, :long], :int
+        attach_function_maybe :archive_entry_unset_birthtime, [:pointer], :int
+        attach_function :archive_entry_ctime, [:pointer], :time_t
+        attach_function :archive_entry_ctime_nsec, [:pointer, :time_t, :long], :void
+        attach_function_maybe :archive_entry_ctime_is_set, [:pointer], :int
+        attach_function :archive_entry_set_ctime, [:pointer, :time_t, :long], :int
+        attach_function_maybe :archive_entry_unset_ctime, [:pointer], :int
+        attach_function :archive_entry_mtime, [:pointer], :time_t
+        attach_function :archive_entry_mtime_nsec, [:pointer, :time_t, :long], :void
+        attach_function_maybe :archive_entry_mtime_is_set, [:pointer], :int
+        attach_function :archive_entry_set_mtime, [:pointer, :time_t, :long], :int
+        attach_function_maybe :archive_entry_unset_mtime, [:pointer], :int
+        attach_function :archive_entry_dev, [:pointer], :dev_t
+        attach_function :archive_entry_set_dev, [:pointer, :dev_t], :void
+        attach_function :archive_entry_devmajor, [:pointer], :dev_t
+        attach_function :archive_entry_set_devmajor, [:pointer, :dev_t], :void
+        attach_function :archive_entry_devminor, [:pointer], :dev_t
+        attach_function :archive_entry_set_devminor, [:pointer, :dev_t], :void
+        attach_function :archive_entry_filetype, [:pointer], :mode_t
+        attach_function :archive_entry_set_filetype, [:pointer, :mode_t], :void
+        attach_function :archive_entry_fflags, [:pointer, :pointer, :pointer], :void
+        attach_function :archive_entry_set_fflags, [:pointer, :ulong, :ulong], :void
+        attach_function :archive_entry_fflags_text, [:pointer], :string
+        attach_function :archive_entry_gid, [:pointer], :gid_t
+        attach_function :archive_entry_set_gid, [:pointer, :gid_t], :void
+        attach_function :archive_entry_gname, [:pointer], :string
+        attach_function :archive_entry_set_gname, [:pointer, :string], :void
+        attach_function :archive_entry_hardlink, [:pointer], :string
+        attach_function :archive_entry_set_hardlink, [:pointer, :string], :void
+        attach_function :archive_entry_set_link, [:pointer, :string], :void
+        attach_function :archive_entry_ino, [:pointer], :ino_t
+        attach_function :archive_entry_set_ino, [:pointer, :ino_t], :void
+        attach_function :archive_entry_mode, [:pointer], :mode_t
+        attach_function :archive_entry_set_mode, [:pointer, :mode_t], :void
+        attach_function :archive_entry_set_perm, [:pointer, :mode_t], :void
+        attach_function :archive_entry_nlink, [:pointer], :uint
+        attach_function :archive_entry_set_nlink, [:pointer, :uint], :void
+        attach_function :archive_entry_pathname, [:pointer], :string
+        attach_function :archive_entry_set_pathname, [:pointer, :string], :void
+        attach_function :archive_entry_rdev, [:pointer], :dev_t
+        attach_function :archive_entry_set_rdev, [:pointer, :dev_t], :void
+        attach_function :archive_entry_rdevmajor, [:pointer], :dev_t
+        attach_function :archive_entry_set_rdevmajor, [:pointer, :dev_t], :void
+        attach_function :archive_entry_rdevminor, [:pointer], :dev_t
+        attach_function :archive_entry_set_rdevminor, [:pointer, :dev_t], :void
+        attach_function :archive_entry_size, [:pointer], :int64_t
+        attach_function :archive_entry_set_size, [:pointer, :int64_t], :void
+        attach_function_maybe :archive_entry_unset_size, [:pointer], :void
+        attach_function_maybe :archive_entry_size_is_set, [:pointer], :int
+        attach_function :archive_entry_sourcepath, [:pointer], :string
+        attach_function :archive_entry_strmode, [:pointer], :string
+        attach_function :archive_entry_symlink, [:pointer], :string
+        attach_function :archive_entry_set_symlink, [:pointer, :string], :void
+        attach_function :archive_entry_uid, [:pointer], :uid_t
+        attach_function :archive_entry_set_uid, [:pointer, :uid_t], :void
+        attach_function :archive_entry_uname, [:pointer], :string
+        attach_function :archive_entry_set_uname, [:pointer, :string], :void
+        attach_function :archive_entry_copy_stat, [:pointer, :pointer], :void
+        attach_function :archive_entry_copy_fflags_text, [:pointer, :string], :string
+        attach_function :archive_entry_copy_gname, [:pointer, :string], :string
+        attach_function :archive_entry_copy_uname, [:pointer, :string], :string
+        attach_function :archive_entry_copy_hardlink, [:pointer, :string], :string
+        attach_function :archive_entry_copy_link, [:pointer, :string], :string
+        attach_function :archive_entry_copy_symlink, [:pointer, :string], :string
+        attach_function :archive_entry_copy_sourcepath, [:pointer, :string], :string
+        attach_function :archive_entry_copy_pathname, [:pointer, :string], :string
+        attach_function :archive_entry_xattr_clear, [:pointer], :void
+        attach_function :archive_entry_xattr_add_entry, [:pointer, :string, :pointer, :size_t], :void
+        attach_function :archive_entry_xattr_count, [:pointer], :int
+        attach_function :archive_entry_xattr_reset, [:pointer], :int
+        attach_function :archive_entry_xattr_next, [:pointer, :pointer, :pointer, :pointer], :int
+
+        EOF    = 1
+        OK     = 0
+        RETRY  = (-10)
+        WARN   = (-20)
+        FAILED = (-25)
+        FATAL  = (-30)
+
+        DATA_BUFFER_SIZE = 2**16
+    end
+
+    COMPRESSION_NONE     = 0
+    COMPRESSION_GZIP     = 1
+    COMPRESSION_BZIP2    = 2
+    COMPRESSION_COMPRESS = 3
+    COMPRESSION_PROGRAM  = 4
+    COMPRESSION_LZMA     = 5
+    COMPRESSION_XZ       = 6
+    COMPRESSION_UU       = 7
+    COMPRESSION_RPM      = 8
+
+    FORMAT_BASE_MASK           = 0xff0000
+    FORMAT_CPIO                = 0x10000
+    FORMAT_CPIO_POSIX          = (FORMAT_CPIO | 1)
+    FORMAT_CPIO_BIN_LE         = (FORMAT_CPIO | 2)
+    FORMAT_CPIO_BIN_BE         = (FORMAT_CPIO | 3)
+    FORMAT_CPIO_SVR4_NOCRC     = (FORMAT_CPIO | 4)
+    FORMAT_CPIO_SVR4_CRC       = (FORMAT_CPIO | 5)
+    FORMAT_SHAR                = 0x20000
+    FORMAT_SHAR_BASE           = (FORMAT_SHAR | 1)
+    FORMAT_SHAR_DUMP           = (FORMAT_SHAR | 2)
+    FORMAT_TAR                 = 0x30000
+    FORMAT_TAR_USTAR           = (FORMAT_TAR | 1)
+    FORMAT_TAR_PAX_INTERCHANGE = (FORMAT_TAR | 2)
+    FORMAT_TAR_PAX_RESTRICTED  = (FORMAT_TAR | 3)
+    FORMAT_TAR_GNUTAR          = (FORMAT_TAR | 4)
+    FORMAT_ISO9660             = 0x40000
+    FORMAT_ISO9660_ROCKRIDGE   = (FORMAT_ISO9660 | 1)
+    FORMAT_ZIP                 = 0x50000
+    FORMAT_EMPTY               = 0x60000
+    FORMAT_AR                  = 0x70000
+    FORMAT_AR_GNU              = (FORMAT_AR | 1)
+    FORMAT_AR_BSD              = (FORMAT_AR | 2)
+    FORMAT_MTREE               = 0x80000
+    FORMAT_RAW                 = 0x90000
+    FORMAT_XAR                 = 0xA0000
+
+    EXTRACT_OWNER              = (0x0001)
+    EXTRACT_PERM               = (0x0002)
+    EXTRACT_TIME               = (0x0004)
+    EXTRACT_NO_OVERWRITE       = (0x0008)
+    EXTRACT_UNLINK             = (0x0010)
+    EXTRACT_ACL                = (0x0020)
+    EXTRACT_FFLAGS             = (0x0040)
+    EXTRACT_XATTR              = (0x0080)
+    EXTRACT_SECURE_SYMLINKS    = (0x0100)
+    EXTRACT_SECURE_NODOTDOT    = (0x0200)
+    EXTRACT_NO_AUTODIR         = (0x0400)
+    EXTRACT_NO_OVERWRITE_NEWER = (0x0800)
+    EXTRACT_SPARSE             = (0x1000)
+
+    def self.read_open_filename file_name, command = nil, &block
+        Reader.open_filename file_name, command, &block
+    end
+
+    def self.read_open_memory string, command = nil, &block
+        Reader.open_memory string, command, &block
+    end
+
+    def self.write_open_filename file_name, compression, format, &block
+        Writer.open_filename file_name, compression, format, &block
+    end
+
+    def self.write_open_memory string, compression, format, &block
+        Writer.open_memory string, compression, format, &block
+    end
+
+    def self.version_number
+        C::archive_version_number
+    end
+
+    def self.version_string
+        C::archive_version_string
+    end
+
+    class Error < StandardError
+        def initialize(archive)
+            if archive.kind_of? String
+                super archive
+            else
+                super "#{C::archive_error_string(archive)}"
+            end
+        end
+    end
+
+    class BaseArchive
+
+        def initialize alloc, free
+            @archive = nil
+            @archive_free = nil
+            @archive = alloc.call
+            @archive_free = [nil]
+            raise Error, @archive unless @archive
+
+            @archive_free[0] = free
+            ObjectSpace.define_finalizer( self, BaseArchive.finalizer(@archive, @archive_free) )
+        end
+
+        def self.finalizer archive, archive_free
+            Proc.new do |*args|
+                archive_free[0].call(archive) if archive_free[0]
+            end
+        end
+
+        def close
+            # TODO: do we need synchronization here?
+            if @archive
+                # TODO: Error check?
+                @archive_free[0].call(@archive)
+            end
+        ensure
+            @archive = nil
+            @archive_free[0] = nil
+            @data = nil
+        end
+
+        def archive
+            raise Error, "No archive open" unless @archive
+            @archive
+        end
+        protected :archive
+
+        def error_string
+            C::archive_error_string(@archive)
+        end
+
+        def errno
+            C::archive_errno(@archive)
+        end
+    end
+
+end