libarchive-ruby-fs 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cad5ca6e728705a251de396e39cc0b704b8c14af
+  data.tar.gz: 466d30f2a49e7af1f622c7de19b3419291740882
+SHA512:
+  metadata.gz: 1399659e2ae6a649edc6e8bad7dfff65015309fbf3dd9d4ed3c1c0a1723358adcf878b8d68db514fa4bf046c4da3a95d68b2032644d85a66f7710a8744e8c60e
+  data.tar.gz: 941744ac5459dcc17afd503354f306acba6522c1756d3bdb27ba8b1ecb8bca7e72a6570790e23e10286d698565603f80680badb30759ccf7ddd64100661cde0b

data/ext/rblibarchive/archive_read_support_compression.c

@@ -0,0 +1,31 @@
+#include <errno.h>
+#include <archive.h>
+
+static struct {
+  int code;
+  int (*setter)(struct archive *);
+} codes[] = {
+  { ARCHIVE_COMPRESSION_NONE,     archive_read_support_compression_none     },
+  { ARCHIVE_COMPRESSION_GZIP,     archive_read_support_compression_gzip     },
+  { ARCHIVE_COMPRESSION_BZIP2,    archive_read_support_compression_bzip2    },
+  { ARCHIVE_COMPRESSION_COMPRESS, archive_read_support_compression_compress },
+  // XXX:
+  /*
+  { ARCHIVE_COMPRESSION_PROGRAM,  archive_read_support_compression_program  },
+  { ARCHIVE_COMPRESSION_LZMA,     archive_read_support_compression_lzma     },
+  */
+  { -1,                           NULL                                      },
+};
+
+int archive_read_support_compression(struct archive *a, int code) {
+  int i;
+
+  for (i = 0; codes[i].code >= 0; i++) {
+    if (codes[i].code == code) {
+      return codes[i].setter(a);
+    }
+  }
+
+  archive_set_error(a, EINVAL, "No such compression");
+  return ARCHIVE_FATAL;
+}

data/ext/rblibarchive/archive_read_support_compression.h

@@ -0,0 +1,6 @@
+#ifndef _ARCHIVE_READ_SUPPORT_COMPRESSION_H_
+#define _ARCHIVE_READ_SUPPORT_COMPRESSION_H_
+
+int archive_read_support_compression(struct archive *a, int code);
+
+#endif

data/ext/rblibarchive/archive_read_support_format.c

@@ -0,0 +1,32 @@
+#include <errno.h>
+#include <archive.h>
+
+static struct {
+  int code;
+  int (*setter)(struct archive *);
+} codes[] = {
+  { ARCHIVE_FORMAT_CPIO,       archive_read_support_format_cpio    },
+  { ARCHIVE_FORMAT_TAR,        archive_read_support_format_tar     },
+  { ARCHIVE_FORMAT_TAR_GNUTAR, archive_read_support_format_gnutar  },
+  { ARCHIVE_FORMAT_ISO9660,    archive_read_support_format_iso9660 },
+  { ARCHIVE_FORMAT_ZIP,        archive_read_support_format_zip     },
+  { ARCHIVE_FORMAT_EMPTY,      archive_read_support_format_empty   },
+  { ARCHIVE_FORMAT_AR,         archive_read_support_format_ar      },
+#ifdef ARCHIVE_FORMAT_MTREE
+  { ARCHIVE_FORMAT_MTREE,      archive_read_support_format_mtree   },
+#endif
+  { -1,                        NULL                                },
+};
+
+int archive_read_support_format(struct archive *a, int code) {
+  int i;
+
+  for (i = 0; codes[i].code >= 0; i++) {
+    if (codes[i].code == code) {
+      return codes[i].setter(a);
+    }
+  }
+
+  archive_set_error(a, EINVAL, "No such format");
+  return ARCHIVE_FATAL;
+}

data/ext/rblibarchive/archive_read_support_format.h

@@ -0,0 +1,6 @@
+#ifndef _ARCHIVE_READ_SUPPORT_FORMAT_H_
+#define _ARCHIVE_READ_SUPPORT_FORMAT_H_
+
+int archive_read_support_format(struct archive *a, int code);
+
+#endif

