ffi_libarchive 1.1.0

data/lib/ffi_libarchive/reader.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Archive
+  class Reader < BaseArchive
+    private_class_method :new
+
+    # @param [String] file_name
+    # @return [Reader]
+    # @yieldparam [Reader]
+    def self.open_filename(file_name, command = nil)
+      if block_given?
+        reader = open_filename file_name, command
+        begin
+          yield reader
+        ensure
+          reader.close if reader.respond_to?(:close)
+        end
+      else
+        new file_name: file_name, command: command
+      end
+    end
+
+    # @param [String] string
+    # @return [Reader]
+    # @yieldparam [Reader]
+    def self.open_memory(string, command = nil)
+      if block_given?
+        reader = open_memory string, command
+        begin
+          yield reader
+        ensure
+          reader.close if reader.respond_to?(:close)
+        end
+      else
+        new memory: string, command: command
+      end
+    end
+
+    # @param [#call] stream
+    # @return [Reader]
+    # @yieldparam [Reader]
+    def self.open_stream(stream, command = nil)
+      if block_given?
+        reader = open_stream stream, command
+        begin
+          yield reader
+        ensure
+          reader.close if reader.respond_to?(:close)
+        end
+      else
+        new reader: stream, command: command
+      end
+    end
+
+    # @param [Hash] params
+    # @option params [Object] :command
+    # @option params [String] :file_name
+    # @option params [String] :memory
+    # @option params [#call] :reader
+    def initialize(params = {})
+      super C.method(:archive_read_new), C.method(:archive_read_free)
+
+      begin
+        init_compression params[:command]
+        init_format
+
+        if params[:file_name]
+          init_for_filename params[:file_name]
+        elsif params[:memory]
+          init_for_memory params[:memory]
+        elsif params[:reader]
+          init_for_stream params[:reader]
+        end
+      rescue StandardError
+        close
+        raise
+      end
+    end
+
+    # @param [Entry] entry
+    # @param [Integer] flags  see ::EXTRACT_*
+    def extract(entry, flags = 0)
+      raise ArgumentError, 'Expected Archive::Entry as first argument' unless entry.is_a? Entry
+      raise ArgumentError, 'Expected Integer as second argument' unless flags.is_a? Integer
+
+      flags |= EXTRACT_FFLAGS
+      raise Error, self if C.archive_read_extract(archive, entry.entry, flags) != C::OK
+    end
+
+    # Retrieve the byte offset in UNCOMPRESSED data where last-read header started.
+    # @return [Integer]
+    def header_position
+      C.archive_read_header_position archive
+    end
+
+    # @return [Entry]
+    def next_header
+      entry_ptr = FFI::MemoryPointer.new(:pointer)
+
+      case C.archive_read_next_header(archive, entry_ptr)
+      when C::OK
+        Entry.from_pointer entry_ptr.get_pointer(0)
+      when C::EOF
+        nil
+      else
+        raise Error, self
+      end
+    end
+
+    # @yieldparam [Entry]
+    def each_entry
+      while (entry = next_header)
+        yield entry
+      end
+    end
+
+    # @yieldparam [Entry] entry
+    # @yieldparam [String] data
+    def each_entry_with_data(size = C::DATA_BUFFER_SIZE)
+      while (entry = next_header)
+        yield entry, read_data(size)
+      end
+    end
+
+    # @yieldparam [Entry] entry
+    def each_entry_skip_data
+      while (entry = next_header)
+        begin
+          yield entry
+        ensure
+          C.archive_read_data_skip archive
+        end
+      end
+    end
+
+    # @return [String, Integer]
+    # @yieldparam [String] chunk
+    def read_data(size = C::DATA_BUFFER_SIZE)
+      raise ArgumentError, "Buffer size must be > 0 (was: #{size})" if !size.is_a?(Integer) || size <= 0
+
+      data   = nil
+      buffer = FFI::MemoryPointer.new(:char, size)
+      len    = 0
+
+      while (n = C.archive_read_data(archive, buffer, size)) != 0
+        # TODO: C::FATAL, C::WARN, C::RETRY
+        raise Error, self if n < 0
+
+        chunk = buffer.get_bytes(0, n)
+        if block_given?
+          yield chunk
+        elsif data
+          data << chunk
+        else
+          data = chunk.dup
+        end
+
+        len += n
+      end
+
+      data || len
+    end
+
+    # @param [String] file_name
+    def save_data(file_name)
+      File.open(file_name, 'wb') do |f|
+        raise Error, self if C.archive_read_data_into_fd(archive, f.fileno) != C::OK
+      end
+    end
+
+    protected
+
+    def init_compression(command)
+      if command && !(cmd = command.to_s).empty?
+        raise Error, self if C.archive_read_support_compression_program(archive, cmd) != C::OK
+      elsif C.respond_to?(:archive_read_support_filter_all)
+        raise Error, self if C.archive_read_support_filter_all(archive) != C::OK
+      elsif C.archive_read_support_compression_all(archive) != C::OK
+        raise Error, self
+      end
+    end
+
+    def init_format
+      raise Error, self if C.archive_read_support_format_all(archive) != C::OK
+    end
+
+    BLOCK_SIZE = 1024
+
+    def init_for_filename(file_name)
+      raise Error, self if C.archive_read_open_filename(archive, file_name, BLOCK_SIZE) != C::OK
+    end
+
+    def init_for_memory(string)
+      buffer = Utils.get_memory_ptr(string)
+      raise Error, self if C.archive_read_open_memory(archive, buffer, string.bytesize) != C::OK
+    end
+
+    def init_for_stream(reader)
+      read_callback = proc do |_ar, _client_data, buffer|
+        # @type [String]
+        data = reader.call
+
+        if data.is_a?(String)
+          buffer.put_pointer 0, Utils.get_memory_ptr(data)
+          data.bytesize
+        else
+          0
+        end
+      end
+      raise Error, self if C.archive_read_set_read_callback(archive, read_callback) != C::OK
+
+      if reader.respond_to?(:skip)
+        skip_callback = proc { |_ar, _client_data, request| reader.skip(request) }
+        raise Error, self if C.archive_read_set_skip_callback(archive, skip_callback) != C::OK
+      end
+
+      if reader.respond_to?(:seek)
+        seek_callback = proc { |_ar, _client_data, offset, whence| reader.seek(offset, whence) }
+        raise Error, self if C.archive_read_set_seek_callback(archive, seek_callback) != C::OK
+      end
+
+      # Required or open1 will segfault, even though the callback data is not used.
+      raise Error, self if C.archive_read_set_callback_data(archive, FFI::Pointer::NULL) != C::OK
+      raise Error, self if C.archive_read_open1(archive) != C::OK
+    end
+  end
+end

