zipruby 0.2.6 → 0.2.8

data/ext/extconf.rb

@@ -1,5 +1,8 @@
 require 'mkmf'
 
 if have_header('zlib.h') and have_library('z')
+  have_func('fseeko')
+  have_func('ftello')
+  have_func('mkstemp')
   create_makefile('zipruby')
 end

data/ext/tmpfile.c

@@ -0,0 +1,173 @@
+#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);
+}

data/ext/tmpfile.h

@@ -0,0 +1,9 @@
+#ifndef __TMPFILE_H__
+#define __TMPFILE_H__
+
+#include <stdio.h>
+
+char *zipruby_tmpnam(void *data, int len);
+void zipruby_rmtmp(const char *tmpfilnam);
+
+#endif

data/ext/zip.h

@@ -55,6 +55,8 @@ typedef int ssize_t;
 #define ZIP_CREATE           1
 #define ZIP_EXCL             2
 #define ZIP_CHECKCONS        4
+// modified for Zip/Ruby by SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
+#define ZIP_TRUNC            8
 
 
 /* flags for zip_name_locate, zip_fopen, zip_stat, ... */
@@ -207,6 +209,7 @@ int zip_unchange_archive(struct zip *);
 // modified for Zip/Ruby by SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
 int zip_decrypt(const char *path, const char *pwd, int pwdlen, int *errorp, int *wrongpwd);
 int zip_encrypt(const char *path, const char *pwd, int pwdlen, int *errorp);
+int _zip_changed(struct zip *, int *);
 
 #ifdef __cplusplus
 }

data/ext/zip_close.c

@@ -61,8 +61,7 @@ static void ch_set_error(struct zip_error *, zip_source_callback, void *);
 // modified for Zip/Ruby by SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
 //static int copy_data(FILE *, off_t, FILE *, struct zip_error *);
 //static int _zip_cdir_set_comment(struct zip_cdir *, struct zip *);
-static int _zip_changed(struct zip *, int *);
-// modified for Zip/Ruby by SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
+//static int _zip_changed(struct zip *, int *);
 //static char *_zip_create_temp_output(struct zip *, FILE **);
 
 
@@ -512,7 +511,8 @@ _zip_cdir_set_comment(struct zip_cdir *dest, struct zip *src)
 
 
 
-static int
+// modified for Zip/Ruby by SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
+/*static*/ int
 _zip_changed(struct zip *za, int *survivorsp)
 {
     int changed, i, survivors;

data/ext/zip_open.c

@@ -409,6 +409,10 @@ _zip_file_exists(const char *fn, int flags, int *zep)
 	    return -1;
 	}
     }
+    // modified for Zip/Ruby by SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
+    else if ((flags & ZIP_CREATE) && (flags & ZIP_TRUNC)) {
+      return 0;
+    }
     else if ((flags & ZIP_EXCL)) {
 	set_error(zep, NULL, ZIP_ER_EXISTS);
 	return -1;

data/ext/zipruby.h

@@ -1,7 +1,7 @@
 #ifndef __ZIPRUBY_H__
 #define __ZIPRUBY_H__
 
-#define VERSION "0.2.6"
+#define VERSION "0.2.8"
 #define ERRSTR_BUFSIZE 256
 #define DATA_BUFSIZE 8192
 

data/ext/zipruby_archive.c

@@ -4,6 +4,7 @@
 #include "zipruby.h"
 #include "zipruby_archive.h"
 #include "zipruby_zip_source_proc.h"
+#include "tmpfile.h"
 #include "ruby.h"
 #include "rubyio.h"
 
@@ -11,6 +12,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);
@@ -47,6 +49,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;
@@ -59,6 +62,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);
@@ -98,6 +102,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) {
@@ -106,15 +111,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);
 }
 
@@ -162,6 +175,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;
@@ -217,6 +300,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;
@@ -225,14 +309,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;
@@ -1068,17 +1158,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));
 
@@ -1103,6 +1200,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);
@@ -1117,12 +1215,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));
 
@@ -1141,6 +1245,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);
@@ -1155,12 +1260,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));
 
@@ -1174,3 +1285,56 @@ 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;
+}

data/ext/zipruby_archive.h

@@ -8,6 +8,8 @@ struct zipruby_archive {
   struct zip *archive;
   VALUE path;
   int flags;
+  char *tmpfilnam;
+  VALUE buffer;
 };
 
 void Init_zipruby_archive();

data/ext/zipruby_zip.c

@@ -12,6 +12,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));

data/ext/zipruby_zip_source_proc.c

@@ -5,6 +5,10 @@
 #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;
@@ -19,13 +23,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) {