data/ext/rblibarchive/archive_write_open_rb_str.c

@@ -0,0 +1,25 @@
+#include <archive.h>
+#include <ruby.h>
+
+static int rb_str_write_open(struct archive *a, void *client_data) {
+  if (archive_write_get_bytes_in_last_block(a) == -1) {
+    archive_write_set_bytes_in_last_block(a, 1);
+  }
+
+  return ARCHIVE_OK;
+}
+
+static int rb_str_write_close(struct archive *a, void *client_data) {
+  return ARCHIVE_OK;
+}
+
+
+static ssize_t rb_str_write(struct archive *a, void *client_data, const void *buff, size_t length) {
+  VALUE str = (VALUE) client_data;
+  rb_str_cat(str, buff, length);
+  return length;
+}
+
+int archive_write_open_rb_str(struct archive *a, VALUE str) {
+  return archive_write_open(a, (void *) str, rb_str_write_open, rb_str_write, rb_str_write_close);
+}

data/ext/rblibarchive/archive_write_open_rb_str.h

@@ -0,0 +1,6 @@
+#ifndef _ARCHIVE_WRITE_OPEN_RB_STR_H_
+#define _ARCHIVE_WRITE_OPEN_RB_STR_H_
+
+int archive_write_open_rb_str(struct archive *a, VALUE str);
+
+#endif

data/ext/rblibarchive/archive_write_set_compression.c

@@ -0,0 +1,32 @@
+#include <errno.h>
+#include <archive.h>
+
+static struct {
+  int code;
+  int (*setter)(struct archive *);
+} codes[] = {
+  { ARCHIVE_COMPRESSION_NONE,     archive_write_set_compression_none     },
+  { ARCHIVE_COMPRESSION_GZIP,     archive_write_set_compression_gzip     },
+  { ARCHIVE_COMPRESSION_BZIP2,    archive_write_set_compression_bzip2    },
+#if ARCHIVE_VERSION_NUMBER >= 2005000
+  { ARCHIVE_COMPRESSION_COMPRESS, archive_write_set_compression_compress },
+#endif
+  // XXX:
+  /*
+  { ARCHIVE_COMPRESSION_PROGRAM,  archive_read_support_compression_program  },
+  */
+  { -1,                           NULL                                      },
+};
+
+int archive_write_set_compression(struct archive *a, int code) {
+  int i;
+
+  for (i = 0; codes[i].code >= 0; i++) {
+    if (codes[i].code == code) {
+      return codes[i].setter(a);
+    }
+  }
+
+  archive_set_error(a, EINVAL, "No such compression");
+  return ARCHIVE_FATAL;
+}

data/ext/rblibarchive/archive_write_set_compression.h

@@ -0,0 +1,6 @@
+#ifndef _ARCHIVE_WRITE_SET_COMPRESSION_H_
+#define _ARCHIVE_WRITE_SET_COMPRESSION_H_
+
+int archive_write_set_compression(struct archive *a, int code);
+
+#endif

data/ext/rblibarchive/extconf.rb

@@ -0,0 +1,20 @@
+require 'mkmf'
+
+unless (libarchive_cfg = pkg_config('libarchive'))
+  abort 'Failed to locate pkg-config file for libarchive.'
+end
+
+unless have_library('archive')
+  abort 'Failed to test-link against libarchive.'
+end
+
+non_std_location = libarchive_cfg.detect { |flag| flag =~ /^-L/ }
+if non_std_location
+  non_std_location.gsub!('-L', '')
+  $LDFLAGS << " -Wl,-rpath,#{non_std_location}"
+  message "embedding path to library into rblibarchive.so: #{non_std_location}\n"
+end
+
+with_cppflags("#{(libarchive_cfg.detect { |flag| flag =~ /^-I/ })}") do
+  create_makefile('rblibarchive')
+end

data/ext/rblibarchive/libarchive.c