data/lib/ffi_libarchive/utils.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Archive
+  module Utils
+    module LibC
+      extend FFI::Library
+      ffi_lib FFI::Library::LIBC
+
+      # @!method mbstowcs(dest, src, max)
+      #   Convert multibyte string to wide-character string
+      #   @param [FFI::Pointer] dest of :wchar_t*
+      #   @param [String] src
+      #   @param [Integer] max  Maximum number of :wchar_t characters to write to dest
+      #   @return [Integer] Number of wide characters written to dest (excluding null-terminated), or -1 if error
+      attach_function :mbstowcs, [:pointer, :string, :size_t], :size_t
+
+      # @!method chdir(path)
+      #   Changes the current working directory
+      #   @param [String] path
+      #   @return [Integer] 0 if successful. Otherwise, -1
+      begin
+        attach_function :chdir, [:string], :int
+      rescue FFI::NotFoundError
+        attach_function :chdir, :_chdir, [:string], :int
+      end
+    end
+
+    WCHAR_ENCODINGS = {
+      'UTF-16LE' => "!\x00@\x00\x00\x00",
+      'UTF-16BE' => "\x00!\x00@\x00\x00",
+      'UTF-32LE' => "!\x00\x00\x00@\x00",
+      'UTF-32BE' => "\x00\x00\x00!\x00\x00"
+    }.freeze
+
+    class << self
+      # @return [String]
+      def wchar_encoding
+        @wchar_encoding ||=
+          begin
+            ptr = FFI::MemoryPointer.new :char, 12
+            rc  = LibC.mbstowcs ptr, '!@', 3
+
+            str = ptr.get_bytes 0, 6
+            enc = WCHAR_ENCODINGS.key(str)
+            raise "Unsupported wide-character: #{rc} - #{str.inspect}" unless enc
+
+            enc
+          end
+      end
+
+      # @param [FFI::Pointer] ptr
+      # @return [String]
+      def read_wide_string(ptr)
+        return nil if !ptr.respond_to?(:null?) || ptr.null?
+
+        if wchar_encoding.include?('32')
+          wchar_sz = 4
+          wchar_t  = :int32
+        else
+          wchar_sz = 2
+          wchar_t  = :int16
+        end
+
+        # detect string length in bytes
+        sz = ptr.size
+        sz -= wchar_sz if sz
+
+        len = 0
+        len += wchar_sz while (!sz || len < sz) && ptr.send("get_#{wchar_t}", len) != 0
+
+        ptr.get_bytes(0, len).force_encoding(wchar_encoding)
+      end
+
+      # @param [String] str
+      # @return [String]
+      def to_wide_string(str)
+        str ? str.encode(wchar_encoding) : str
+      end
+
+      # @param [String] dir
+      # @return [Integer]
+      def change_cwd(dir)
+        if block_given?
+          # @type [String]
+          cwd = Dir.getwd
+          change_cwd dir
+
+          begin
+            yield
+          ensure
+            change_cwd cwd
+          end
+        else
+          rc = Dir.chdir dir
+          rc != 0 ? rc : LibC.chdir(dir)
+        end
+      end
+
+      # @param [String] string  MANDATORY
+      # @return [FFI::Pointer]
+      # @yieldparam [FFI::Pointer]
+      def get_memory_ptr(string)
+        len = string.bytesize
+        if block_given?
+          FFI::MemoryPointer.new(:char, len, false) do |ptr|
+            ptr.put_bytes(0, string, 0, len)
+            yield ptr
+          end
+        else
+          ptr = FFI::MemoryPointer.new(:char, len, false)
+          ptr.put_bytes(0, string, 0, len)
+          ptr
+        end
+      end
+    end
+  end
+end

