seven_zip_ruby 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee5048a454954a7610658f10e463febaa31ecb93
-  data.tar.gz: 70cf302be7166790d2af569eb6b4a109d78934bc
+  metadata.gz: 576e8ef01f360932073896eb2ada1386f998f644
+  data.tar.gz: 1ec0d7e51e795d61062c969126c206025e6734d4
 SHA512:
-  metadata.gz: 3d94b6a533f37ddae5ca51d8882289884494b7ed783dee966cf3b5e060d0f7c404096bfd2212dc0d29a32125075acfc4e7a11af82aca33eaf65d178b47b25300
-  data.tar.gz: 96635e6baac1b98fed6f7321b4cb039abeddc81f2dada7fcdfc6dd053be9c0a3125fe3d47852a4347fda0dee38b303132b81b9083b0b0b9f6ca27f1f417caa78
+  metadata.gz: d46d87711429c1cdf191efdf8bed3c0077de239fe7934b8d1fa619f9fcadedd11d026b9b38dfd8a3ecf44af27e85e9be563a8df0432a24cc03939d9308e684be
+  data.tar.gz: 4164be8cbd6877ee638369385027c5ac232db25d3c784a11d9a4d80413076f8fedef31fdae86fce7ee5933ad7047ec41d853e504e39729b6a324b5aa198a7d83

data/.gitignore

@@ -1,5 +1,6 @@
 *.rbc
 *.o
+*.obj
 *.so
 *.bundle
 *.bak

data/.travis.yml

@@ -1,6 +1,15 @@
 language: ruby
 rvm:
   - "2.0.0"
+  - "2.1.0"
+  - "rbx"
+  - "ruby-head"
+matrix:
+  allow_failures:
+    - rvm: "rbx"
+    - rvm: "ruby-head"
+notifications:
+  email: false
 cache:
   - apt
 before_install:

data/README.md

@@ -1,8 +1,8 @@
 # SevenZipRuby ![Logo](https://raw.github.com/masamitsu-murase/seven_zip_ruby/master/resources/seven_zip_ruby_logo.png)
 