@@ -0,0 +1,92 @@
+#include "libarchive_internal.h"
+
+VALUE rb_mArchive;
+VALUE rb_eArchiveError;
+
+/* */
+VALUE rb_libarchive_s_version_number(VALUE self) {
+#if ARCHIVE_VERSION >= 2005000
+  return INT2NUM(archive_version_number());
+#else
+  return INT2NUM(archive_version_stamp());
+#endif
+}
+
+/* */
+VALUE rb_libarchive_s_version_string(VALUE self) {
+#if ARCHIVE_VERSION_NUMBER >= 2005000
+  return rb_str_new2(archive_version_string());
+#else
+  return rb_str_new2(archive_version());
+#endif
+}
+
+void DLLEXPORT Init_rblibarchive() {
+  rb_mArchive = rb_define_module("LibArchiveRubyFs");
+
+  rb_define_const(rb_mArchive, "COMPRESSION_NONE",     INT2NUM(ARCHIVE_COMPRESSION_NONE));
+#ifdef HAVE_ZLIB_H
+  rb_define_const(rb_mArchive, "COMPRESSION_GZIP",     INT2NUM(ARCHIVE_COMPRESSION_GZIP));
+#endif
+#ifdef HAVE_BZLIB_H
+  rb_define_const(rb_mArchive, "COMPRESSION_BZIP2",    INT2NUM(ARCHIVE_COMPRESSION_BZIP2));
+#endif
+  rb_define_const(rb_mArchive, "COMPRESSION_COMPRESS", INT2NUM(ARCHIVE_COMPRESSION_COMPRESS));
+  // XXX:
+  /*
+  rb_define_const(rb_mArchive, "COMPRESSION_PROGRAM",  INT2NUM(ARCHIVE_COMPRESSION_PROGRAM));
+  rb_define_const(rb_mArchive, "COMPRESSION_LZMA",     INT2NUM(ARCHIVE_COMPRESSION_LZMA));
+  */
+
+  rb_define_const(rb_mArchive, "FORMAT_BASE_MASK",           INT2NUM(ARCHIVE_FORMAT_BASE_MASK));
+  rb_define_const(rb_mArchive, "FORMAT_CPIO",                INT2NUM(ARCHIVE_FORMAT_CPIO));
+  rb_define_const(rb_mArchive, "FORMAT_CPIO_POSIX",          INT2NUM(ARCHIVE_FORMAT_CPIO_POSIX));
+  rb_define_const(rb_mArchive, "FORMAT_CPIO_BIN_LE",         INT2NUM(ARCHIVE_FORMAT_CPIO_BIN_LE));
+  rb_define_const(rb_mArchive, "FORMAT_CPIO_BIN_BE",         INT2NUM(ARCHIVE_FORMAT_CPIO_BIN_BE));
+  rb_define_const(rb_mArchive, "FORMAT_CPIO_SVR4_NOCRC",     INT2NUM(ARCHIVE_FORMAT_CPIO_SVR4_NOCRC));
+  rb_define_const(rb_mArchive, "FORMAT_CPIO_SVR4_CRC",       INT2NUM(ARCHIVE_FORMAT_CPIO_SVR4_CRC));
+  rb_define_const(rb_mArchive, "FORMAT_SHAR",                INT2NUM(ARCHIVE_FORMAT_SHAR));
+  rb_define_const(rb_mArchive, "FORMAT_SHAR_BASE",           INT2NUM(ARCHIVE_FORMAT_SHAR_BASE));
+  rb_define_const(rb_mArchive, "FORMAT_SHAR_DUMP",           INT2NUM(ARCHIVE_FORMAT_SHAR_DUMP));
+  rb_define_const(rb_mArchive, "FORMAT_TAR",                 INT2NUM(ARCHIVE_FORMAT_TAR));
+  rb_define_const(rb_mArchive, "FORMAT_TAR_USTAR",           INT2NUM(ARCHIVE_FORMAT_TAR_USTAR));
+  rb_define_const(rb_mArchive, "FORMAT_TAR_PAX_INTERCHANGE", INT2NUM(ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE));
+  rb_define_const(rb_mArchive, "FORMAT_TAR_PAX_RESTRICTED",  INT2NUM(ARCHIVE_FORMAT_TAR_PAX_RESTRICTED));
+  rb_define_const(rb_mArchive, "FORMAT_TAR_GNUTAR",          INT2NUM(ARCHIVE_FORMAT_TAR_GNUTAR));
+  rb_define_const(rb_mArchive, "FORMAT_ISO9660",             INT2NUM(ARCHIVE_FORMAT_ISO9660));
+  rb_define_const(rb_mArchive, "FORMAT_ISO9660_ROCKRIDGE",   INT2NUM(ARCHIVE_FORMAT_ISO9660_ROCKRIDGE));
+  rb_define_const(rb_mArchive, "FORMAT_ZIP",                 INT2NUM(ARCHIVE_FORMAT_ZIP));
+  rb_define_const(rb_mArchive, "FORMAT_EMPTY",               INT2NUM(ARCHIVE_FORMAT_EMPTY));
+  rb_define_const(rb_mArchive, "FORMAT_AR",                  INT2NUM(ARCHIVE_FORMAT_AR));
+  rb_define_const(rb_mArchive, "FORMAT_AR_GNU",              INT2NUM(ARCHIVE_FORMAT_AR_GNU));
+  rb_define_const(rb_mArchive, "FORMAT_AR_BSD",              INT2NUM(ARCHIVE_FORMAT_AR_BSD));
+#ifdef ARCHIVE_FORMAT_MTREE
+  rb_define_const(rb_mArchive, "FORMAT_MTREE",               INT2NUM(ARCHIVE_FORMAT_MTREE));
+#endif
+
+  rb_define_const(rb_mArchive, "EXTRACT_OWNER",              INT2NUM(ARCHIVE_EXTRACT_OWNER));
+  rb_define_const(rb_mArchive, "EXTRACT_PERM",               INT2NUM(ARCHIVE_EXTRACT_PERM));
+  rb_define_const(rb_mArchive, "EXTRACT_TIME",               INT2NUM(ARCHIVE_EXTRACT_TIME));
+  rb_define_const(rb_mArchive, "EXTRACT_NO_OVERWRITE",       INT2NUM(ARCHIVE_EXTRACT_NO_OVERWRITE));
+  rb_define_const(rb_mArchive, "EXTRACT_UNLINK",             INT2NUM(ARCHIVE_EXTRACT_UNLINK));
+  rb_define_const(rb_mArchive, "EXTRACT_ACL",                INT2NUM(ARCHIVE_EXTRACT_ACL));
+  rb_define_const(rb_mArchive, "EXTRACT_FFLAGS",             INT2NUM(ARCHIVE_EXTRACT_FFLAGS));
+  rb_define_const(rb_mArchive, "EXTRACT_XATTR",              INT2NUM(ARCHIVE_EXTRACT_XATTR));
+  rb_define_const(rb_mArchive, "EXTRACT_SECURE_SYMLINKS",    INT2NUM(ARCHIVE_EXTRACT_SECURE_SYMLINKS));
+  rb_define_const(rb_mArchive, "EXTRACT_SECURE_NODOTDOT",    INT2NUM(ARCHIVE_EXTRACT_SECURE_NODOTDOT));
+  rb_define_const(rb_mArchive, "EXTRACT_NO_AUTODIR",         INT2NUM(ARCHIVE_EXTRACT_NO_AUTODIR));
+  rb_define_const(rb_mArchive, "EXTRACT_NO_OVERWRITE_NEWER", INT2NUM(ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER));
+#ifdef ARCHIVE_EXTRACT_SPARSE
+  rb_define_const(rb_mArchive, "EXTRACT_SPARSE",             INT2NUM(ARCHIVE_EXTRACT_SPARSE));
+#endif
+
+  rb_define_module_function(rb_mArchive, "version_number", rb_libarchive_s_version_number, 0);
+  rb_define_module_function(rb_mArchive, "version_string", rb_libarchive_s_version_string, 0);
+
+  rb_eArchiveError = rb_define_class_under(rb_mArchive, "Error", rb_eStandardError);
+
+  Init_libarchive_reader();
+  Init_libarchive_writer();
+  Init_libarchive_archive();
+  Init_libarchive_entry();
+}

