zipruby 0.2.6-mswin32 → 0.2.8-mswin32

data/zipruby.c

@@ -1,4 +1,177 @@
 /* rdoc source */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <io.h>
+#include <fcntl.h>
+#include <share.h>
+#endif
+
+#include "tmpfile.h"
+#include "ruby.h"
+
+#ifndef _WIN32
+#ifndef HAVE_MKSTEMP
+int _zip_mkstemp(char *);
+#define mkstemp _zip_mkstemp
+#endif
+#endif
+
+static int write_from_proc(VALUE proc, int fd);
+static VALUE proc_call(VALUE proc);
+
+char *zipruby_tmpnam(void *data, int len) {
+  char *filnam;
+
+#ifdef _WIN32
+  int fd;
+  char tmpdirnam[_MAX_PATH];
+  char tmpfilnam[_MAX_PATH];
+  int namlen;
+
+  memset(tmpdirnam, 0, _MAX_PATH);
+
+  if (GetTempPathA(_MAX_PATH, tmpdirnam) == 0) {
+    return NULL;
+  }
+
+  memset(tmpfilnam, 0, _MAX_PATH);
+
+  if (GetTempFileNameA(tmpdirnam, "zrb", 0, tmpfilnam) == 0) {
+    return NULL;
+  }
+
+  namlen = strlen(tmpfilnam) + 1;
+
+  if ((filnam = calloc(namlen, sizeof(char))) == NULL) {
+    return NULL;
+  }
+
+  if (strcpy_s(filnam, namlen, tmpfilnam) != 0) {
+    free(filnam);
+    return NULL;
+  }
+
+  if (data) {
+    if ((_sopen_s(&fd, filnam, _O_WRONLY | _O_BINARY, _SH_DENYRD, _S_IWRITE)) != 0) {
+      free(filnam);
+      return NULL;
+    }
+
+    if (len < 0) {
+      if (write_from_proc((VALUE) data, fd) == -1) {
+        free(filnam);
+        return NULL;
+      }
+    } else {
+      if (_write(fd, data, len) == -1) {
+        free(filnam);
+        return NULL;
+      }
+    }
+
+    if (_close(fd) == -1) {
+      free(filnam);
+      return NULL;
+    }
+  }
+#else
+  int fd;
+#ifdef P_tmpdir
+  int namlen = 16 + strlen(P_tmpdir);
+  char *dirnam = P_tmpdir;
+#else
+  int namlen = 20;
+  char *dirnam = "/tmp";
+#endif
+
+  if ((filnam = calloc(namlen, sizeof(char))) == NULL) {
+    return NULL;
+  }
+
+  strcpy(filnam, dirnam);
+  strcat(filnam, "/zipruby.XXXXXX");
+
+  if ((fd = mkstemp(filnam)) == -1) {
+    free(filnam);
+    return NULL;
+  }
+
+  if (data) {
+    if (len < 0) {
+      if (write_from_proc((VALUE) data, fd) == -1) {
+        free(filnam);
+        return NULL;
+      }
+    } else {
+      if (write(fd, data, len) == -1) {
+        free(filnam);
+        return NULL;
+      }
+    }
+  }
+
+  if (close(fd) == -1) {
+    free(filnam);
+    return NULL;
+  }
+#endif
+
+  return filnam;
+}
+
+void zipruby_rmtmp(const char *tmpfilnam) {
+  struct stat st;
+
+  if (!tmpfilnam) {
+    return;
+  }
+
+  if (stat(tmpfilnam, &st) != 0) {
+    return;
+  }
+
+#ifdef _WIN32
+  _unlink(tmpfilnam);
+#else
+  unlink(tmpfilnam);
+#endif
+}
+
+static int write_from_proc(VALUE proc, int fd) {
+  while (1) {
+    VALUE src = rb_protect(proc_call, proc, NULL);
+
+    if (TYPE(src) != T_STRING) {
+      break;
+    }
+
+    if (RSTRING(src)->len < 1) {
+      break;
+    }
+
+#ifdef _WIN32
+    if (_write(fd, StringValuePtr(src), RSTRING(src)->len) == -1) {
+      return -1;
+    }
+#else
+    if (write(fd, StringValuePtr(src), RSTRING(src)->len) == -1) {
+      return -1;
+    }
+#endif
+  }
+
+  return 0;
+}
+
+static VALUE proc_call(VALUE proc) {
+  return rb_funcall(proc, rb_intern("call"), 0);
+}
 #ifdef _WIN32
 __declspec(dllexport) void Init_zipruby(void);
 #endif