-[![Build Status](https://travis-ci.org/masamitsu-murase/seven_zip_ruby.png?branch=master)](https://travis-ci.org/masamitsu-murase/seven_zip_ruby)
+[![Build Status](https://travis-ci.org/masamitsu-murase/seven_zip_ruby.png?branch=master)](https://travis-ci.org/masamitsu-murase/seven_zip_ruby) [![Gem Version](https://badge.fury.io/rb/seven_zip_ruby.png)](http://badge.fury.io/rb/seven_zip_ruby)
 
-This is a Ruby gem library to handle [7-Zip](http://www.7-zip.org) archives.
+This is a Ruby gem library to extract/compress [7-Zip](http://www.7-zip.org) archives.
 
 This extension calls the native library, 7z.dll or 7z.so, internally and it is included in this gem.
 
@@ -86,12 +86,19 @@ File.open("filename.7z", "wb") do |file|
 end
 ```
 
-## Supported platforms
+## Supported environment
+
+SevenZipRuby supports the following platforms.
 
 * Windows
 * Linux
 * Mac OSX
 
+SevenZipRuby supports the following Ruby engines on each platform.
+
+* MRI 2.0.0 and later
+* Rubinius 2.2.1 and later
+
 ## More examples
 
 ### Extract partially
@@ -180,7 +187,7 @@ LGPL and unRAR license. Please refer to LICENSE.txt.
 
 ## Releases
 
-* 1.1.0
+* 1.1.0  
   Raise error when wrong password is specified.
 * 1.0.0  
   Initial release.

data/Rakefile

@@ -1,4 +1,5 @@
 require "fileutils"
+require "tempfile"
 require "bundler/gem_tasks"
 
 BINARY_FILES = [ "seven_zip_archive.so", "seven_zip_archive.bundle" ]
@@ -32,7 +33,18 @@ end
 task :build_binary do
   Dir.chdir "ext/seven_zip_ruby" do
     FileUtils.rmtree BINARY_FILES
-    sh "ruby extconf.rb"
+
+    Tempfile.open([ "site", ".rb" ], Dir.pwd) do |temp|
+      temp.puts <<"EOS"
+require('rbconfig')
+RbConfig::CONFIG['sitearchdir'] = "../../lib"
+EOS
+      temp.flush
+
+      sh "ruby -r#{File.expand_path(temp.path)} extconf.rb"
+      temp.unlink
+    end
+
     sh "#{MAKE}"
   end
 end

data/ext/seven_zip_ruby/extconf.rb

@@ -4,6 +4,8 @@ require("mkmf")
 require("rbconfig")
 
 
+SO_TARGET_DIR = File.expand_path(File.join(RbConfig::CONFIG["sitearchdir"], "seven_zip_ruby"))
+
 def create_p7zip_makefile(type)
   config = RbConfig::CONFIG
 
@@ -64,7 +66,6 @@ def sample_cpp_source
 #include <iostream>
 
 #include <ruby.h>
-#include <ruby/thread.h>
 
 void test()
 {
@@ -87,11 +88,49 @@ void test()
 EOS
 end
 
+def sample_for_rb_thread_call_without_gvl(have_ruby_thread_h)
+  header = "#include <ruby.h>\n"
+  header += "#include <ruby/thread.h>\n" if (have_ruby_thread_h)
+  body = <<'EOS'
+
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    printf("%p\n", rb_thread_call_without_gvl);
+    return 0;
+}
+EOS
+  return header + body
+end
+
+def sample_for_nullptr
+  return <<'EOS'
+#include <stdio.h>
+int main(int argc, char *argv[])
+{
+    printf("%p\n", nullptr);
+    return 0;
+}
+EOS
+end
+
 def main
+  base_flag = ""
+
+  th_h = have_header("ruby/thread.h")
+
+  unless (try_compile(sample_for_rb_thread_call_without_gvl(th_h)))
+    base_flag += " -DNO_RB_THREAD_CALL_WITHOUT_GVL"
+  end
+  unless (try_compile(sample_for_nullptr))
+    base_flag += " -DNO_NULLPTR"
+  end
+
   if (RUBY_PLATFORM.include?("mswin"))
     # mswin32
     $LIBS = "oleaut32.lib"
-    $CPPFLAGS = "/I.. /EHsc /DNDEBUG"
+    $CPPFLAGS = "/I.. /EHsc /DNDEBUG /DUSE_WIN32_FILE_API #{base_flag} "
   elsif (RUBY_PLATFORM.include?("mingw"))
     # MinGW
     $LIBS = "-loleaut32 -static-libgcc -static-libstdc++"
@@ -101,14 +140,14 @@ def main
     end
     raise "C++11 is not supported by the compiler." unless (cpp0x_flag)
 
-    $CPPFLAGS = "-I.. #{cpp0x_flag} -DNDEBUG "
+    $CPPFLAGS = "-I.. #{cpp0x_flag} -DNDEBUG -DUSE_WIN32_FILE_API #{base_flag} "
   else
     cpp0x_flag = [ "", "-std=c++11", "-std=gnu++11", "-std=c++0x", "-std=gnu++0x" ].find do |opt|
       next (try_compile(sample_cpp_source, "#{opt} -x c++ ") || try_compile(sample_cpp_source, "#{opt} "))
     end
     raise "C++11 is not supported by the compiler." unless (cpp0x_flag)
 
-    $CPPFLAGS = "-I.. -I../CPP/include_windows -I../CPP #{cpp0x_flag} -DNDEBUG "
+    $CPPFLAGS = "-I.. -I../CPP/include_windows -I../CPP #{cpp0x_flag} -DNDEBUG #{base_flag} "
 
 
     ostype = check_ostype
@@ -119,7 +158,9 @@ def main
       make_success = system("make 7zso")
       raise "Failed to make p7zip" unless (make_success)
 
-      FileUtils.mv("./bin/7z.so", "../../lib/seven_zip_ruby/7z.so")
+      FileUtils.mkpath(SO_TARGET_DIR)
+      FileUtils.cp("./bin/7z.so", SO_TARGET_DIR)
+
       system("make clean_7zso")
     end
   end

data/ext/seven_zip_ruby/seven_zip_archive.cpp

@@ -18,6 +18,8 @@
 namespace SevenZip
 {
 
+using namespace RubyCppUtil;
+
 
 typedef UINT32 (WINAPI * CreateObjectFunc)(
     const GUID *clsID,
@@ -38,7 +40,8 @@ ArchiveBase::RubyAction ArchiveBase::ACTION_END = [](){};
 
 ArchiveBase::ArchiveBase()
      : m_action_tuple(nullptr),
-       m_event_loop_running(false)
+       m_event_loop_running(false),
+       m_self(Qnil)
 {
     m_action_result.clear();
 }
@@ -47,6 +50,16 @@ ArchiveBase::~ArchiveBase()
 {
 }
 
+void ArchiveBase::setSelf(VALUE self)
+{
+    m_self = self;
+}
+
+VALUE ArchiveBase::self()
+{
+    return m_self;
+}
+
 void ArchiveBase::rubyEventLoop()
 {
     m_action_mutex.lock();
@@ -54,7 +67,7 @@ void ArchiveBase::rubyEventLoop()
         m_action_mutex.unlock();
 
         RubyActionTuple end_tuple = std::make_pair(&ACTION_END, false);
-        RubyActionTuple *action_tuple = nullptr;
+        RubyActionTuple * volatile action_tuple = nullptr;
 
         bool success = runNativeFuncProtect([&](){
             MutexLocker locker(&m_action_mutex);
@@ -95,6 +108,12 @@ void ArchiveBase::rubyEventLoop()
 
         m_action_mutex.lock();
         m_event_loop_running = event_loop_running;
+        // if (m_action_tuple && m_action_tuple != &end_tuple && m_action_tuple != action_tuple){
+        //     // Someone overrode m_action_tuple.
+        //     // It might be killEventLoopThread. Otherwise, it might a bug.
+        //     // Therefore, terminate event loop for safety.
+        //     m_event_loop_running = false;
+        // }
         m_action_tuple = nullptr;
         m_action_cond_var.broadcast();
     }
@@ -111,6 +130,8 @@ VALUE ArchiveBase::runProtectedRubyAction(VALUE p)
 VALUE ArchiveBase::staticRubyEventLoop(void *p)
 {
     ArchiveBase *self = reinterpret_cast<ArchiveBase*>(p);
+    VALUE gc_guard = self->self();
+    RB_GC_GUARD(gc_guard);
     self->rubyEventLoop();
     return Qnil;
 }
@@ -125,19 +146,21 @@ void ArchiveBase::startEventLoopThread()
     rb_thread_create(RUBY_METHOD_FUNC(staticRubyEventLoop), this);
 }
 
-void ArchiveBase::cancelAction(void *p)
+void ArchiveBase::cancelAction()
 {
-    if (!p){
-        return;
-    }
-
-    ArchiveBase *self = reinterpret_cast<ArchiveBase*>(p);
-    self->cancelAction();
+//    killEventLoopThread();
+    setErrorState();
 }
 
-void ArchiveBase::cancelAction()
+void ArchiveBase::killEventLoopThread()
 {
-    setErrorState();
+    MutexLocker locker(&m_action_mutex);
+    if (m_event_loop_running){
+        static RubyActionTuple end_tuple;
+        end_tuple = std::make_pair(&ACTION_END, false);
+        m_action_tuple = &end_tuple;  // override.
+        m_action_cond_var.broadcast();
+    }
 }
 
 bool ArchiveBase::runRubyActionImpl(RubyAction *action)
@@ -168,8 +191,10 @@ bool ArchiveBase::runRubyActionImpl(RubyAction *action)
     return (tuple.second && m_event_loop_running);
 }
 
-bool ArchiveBase::runRubyAction(RubyAction action)
+template<typename T>
+bool ArchiveBase::runRubyAction(T t)
 {
+    RubyAction action = t;
     return runRubyActionImpl(&action);
 }
 
@@ -180,6 +205,7 @@ void ArchiveBase::finishRubyAction()
 
 void ArchiveBase::mark()
 {
+    rb_gc_mark(m_self);
     m_action_result.mark();
 }
 
@@ -199,8 +225,8 @@ void ArchiveBase::terminateEventLoopThread()
 
 ////////////////////////////////////////////////////////////////
 ArchiveReader::ArchiveReader(const GUID &format_guid)
-     : m_rb_callback_proc(Qnil), m_rb_out_stream(Qnil), m_rb_in_stream(Qnil),
-       m_processing_index((UInt32)(Int32)-1),
+     : m_rb_callback_proc(Qnil), m_rb_out_stream(Qnil),
+       m_processing_index((UInt32)(Int32)-1), m_rb_in_stream(Qnil),
        m_format_guid(format_guid),
        m_password_specified(false),
        m_state(STATE_INITIAL)
@@ -258,7 +284,10 @@ VALUE ArchiveReader::open(VALUE in_stream, VALUE param)
     m_rb_out_stream = Qnil;
     m_rb_entry_info_list.clear();
 
-    VALUE password = rb_hash_aref(param, ID2SYM(INTERN("password")));
+    VALUE password;
+    runRubyFunction([&](){
+        password = rb_hash_aref(param, ID2SYM(INTERN("password")));
+    });
     if (NIL_P(password)){
         m_password_specified = false;
     }else{
@@ -365,13 +394,17 @@ VALUE ArchiveReader::getArchiveProperty()
 
     checkState(STATE_OPENED, "getArchiveProperty error");
 
-    VALUE archive_info = rb_const_get(gSevenZipModule, INTERN("ArchiveInfo"));
-    ID new_id = INTERN("new");
+    VALUE ret;
     VALUE value_list[size];
-    for (unsigned int i=0; i<size; i++){
-        value_list[i] = ConvertPropToValue(variant_list[i]);
-    }
-    return rb_funcall2(archive_info, new_id, size, value_list);
+    runRubyFunction([&](){
+        VALUE archive_info = rb_const_get(gSevenZipModule, INTERN("ArchiveInfo"));
+        ID new_id = INTERN("new");
+        for (unsigned int i=0; i<size; i++){
+            value_list[i] = ConvertPropToValue(variant_list[i]);
+        }
+        ret = rb_funcall2(archive_info, new_id, size, value_list);
+    });
+    return ret;
 }
 
 VALUE ArchiveReader::getEntryInfo(VALUE index)
@@ -384,7 +417,10 @@ VALUE ArchiveReader::getEntryInfo(VALUE index)
 
     checkState(STATE_OPENED, "getEntryInfo error");
 
-    UInt32 idx = NUM2ULONG(index);
+    UInt32 idx;
+    runRubyFunction([&](){
+        idx = NUM2ULONG(index);
+    });
     return entryInfo(idx);
 }
 
@@ -407,7 +443,11 @@ VALUE ArchiveReader::getAllEntryInfo()
 
     checkState(STATE_OPENED, "getAllEntryInfo error");
 
-    return rb_ary_new4(m_rb_entry_info_list.size(), &m_rb_entry_info_list[0]);
+    VALUE ret;
+    runRubyFunction([&](){
+        ret = rb_ary_new4(m_rb_entry_info_list.size(), &m_rb_entry_info_list[0]);
+    });
+    return ret;
 }
 
 VALUE ArchiveReader::setFileAttribute(VALUE path, VALUE attrib)
@@ -433,7 +473,10 @@ VALUE ArchiveReader::extract(VALUE index, VALUE callback_proc)
 
     fillEntryInfo();
 
-    UInt32 i = NUM2ULONG(index);
+    UInt32 i;
+    runRubyFunction([&](){
+        i = NUM2ULONG(index);
+    });
     HRESULT ret;
     runNativeFunc([&](){
         ArchiveExtractCallback *extract_callback = createArchiveExtractCallback();
@@ -541,35 +584,37 @@ VALUE ArchiveReader::testAll(VALUE detail)
     }
 
     if (RTEST(detail)){
-        using namespace NArchive::NExtract::NOperationResult;
+        VALUE ary;
+        runRubyFunction([&](){
+            using namespace NArchive::NExtract::NOperationResult;
 
-        VALUE unsupportedMethod = ID2SYM(INTERN("UnsupportedMethod"));
-        VALUE dataError = ID2SYM(INTERN("DataError"));
-        VALUE crcError = ID2SYM(INTERN("CrcError"));
-
-        VALUE ary = rb_ary_new2(num);
-        rb_ary_resize(ary, m_test_result.size());
-        for (unsigned int i=0; i<m_test_result.size(); i++){
-            VALUE v;
-            switch(m_test_result[i]){
-              case kOK:
-                v = Qtrue;
-                break;
-              case kUnSupportedMethod:
-                v = unsupportedMethod;
-                break;
-              case kDataError:
-                v = dataError;
-                break;
-              case kCRCError:
-                v = crcError;
-                break;
-              default:
-                v = Qnil;
-                break;
+            VALUE unsupportedMethod = ID2SYM(INTERN("UnsupportedMethod"));
+            VALUE dataError = ID2SYM(INTERN("DataError"));
+            VALUE crcError = ID2SYM(INTERN("CrcError"));
+
+            ary = rb_ary_new2(num);
+            for (unsigned int i=0; i<m_test_result.size(); i++){
+                VALUE v;
+                switch(m_test_result[i]){
+                  case kOK:
+                    v = Qtrue;
+                    break;
+                  case kUnSupportedMethod:
+                    v = unsupportedMethod;
+                    break;
+                  case kDataError:
+                    v = dataError;
+                    break;
+                  case kCRCError:
+                    v = crcError;
+                    break;
+                  default:
+                    v = Qnil;
+                    break;
+                }
+                rb_ary_store(ary, (long)i, v);
             }
-            RARRAY_PTR(ary)[i] = v;
-        }
+        });
         return ary;
     }else{
         using namespace NArchive::NExtract::NOperationResult;
@@ -643,17 +688,19 @@ void ArchiveReader::fillEntryInfo()
         throw RubyCppUtil::RubyException("Cannot get property of items");
     }
 
-    VALUE entry_info = rb_const_get(gSevenZipModule, INTERN("EntryInfo"));
-    ID new_id = INTERN("new");
     m_rb_entry_info_list.resize(variant_list.size(), Qnil);
-    for (UInt32 i=0; i<m_rb_entry_info_list.size(); i++){
-        VALUE value_list[size + 1];
-        value_list[0] = ULONG2NUM(i);
-        for (unsigned int j=0; j<size; j++){
-            value_list[j+1] = ConvertPropToValue(variant_list[i][j]);
+    VALUE value_list[size + 1];
+    runRubyFunction([&](){
+        VALUE entry_info = rb_const_get(gSevenZipModule, INTERN("EntryInfo"));
+        ID new_id = INTERN("new");
+        for (UInt32 i=0; i<m_rb_entry_info_list.size(); i++){
+            value_list[0] = ULONG2NUM(i);
+            for (unsigned int j=0; j<size; j++){
+                value_list[j+1] = ConvertPropToValue(variant_list[i][j]);
+            }
+            m_rb_entry_info_list[i] = rb_funcall2(entry_info, new_id, size + 1, value_list);
         }
-        m_rb_entry_info_list[i] = rb_funcall2(entry_info, new_id, size + 1, value_list);
-    }
+    });
 }
 
 void ArchiveReader::mark()
@@ -728,7 +775,10 @@ VALUE ArchiveWriter::open(VALUE out_stream, VALUE param)
     m_rb_in_stream = Qnil;
     std::vector<VALUE>().swap(m_rb_update_list);
 
-    VALUE password = rb_hash_aref(param, ID2SYM(INTERN("password")));
+    VALUE password;
+    runRubyFunction([&](){
+        password = rb_hash_aref(param, ID2SYM(INTERN("password")));
+    });
     if (NIL_P(password)){
         m_password_specified = false;
     }else{
@@ -999,7 +1049,7 @@ VALUE SevenZipWriter::method()
 
 VALUE SevenZipWriter::setLevel(VALUE level)
 {
-    level = rb_check_to_int(level);
+    level = rb_check_to_integer(level, "to_int");
     if (NIL_P(level)){
         throw RubyCppUtil::RubyException(rb_exc_new2(rb_eArgError, "level should be Integer"));
     }
@@ -1094,11 +1144,19 @@ ArchiveOpenCallback::ArchiveOpenCallback(ArchiveReader *archive, const std::stri
 
 STDMETHODIMP ArchiveOpenCallback::SetTotal(const UInt64 *files, const UInt64 *bytes)
 {
+    // This function is called periodically, so use this function as a check function of interrupt.
+    if (m_archive->isErrorState()){
+        return E_ABORT;
+    }
     return S_OK;
 }
 
 STDMETHODIMP ArchiveOpenCallback::SetCompleted(const UInt64 *files, const UInt64 *bytes)
 {
+    // This function is called periodically, so use this function as a check function of interrupt.
+    if (m_archive->isErrorState()){
+        return E_ABORT;
+    }
     return S_OK;
 }
 
@@ -1128,6 +1186,10 @@ ArchiveExtractCallback::ArchiveExtractCallback(ArchiveReader *archive, const std
 
 STDMETHODIMP ArchiveExtractCallback::SetTotal(UInt64 size)
 {
+    // This function is called periodically, so use this function as a check function of interrupt.
+    if (m_archive->isErrorState()){
+        return E_ABORT;
+    }
     return S_OK;
 }
 
@@ -1135,7 +1197,7 @@ STDMETHODIMP ArchiveExtractCallback::SetCompleted(const UInt64 *completeValue)
 {
     // This function is called periodically, so use this function as a check function of interrupt.
     if (m_archive->isErrorState()){
-        return E_FAIL;
+        return E_ABORT;
     }
     return S_OK;
 }
@@ -1243,13 +1305,18 @@ ArchiveUpdateCallback::ArchiveUpdateCallback(ArchiveWriter *archive, const std::
 
 STDMETHODIMP ArchiveUpdateCallback::SetTotal(UInt64 size)
 {
+    // This function is called periodically, so use this function as a check function of interrupt.
+    if (m_archive->isErrorState()){
+        return E_ABORT;
+    }
     return S_OK;
 }
 
 STDMETHODIMP ArchiveUpdateCallback::SetCompleted(const UInt64 *completeValue)
 {
+    // This function is called periodically, so use this function as a check function of interrupt.
     if (m_archive->isErrorState()){
-        return E_FAIL;
+        return E_ABORT;
     }
     return S_OK;
 }
@@ -1338,6 +1405,9 @@ STDMETHODIMP ArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PRO
             break;
         }
     });
+    if (!ret){
+        return E_FAIL;
+    }
 
     return S_OK;
 }
@@ -1345,10 +1415,25 @@ STDMETHODIMP ArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PRO
 STDMETHODIMP ArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream **inStream)
 {
     VALUE rb_stream;
+    std::string filepath;
     VALUE proc = m_archive->callbackProc();
     bool ret = m_archive->runRubyAction([&](){
         VALUE info = m_archive->itemInfo(index);
-        rb_stream = rb_funcall(proc, INTERN("call"), 2, ID2SYM(INTERN("stream")), info);
+        VALUE ret_array = rb_funcall(proc, INTERN("call"), 2, ID2SYM(INTERN("stream")), info);
+        if (NIL_P(ret_array)){
+            rb_stream = Qnil;
+            return;
+        }
+
+        // ret_array[0]: true:  filepath
+        //               false: io
+        if (RTEST(rb_ary_entry(ret_array, 0))){
+            rb_stream = Qnil;
+            VALUE path = rb_ary_entry(ret_array, 1);
+            filepath = std::string(RSTRING_PTR(path), RSTRING_LEN(path));
+        }else{
+            rb_stream = rb_ary_entry(ret_array, 1);
+        }
     });
     if (!ret){
         m_archive->clearProcessingStream();
@@ -1357,9 +1442,15 @@ STDMETHODIMP ArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream
 
     m_archive->setProcessingStream(rb_stream, index);
 
-    InStream *stream = new InStream(rb_stream, m_archive);
-    CMyComPtr<InStream> ptr(stream);
-    *inStream = ptr.Detach();
+    if (NIL_P(rb_stream) && !(filepath.empty())){
+        FileInStream *stream = new FileInStream(filepath, m_archive);
+        CMyComPtr<FileInStream> ptr(stream);
+        *inStream = ptr.Detach();
+    }else{
+        InStream *stream = new InStream(rb_stream, m_archive);
+        CMyComPtr<InStream> ptr(stream);
+        *inStream = ptr.Detach();
+    }
 
     return S_OK;
 }
@@ -1449,11 +1540,138 @@ STDMETHODIMP InStream::Read(void *data, UInt32 size, UInt32 *processedSize)
             *processedSize = (NIL_P(str) ? 0 : RSTRING_LEN(str));
         }
     });
+    if (!ret){
+        if (processedSize){
+            *processedSize = 0;
+        }
+        return E_FAIL;
+    }
+
+    return S_OK;
+}
+
+////////////////////////////////////////////////////////////////
+FileInStream::FileInStream(const std::string  &filename, ArchiveBase *archive)
+     : m_archive(archive)
+#ifdef USE_WIN32_FILE_API
+     , m_file_handle(INVALID_HANDLE_VALUE)
+#else
+     , m_file(filename.c_str(), std::ios::binary)
+#endif
+{
+#ifdef USE_WIN32_FILE_API
+    BSTR name = ConvertStringToBstr(filename);
+    m_file_handle = CreateFileW(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
+                                FILE_ATTRIBUTE_NORMAL, NULL);
+    SysFreeString(name);
+#else
+    // Nothing to do
+#endif
+}
+
+FileInStream::~FileInStream()
+{
+#ifdef USE_WIN32_FILE_API
+    if (m_file_handle == INVALID_HANDLE_VALUE){
+        return;
+    }
+
+    CloseHandle(m_file_handle);
+    m_file_handle = INVALID_HANDLE_VALUE;
+#else
+    // Nothing to do
+#endif
+}
+
+STDMETHODIMP FileInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+#ifdef USE_WIN32_FILE_API
+    if (m_file_handle == INVALID_HANDLE_VALUE){
+        return E_FAIL;
+    }
+
+    DWORD method;
+    switch(seekOrigin){
+      case 0:
+        method = FILE_BEGIN;
+        break;
+      case 1:
+        method = FILE_CURRENT;
+        break;
+      case 2:
+        method = FILE_END;
+        break;
+      default:
+        return E_FAIL;
+    }
+
+    DWORD low, high;
+    low = (DWORD)(offset & 0xFFFFFFFFUL);
+    high = (DWORD)((offset >> 32) & 0xFFFFFFFFUL);
+    DWORD new_low = SetFilePointer(m_file_handle, (LONG)low, (PLONG)&high, method);
+
+    if (newPosition){
+        *newPosition = (((UInt64)high) << 32) + ((UInt64)new_low);
+    }
+    return S_OK;
+#else
+    if (!m_file.is_open()){
+        return E_FAIL;
+    }
+
+    std::ios::seekdir method;
+    switch(seekOrigin){
+      case 0:
+        method = std::ios::beg;
+        break;
+      case 1:
+        method = std::ios::cur;
+        break;
+      case 2:
+        method = std::ios::end;
+        break;
+      default:
+        return E_FAIL;
+    }
+
+    std::streamoff sto = offset;
+    m_file.seekg(sto, method);
+    if (newPosition){
+        *newPosition = m_file.tellg();
+    }
+    return S_OK;
+#endif
+}
+
+STDMETHODIMP FileInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+#ifdef USE_WIN32_FILE_API
+    if (m_file_handle == INVALID_HANDLE_VALUE){
+        return E_FAIL;
+    }
+
+    DWORD processed_size;
+    BOOL ret = ReadFile(m_file_handle, data, size, &processed_size, NULL);
     if (!ret){
         return E_FAIL;
     }
 
+    if (processedSize){
+        *processedSize = processed_size;
+    }
+
     return S_OK;
+#else
+    if (!m_file.is_open()){
+        return E_FAIL;
+    }
+
+    m_file.read(reinterpret_cast<char*>(data), size);
+    if (processedSize){
+        *processedSize = m_file.gcount();
+    }
+    return S_OK;
+#endif
 }
 
 ////////////////////////////////////////////////////////////////
@@ -1476,6 +1694,16 @@ STDMETHODIMP OutStream::Write(const void *data, UInt32 size, UInt32 *processedSi
         }
     });
     if (!ret){
+        if (processedSize){
+            *processedSize = 0;
+        }
+        // When killEventLoopThread is called in cancelAction
+        // return S_OK even if error occurs.
+        //
+        // Detail:
+        //  It seems that BZip2Encoder has a bug.
+        //  If Write method returns E_FAIL, some Events are not set in that file
+        //  because OutBuffer throws an exception in Encoder->WriteBytes.
         return E_FAIL;
     }
 
@@ -1570,7 +1798,7 @@ extern "C" void Init_seven_zip_archive(void)
 
     cls = rb_define_wrapped_cpp_class_under<SevenZipReader>(mod, "SevenZipReader", rb_cObject);
     rb_define_method_ext(cls, "open_impl", READER_FUNC(open, 2));
-    rb_define_method_ext(cls, "close", READER_FUNC(close, 0));
+    rb_define_method_ext(cls, "close_impl", READER_FUNC(close, 0));
     rb_define_method_ext(cls, "entry_num", READER_FUNC(entryNum, 0));
     rb_define_method_ext(cls, "extract_impl", READER_FUNC(extract, 2));
     rb_define_method_ext(cls, "extract_files_impl", READER_FUNC(extractFiles, 2));
@@ -1593,7 +1821,7 @@ extern "C" void Init_seven_zip_archive(void)
     rb_define_method_ext(cls, "open_impl", WRITER_FUNC(open, 2));
     rb_define_method_ext(cls, "add_item", WRITER_FUNC(addItem, 1));
     rb_define_method_ext(cls, "compress_impl", WRITER_FUNC(compress, 1));
-    rb_define_method_ext(cls, "close", WRITER_FUNC(close, 0));
+    rb_define_method_ext(cls, "close_impl", WRITER_FUNC(close, 0));
     rb_define_method_ext(cls, "get_file_attribute", WRITER_FUNC(getFileAttribute, 1));
 
     rb_define_method_ext(cls, "method=", WRITER_FUNC2(setMethod, 1));