data/ext/rblibarchive/libarchive_archive.c

@@ -0,0 +1,84 @@
+#include "libarchive_internal.h"
+
+extern VALUE rb_cArchiveReader;
+extern VALUE rb_cArchiveWriter;
+extern VALUE rb_eArchiveError;
+
+static void rb_libarchive_archive_free(struct rb_libarchive_archive_container *p) {
+  xfree(p);
+}
+
+static void rb_libarchive_archive_mark(struct rb_libarchive_archive_container *p) {
+  rb_gc_mark(p->memory);
+}
+
+VALUE rb_libarchive_archive_alloc(VALUE klass) {
+  struct rb_libarchive_archive_container *p = ALLOC(struct rb_libarchive_archive_container);
+  p->ar = NULL;
+  p->eof = 0;
+  p->memory = Qnil;
+  return Data_Wrap_Struct(klass, rb_libarchive_archive_mark, rb_libarchive_archive_free, p);
+}
+
+/* */
+static VALUE rb_libarchive_archive_position_compressed(VALUE self) {
+  struct rb_libarchive_archive_container *p;
+  Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
+  Check_Archive(p);
+  return LONG2NUM(archive_position_compressed(p->ar));
+}
+
+/* */
+static VALUE rb_libarchive_archive_position_uncompressed(VALUE self) {
+  struct rb_libarchive_archive_container *p;
+  Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
+  Check_Archive(p);
+  return LONG2NUM(archive_position_uncompressed(p->ar));
+}
+
+/* */
+static VALUE rb_libarchive_archive_compression_name(VALUE self) {
+  struct rb_libarchive_archive_container *p;
+  Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
+  Check_Archive(p);
+  return rb_str_new2(archive_compression_name(p->ar));
+}
+
+/* */
+static VALUE rb_libarchive_archive_compression(VALUE self) {
+  struct rb_libarchive_archive_container *p;
+  Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
+  Check_Archive(p);
+  return INT2NUM(archive_compression(p->ar));
+}
+
+/* */
+static VALUE rb_libarchive_archive_format_name(VALUE self) {
+  struct rb_libarchive_archive_container *p;
+  Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
+  Check_Archive(p);
+  return rb_str_new2(archive_format_name(p->ar));
+}
+
+/* */
+static VALUE rb_libarchive_archive_format(VALUE self) {
+  struct rb_libarchive_archive_container *p;
+  Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
+  Check_Archive(p);
+  return NUM2INT(archive_format(p->ar));
+}
+
+void Init_libarchive_archive() {
+  rb_define_method(rb_cArchiveReader, "position_compressed", rb_libarchive_archive_position_compressed, 0);
+  rb_define_method(rb_cArchiveWriter, "position_compressed", rb_libarchive_archive_position_compressed, 0);
+  rb_define_method(rb_cArchiveReader, "position_uncompressed", rb_libarchive_archive_position_uncompressed, 0);
+  rb_define_method(rb_cArchiveWriter, "position_uncompressed", rb_libarchive_archive_position_uncompressed, 0);
+  rb_define_method(rb_cArchiveReader, "compression_name", rb_libarchive_archive_compression_name, 0);
+  rb_define_method(rb_cArchiveWriter, "compression_name", rb_libarchive_archive_compression_name, 0);
+  rb_define_method(rb_cArchiveReader, "compression", rb_libarchive_archive_compression, 0);
+  rb_define_method(rb_cArchiveWriter, "compression", rb_libarchive_archive_compression, 0);
+  rb_define_method(rb_cArchiveReader, "format_name", rb_libarchive_archive_format_name, 0);
+  rb_define_method(rb_cArchiveWriter, "format_name", rb_libarchive_archive_format_name, 0);
+  rb_define_method(rb_cArchiveReader, "format", rb_libarchive_archive_format, 0);
+  rb_define_method(rb_cArchiveWriter, "format", rb_libarchive_archive_format, 0);
+}