data/lib/ffi_libarchive/writer.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Archive
+  class Writer < BaseArchive
+    private_class_method :new
+
+    # @param [String] file_name
+    # @return [Writer]
+    # @yieldparam [Writer]
+    def self.open_filename(file_name, compression, format)
+      if block_given?
+        writer = open_filename file_name, compression, format
+
+        begin
+          yield writer
+        ensure
+          writer.close if writer.respond_to?(:close)
+        end
+      else
+        new file_name: file_name, compression: compression, format: format
+      end
+    end
+
+    # @param [String] string
+    # @return [Writer]
+    # @yieldparam [Writer]
+    def self.open_memory(string, compression, format)
+      if block_given?
+        writer = open_memory string, compression, format
+
+        begin
+          yield writer
+        ensure
+          writer.close if writer.respond_to?(:close)
+        end
+      else
+        new memory: string, compression: compression, format: format
+      end
+    end
+
+    # @param [Hash] params
+    # @option params [Object] :compression
+    # @option params [Object] :format
+    # @option params [String] :file_name
+    # @option params [String] :memory
+    def initialize(params = {})
+      super C.method(:archive_write_new), C.method(:archive_write_free)
+
+      begin
+        init_compression params[:compression]
+        init_format params[:format]
+
+        if params[:file_name]
+          init_for_filename params[:file_name]
+        elsif params[:memory]
+          init_for_memory params[:memory]
+        end
+      rescue StandardError
+        close
+        raise
+      end
+    end
+
+    # @return [Entry]
+    # @yieldparam [Entry]
+    def new_entry
+      entry = Entry.new
+
+      if block_given?
+        begin
+          yield entry
+        ensure
+          entry.close
+        end
+      else
+        entry
+      end
+    end
+
+    # @raise [ArgumentError] If no block given
+    # @return [NilClass]
+    # @yieldparam [Entry]
+    # @yieldreturn [String]
+    def add_entry
+      raise ArgumentError, 'No block given' unless block_given?
+
+      entry = Entry.new
+      begin
+        data = yield entry
+
+        if data
+          entry.size = data.bytesize
+
+          write_header entry
+          write_data data
+        else
+          write_header entry
+        end
+
+        nil
+      ensure
+        entry.close
+      end
+    end
+
+    # @param [Array<String>] args
+    # @return [Integer]
+    # @raise [ArgumentError]
+    # @yieldreturn [String]
+    def write_data(*args)
+      if block_given?
+        raise ArgumentError, 'Not support arguments when block given' unless args.empty?
+
+        len = 0
+        loop do
+          str = yield len
+          n   = str.is_a?(String) ? C.archive_write_data(archive, Utils.get_memory_ptr(str), str.bytesize) : 0
+
+          raise Error, self if n < 0
+          break if n.zero?
+
+          len += n
+        end
+
+        len
+      else
+        str = args[0]
+        raise ArgumentError, 'Invalid String argument' unless str.is_a?(String)
+
+        n = C.archive_write_data(archive, Utils.get_memory_ptr(str), str.bytesize)
+        raise Error, self if n < 0
+
+        n
+      end
+    end
+
+    # @param [Entry] entry
+    def write_header(entry)
+      raise Error, self if C.archive_write_header(archive, entry.entry) != C::OK
+    end
+
+    protected
+
+    def init_compression(compression)
+      raise ArgumentError, 'Missing :compression argument' if !compression || compression.to_s.empty?
+
+      unless compression.is_a?(Integer) || compression.is_a?(String)
+        prefix      = C.respond_to?(:archive_write_add_filter) ? 'FILTER' : 'COMPRESSION'
+        compression = Archive.const_get("#{prefix}_#{compression}".upcase)
+      end
+
+      raise Error, self if C.archive_write_set_compression(archive, compression) != C::OK
+    end
+
+    def init_format(format)
+      raise ArgumentError, 'Missing :format argument' if !format || format.to_s.empty?
+
+      format = Archive.const_get("FORMAT_#{format}".upcase) unless format.is_a?(Integer)
+      raise Error, self if C.archive_write_set_format(archive, format) != C::OK
+    end
+
+    def init_for_filename(file_name)
+      raise Error, self if C.archive_write_open_filename(archive, file_name) != C::OK
+    end
+
+    def init_for_memory(memory)
+      C.archive_write_set_bytes_in_last_block(archive, 1) if C.archive_write_get_bytes_in_last_block(archive) < 0
+
+      write_callback = proc do |_ar, _client_data, buffer, length|
+        memory << buffer.get_bytes(0, length)
+        length
+      end
+
+      null_ptr = FFI::Pointer::NULL
+      raise Error, self if C.archive_write_open(archive, null_ptr, null_ptr, write_callback, null_ptr) != C::OK
+    end
+  end
+end