@@ -23,6 +196,7 @@ void Init_zipruby() {
 #include "zipruby.h"
 #include "zipruby_archive.h"
 #include "zipruby_zip_source_proc.h"
+#include "tmpfile.h"
 #include "ruby.h"
 #include "rubyio.h"
 
@@ -30,6 +204,7 @@ static VALUE zipruby_archive_alloc(VALUE klass);
 static void zipruby_archive_mark(struct zipruby_archive *p);
 static void zipruby_archive_free(struct zipruby_archive *p);
 static VALUE zipruby_archive_s_open(int argc, VALUE *argv, VALUE self);
+static VALUE zipruby_archive_s_open_buffer(int argc, VALUE *argv, VALUE self);
 static VALUE zipruby_archive_s_decrypt(VALUE self, VALUE path, VALUE password);
 static VALUE zipruby_archive_s_encrypt(VALUE self, VALUE path, VALUE password);
 static VALUE zipruby_archive_close(VALUE self);
@@ -66,6 +241,7 @@ static VALUE zipruby_archive_commit(VALUE self);
 static VALUE zipruby_archive_is_open(VALUE self);
 static VALUE zipruby_archive_decrypt(VALUE self, VALUE password);
 static VALUE zipruby_archive_encrypt(VALUE self, VALUE password);
+static VALUE zipruby_archive_read(VALUE self);
 
 extern VALUE Zip;
 VALUE Archive;
@@ -78,6 +254,7 @@ void Init_zipruby_archive() {
   rb_define_alloc_func(Archive, zipruby_archive_alloc);
   rb_include_module(Archive, rb_mEnumerable);
   rb_define_singleton_method(Archive, "open", zipruby_archive_s_open, -1);
+  rb_define_singleton_method(Archive, "open_buffer", zipruby_archive_s_open_buffer, -1);
   rb_define_singleton_method(Archive, "decrypt", zipruby_archive_s_decrypt, 2);
   rb_define_singleton_method(Archive, "encrypt", zipruby_archive_s_encrypt, 2);
   rb_define_method(Archive, "close", zipruby_archive_close, 0);
@@ -117,6 +294,7 @@ void Init_zipruby_archive() {
   rb_define_method(Archive, "open?", zipruby_archive_is_open, 0);
   rb_define_method(Archive, "decrypt", zipruby_archive_decrypt, 1);
   rb_define_method(Archive, "encrypt", zipruby_archive_encrypt, 1);
+  rb_define_method(Archive, "read", zipruby_archive_read, 0);
 }
 
 static VALUE zipruby_archive_alloc(VALUE klass) {
@@ -125,15 +303,23 @@ static VALUE zipruby_archive_alloc(VALUE klass) {
   p->archive = NULL;
   p->path = Qnil;
   p->flags = 0;
+  p->tmpfilnam = NULL;
+  p->buffer = Qnil;
 
   return Data_Wrap_Struct(klass, zipruby_archive_mark, zipruby_archive_free, p);
 }
 
 static void zipruby_archive_mark(struct zipruby_archive *p) {
   rb_gc_mark(p->path);
+  rb_gc_mark(p->buffer);
 }
 
 static void zipruby_archive_free(struct zipruby_archive *p) {
+  if (p->tmpfilnam) {
+    zipruby_rmtmp(p->tmpfilnam);
+    free(p->tmpfilnam);
+  }
+
   xfree(p);
 }
 
@@ -181,6 +367,76 @@ static VALUE zipruby_archive_s_open(int argc, VALUE *argv, VALUE self) {
   }
 }
 
+/* */
+static VALUE zipruby_archive_s_open_buffer(int argc, VALUE *argv, VALUE self) {
+  VALUE buffer, flags;
+  VALUE archive;
+  struct zipruby_archive *p_archive;
+  void *data = NULL;
+  int len = 0, i_flags = 0;
+  int errorp;
+
+  rb_scan_args(argc, argv, "02", &buffer, &flags);
+
+  if (FIXNUM_P(buffer) && NIL_P(flags)) {
+    flags = buffer;
+    buffer = Qnil;
+  }
+
+  if (!NIL_P(flags)) {
+    i_flags = NUM2INT(flags);
+  }
+
+  if (i_flags & ZIP_CREATE) {
+    if (!NIL_P(buffer)) {
+      Check_Type(buffer, T_STRING);
+    }
+
+    i_flags = (i_flags | ZIP_TRUNC);
+  } else if (TYPE(buffer) == T_STRING) {
+    data = StringValuePtr(buffer);
+    len = RSTRING(buffer)->len;
+  } else if (rb_obj_is_instance_of(buffer, rb_cProc)) {
+    data = (void *) buffer;
+    len = -1;
+  } else {
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected String or Proc)", rb_class2name(CLASS_OF(buffer)));
+  }
+
+  archive = rb_funcall(Archive, rb_intern("new"), 0);
+  Data_Get_Struct(archive, struct zipruby_archive, p_archive);
+
+  if ((p_archive->tmpfilnam = zipruby_tmpnam(data, len)) == NULL) {
+    rb_raise(Error, "Open archive failed: Failed to create temporary file");
+  }
+
+  if ((p_archive->archive = zip_open(p_archive->tmpfilnam, i_flags, &errorp)) == NULL) {
+    char errstr[ERRSTR_BUFSIZE];
+    zip_error_to_str(errstr, ERRSTR_BUFSIZE, errorp, errno);
+    rb_raise(Error, "Open archive failed: %s", errstr);
+  }
+
+  p_archive->path = rb_str_new2(p_archive->tmpfilnam);
+  p_archive->flags = i_flags;
+  p_archive->buffer = buffer;
+
+  if (rb_block_given_p()) {
+    VALUE retval;
+    int status;
+
+    retval = rb_protect(rb_yield, archive, &status);
+    zipruby_archive_close(archive);
+
+    if (status != 0) {
+      rb_jump_tag(status);
+    }
+
+    return retval;
+  } else {
+    return archive;
+  }
+}
+
 /* */
 static VALUE zipruby_archive_s_decrypt(VALUE self, VALUE path, VALUE password) {
   int errorp, wrongpwd;
@@ -236,6 +492,7 @@ static VALUE zipruby_archive_s_encrypt(VALUE self, VALUE path, VALUE password) {
 /* */
 static VALUE zipruby_archive_close(VALUE self) {
   struct zipruby_archive *p_archive;
+  int changed, survivors;
 
   if (!zipruby_archive_is_open(self)) {
     return Qfalse;
@@ -244,14 +501,20 @@ static VALUE zipruby_archive_close(VALUE self) {
   Data_Get_Struct(self, struct zipruby_archive, p_archive);
   Check_Archive(p_archive);
 
+  changed = _zip_changed(p_archive->archive, &survivors);
+
   if (zip_close(p_archive->archive) == -1) {
     zip_unchange_all(p_archive->archive);
     zip_unchange_archive(p_archive->archive);
     rb_raise(Error, "Close archive failed: %s", zip_strerror(p_archive->archive));
   }
 
+  if (!NIL_P(p_archive->buffer) && changed) {
+    rb_funcall(p_archive->buffer, rb_intern("replace"), 1, rb_funcall(self, rb_intern("read"), 0));
+  }
+
+  zipruby_rmtmp(p_archive->tmpfilnam);
   p_archive->archive = NULL;
-  p_archive->path = Qnil;
   p_archive->flags = 0;
 
   return Qtrue;
@@ -1087,17 +1350,24 @@ static VALUE zipruby_archive_each(VALUE self) {
 /* */
 static VALUE zipruby_archive_commit(VALUE self) {
   struct zipruby_archive *p_archive;
+  int changed, survivors;
   int errorp;
 
   Data_Get_Struct(self, struct zipruby_archive, p_archive);
   Check_Archive(p_archive);
 
+  changed = _zip_changed(p_archive->archive, &survivors);
+
   if (zip_close(p_archive->archive) == -1) {
     zip_unchange_all(p_archive->archive);
     zip_unchange_archive(p_archive->archive);
     rb_raise(Error, "Commit archive failed: %s", zip_strerror(p_archive->archive));
   }
 
+  if (!NIL_P(p_archive->buffer) && changed) {
+    rb_funcall(p_archive->buffer, rb_intern("replace"), 1, rb_funcall(self, rb_intern("read"), 0));
+  }
+
   p_archive->archive = NULL;
   p_archive->flags = (p_archive->flags & ~(ZIP_CREATE | ZIP_EXCL));
 
@@ -1122,6 +1392,7 @@ static VALUE zipruby_archive_is_open(VALUE self) {
 static VALUE zipruby_archive_decrypt(VALUE self, VALUE password) {
   struct zipruby_archive *p_archive;
   long pwdlen;
+  int changed, survivors;
   int errorp;
 
   Check_Type(password, T_STRING);
@@ -1136,12 +1407,18 @@ static VALUE zipruby_archive_decrypt(VALUE self, VALUE password) {
   Data_Get_Struct(self, struct zipruby_archive, p_archive);
   Check_Archive(p_archive);
 
+  changed = _zip_changed(p_archive->archive, &survivors);
+
   if (zip_close(p_archive->archive) == -1) {
     zip_unchange_all(p_archive->archive);
     zip_unchange_archive(p_archive->archive);
     rb_raise(Error, "Decrypt archive failed: %s", zip_strerror(p_archive->archive));
   }
 
+  if (!NIL_P(p_archive->buffer) && changed) {
+    rb_funcall(p_archive->buffer, rb_intern("replace"), 1, rb_funcall(self, rb_intern("read"), 0));
+  }
+
   p_archive->archive = NULL;
   p_archive->flags = (p_archive->flags & ~(ZIP_CREATE | ZIP_EXCL));
 
@@ -1160,6 +1437,7 @@ static VALUE zipruby_archive_decrypt(VALUE self, VALUE password) {
 static VALUE zipruby_archive_encrypt(VALUE self, VALUE password) {
   struct zipruby_archive *p_archive;
   long pwdlen;
+  int changed, survivors;
   int errorp;
 
   Check_Type(password, T_STRING);
@@ -1174,12 +1452,18 @@ static VALUE zipruby_archive_encrypt(VALUE self, VALUE password) {
   Data_Get_Struct(self, struct zipruby_archive, p_archive);
   Check_Archive(p_archive);
 
+  changed = _zip_changed(p_archive->archive, &survivors);
+
   if (zip_close(p_archive->archive) == -1) {
     zip_unchange_all(p_archive->archive);
     zip_unchange_archive(p_archive->archive);
     rb_raise(Error, "Encrypt archive failed: %s", zip_strerror(p_archive->archive));
   }
 
+  if (!NIL_P(p_archive->buffer) && changed) {
+    rb_funcall(p_archive->buffer, rb_intern("replace"), 1, rb_funcall(self, rb_intern("read"), 0));
+  }
+
   p_archive->archive = NULL;
   p_archive->flags = (p_archive->flags & ~(ZIP_CREATE | ZIP_EXCL));
 
@@ -1193,6 +1477,59 @@ static VALUE zipruby_archive_encrypt(VALUE self, VALUE password) {
 
   return Qnil;
 }
+
+static VALUE zipruby_archive_read(VALUE self) {
+  VALUE retval = Qnil;
+  struct zipruby_archive *p_archive;
+  FILE *fzip;
+  char buf[DATA_BUFSIZE];
+  ssize_t n;
+  int block_given;
+
+  Data_Get_Struct(self, struct zipruby_archive, p_archive);
+
+  if (NIL_P(p_archive->path)) {
+    rb_raise(rb_eRuntimeError, "invalid Zip::Archive");
+  }
+
+#ifdef _WIN32
+  if (fopen_s(&fzip ,StringValuePtr(p_archive->path), "rb") != 0) {
+    rb_raise(Error, "Read archive failed: Cannot open archive");
+  }
+#else
+  if ((fzip = fopen(StringValuePtr(p_archive->path), "rb")) == NULL) {
+    rb_raise(Error, "Read archive failed: Cannot open archive");
+  }
+#endif
+
+  block_given = rb_block_given_p();
+
+  while ((n = fread(buf, 1, sizeof(buf), fzip)) > 0) {
+    if (block_given) {
+      rb_yield(rb_str_new(buf, n));
+    } else {
+      if (NIL_P(retval)) {
+        retval = rb_str_new(buf, n);
+      } else {
+        rb_str_buf_cat(retval, buf, n);
+      }
+    }
+  }
+
+#ifdef RUBY_WIN32_H
+#undef fclose
+  fclose(fzip);
+#define fclose(f) rb_w32_fclose(f)
+#else
+  fclose(fzip);
+#endif
+
+  if (n == -1) {
+    rb_raise(Error, "Read archive failed");
+  }
+
+  return retval;
+}
 #include "zipruby.h"
 #include "zipruby_error.h"
 #include "ruby.h"
@@ -1784,6 +2121,7 @@ void Init_zipruby_zip() {
   rb_define_const(Zip, "CREATE",    INT2NUM(ZIP_CREATE));
   rb_define_const(Zip, "EXCL",      INT2NUM(ZIP_EXCL));
   rb_define_const(Zip, "CHECKCONS", INT2NUM(ZIP_CHECKCONS));
+  rb_define_const(Zip, "TRUNC",     INT2NUM(ZIP_TRUNC));
 
   rb_define_const(Zip, "FL_NOCASE",     INT2NUM(ZIP_FL_NOCASE));
   rb_define_const(Zip, "FL_NODIR",      INT2NUM(ZIP_FL_NODIR));
@@ -1814,6 +2152,10 @@ void Init_zipruby_zip() {
 #include "zipruby_zip_source_proc.h"
 #include "ruby.h"
 
+static VALUE proc_call(VALUE proc) {
+  return rb_funcall(proc, rb_intern("call"), 0);
+}
+
 static ssize_t read_proc(void *state, void *data, size_t len, enum zip_source_cmd cmd) {
   struct read_proc *z;
   VALUE src;
@@ -1828,13 +2170,12 @@ static ssize_t read_proc(void *state, void *data, size_t len, enum zip_source_cm
     return 0;
 
   case ZIP_SOURCE_READ:
-    src = rb_funcall(z->proc, rb_intern("call"), 1, ULONG2NUM(len));
+    src = rb_protect(proc_call, z->proc, NULL);
 
-    if (NIL_P(src)) {
+    if (TYPE(src) != T_STRING) {
       return 0;
     }
 
-    src = rb_check_convert_type(src, T_STRING, "String", "to_s");
     n = RSTRING(src)->len;
 
     if (n > 0) {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: zipruby
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  version: 0.2.8
 platform: mswin32
 authors: 
 - winebarrel
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-13 00:00:00 +09:00
+date: 2008-07-17 00:00:00 +09:00
 default_executable: 
 dependencies: []