ruby-magic-static 0.3.0

data/ext/magic/ruby-magic.h

@@ -0,0 +1,307 @@
+#if !defined(_RUBY_MAGIC_H)
+#define _RUBY_MAGIC_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include "common.h"
+#include "functions.h"
+
+#define MAGIC_SYNCHRONIZED(f, d) magic_lock(object, (f), (d))
+
+#define MAGIC_OBJECT(o) \
+	Data_Get_Struct(object, magic_object_t, (o))
+
+#define MAGIC_COOKIE(o, c) \
+	((c) = MAGIC_OBJECT((o))->cookie)
+
+#define MAGIC_CLOSED_P(o) RTEST(rb_mgc_close_p((o)))
+#define MAGIC_LOADED_P(o) RTEST(rb_mgc_load_p((o)))
+
+#define MAGIC_WARNING(i, ...)				  \
+	do {						  \
+		if (!(i) || !(rb_mgc_warning & BIT(i))) { \
+			rb_mgc_warning |= BIT(i);	  \
+			rb_warn(__VA_ARGS__);		  \
+		}					  \
+	} while(0)
+
+#define MAGIC_ARGUMENT_TYPE_ERROR(o, ...) \
+	rb_raise(rb_eTypeError, error(E_ARGUMENT_TYPE_INVALID), CLASS_NAME((o)), __VA_ARGS__)
+
+#define MAGIC_GENERIC_ERROR(k, e, m) \
+	rb_exc_raise(magic_generic_error((k), (e), error(m)))
+
+#define MAGIC_LIBRARY_ERROR(c) \
+	rb_exc_raise(magic_library_error(rb_mgc_eMagicError, (c)))
+
+#define MAGIC_CHECK_INTEGER_TYPE(o) magic_check_type((o), T_FIXNUM)
+#define MAGIC_CHECK_STRING_TYPE(o)  magic_check_type((o), T_STRING)
+
+#define MAGIC_CHECK_ARGUMENT_MISSING(t, o)					     \
+	do {									     \
+		if ((t) < (o))							     \
+			rb_raise(rb_eArgError, error(E_ARGUMENT_MISSING), (t), (o)); \
+	} while(0)
+
+#define MAGIC_CHECK_ARRAY_EMPTY(o)							  \
+	do {										  \
+		if (RARRAY_EMPTY_P(o))							  \
+			rb_raise(rb_eArgError, "%s", error(E_ARGUMENT_TYPE_ARRAY_EMPTY)); \
+	} while(0)
+
+#define MAGIC_CHECK_ARRAY_OF_STRINGS(o) \
+	magic_check_type_array_of_strings((o))
+
+#define MAGIC_CHECK_OPEN(o)						  \
+	do {								  \
+		if (MAGIC_CLOSED_P(o))					  \
+			MAGIC_GENERIC_ERROR(rb_mgc_eLibraryError, EFAULT, \
+					    E_MAGIC_LIBRARY_CLOSED);	  \
+	} while(0)
+
+#define MAGIC_CHECK_LOADED(o)						 \
+	do {								 \
+		if (!MAGIC_LOADED_P(o))					 \
+			MAGIC_GENERIC_ERROR(rb_mgc_eMagicError, EFAULT,	 \
+					    E_MAGIC_LIBRARY_NOT_LOADED); \
+	} while(0)
+
+#define MAGIC_STRINGIFY(s) #s
+
+#define MAGIC_DEFINE_FLAG(c) \
+	rb_define_const(rb_cMagic, MAGIC_STRINGIFY(c), INT2NUM(MAGIC_##c));
+
+#define MAGIC_DEFINE_PARAMETER(c) \
+	rb_define_const(rb_cMagic, MAGIC_STRINGIFY(PARAM_##c), INT2NUM(MAGIC_PARAM_##c));
+
+#define error(t) errors[(t)]
+
+enum error {
+	E_UNKNOWN = 0,
+	E_NOT_ENOUGH_MEMORY,
+	E_ARGUMENT_MISSING,
+	E_ARGUMENT_TYPE_INVALID,
+	E_ARGUMENT_TYPE_ARRAY_EMPTY,
+	E_ARGUMENT_TYPE_ARRAY_STRINGS,
+	E_MAGIC_LIBRARY_INITIALIZE,
+	E_MAGIC_LIBRARY_CLOSED,
+	E_MAGIC_LIBRARY_NOT_LOADED,
+	E_PARAM_INVALID_TYPE,
+	E_PARAM_INVALID_VALUE,
+	E_FLAG_NOT_IMPLEMENTED,
+	E_FLAG_INVALID_TYPE
+};
+
+typedef struct parameter {
+	size_t value;
+	int tag;
+} parameter_t;
+
+typedef union file {
+	const char *path;
+	int fd;
+} file_t;
+
+typedef struct buffers {
+	size_t count;
+	size_t *sizes;
+	void **pointers;
+} buffers_t;
+
+typedef struct magic_object {
+	magic_t cookie;
+	VALUE mutex;
+	unsigned int database_loaded:1;
+	unsigned int stop_on_errors:1;
+} magic_object_t;
+
+typedef struct magic_arguments {
+	union {
+		file_t file;
+		parameter_t parameter;
+		buffers_t buffers;
+	} type;
+	magic_t cookie;
+	const char *result;
+	int flags;
+	int status;
+	unsigned int stop_on_errors:1;
+} magic_arguments_t;
+
+typedef struct magic_exception {
+	const char *magic_error;
+	VALUE klass;
+	int magic_errno;
+} magic_exception_t;
+
+static const char *errors[] = {
+	[E_UNKNOWN]			= "an unknown error has occurred",
+	[E_NOT_ENOUGH_MEMORY]		= "cannot allocate memory",
+	[E_ARGUMENT_MISSING]		= "wrong number of arguments (given %d, expected %d)",
+	[E_ARGUMENT_TYPE_INVALID]	= "wrong argument type %s (expected %s)",
+	[E_ARGUMENT_TYPE_ARRAY_EMPTY]	= "arguments list cannot be empty (expected array of String)",
+	[E_ARGUMENT_TYPE_ARRAY_STRINGS]	= "wrong argument type %s in arguments list (expected String)",
+	[E_MAGIC_LIBRARY_INITIALIZE]	= "failed to initialize Magic library",
+	[E_MAGIC_LIBRARY_CLOSED]	= "Magic library is not open",
+	[E_MAGIC_LIBRARY_NOT_LOADED]	= "Magic library not loaded",
+	[E_PARAM_INVALID_TYPE]		= "unknown or invalid parameter specified",
+	[E_PARAM_INVALID_VALUE]		= "invalid parameter value specified",
+	[E_FLAG_NOT_IMPLEMENTED]	= "flag is not implemented",
+	[E_FLAG_INVALID_TYPE]		= "unknown or invalid flag specified",
+	NULL
+};
+
+static inline VALUE
+magic_shift(VALUE v)
+{
+	return ARRAY_P(v) ?				       \
+		rb_funcall(v, rb_intern("shift"), 0, Qundef) : \
+		Qnil;
+}
+
+static inline VALUE
+magic_split(VALUE a, VALUE b)
+{
+	return (STRING_P(a) && STRING_P(b)) ?		  \
+		rb_funcall(a, rb_intern("split"), 1, b) : \
+		Qnil;
+}
+
+static inline VALUE
+magic_join(VALUE a, VALUE b)
+{
+	return (ARRAY_P(a) && STRING_P(b)) ?		 \
+		rb_funcall(a, rb_intern("join"), 1, b) : \
+		Qnil;
+}
+
+static inline VALUE
+magic_flatten(VALUE v)
+{
+	return ARRAY_P(v) ?					 \
+		rb_funcall(v, rb_intern("flatten"), 0, Qundef) : \
+		Qnil;
+}
+
+static int
+magic_fileno(VALUE object)
+{
+	int fd;
+	rb_io_t *io;
+
+	if (rb_respond_to(object, rb_intern("fileno"))) {
+		object = rb_funcall(object, rb_intern("fileno"), 0, Qundef);
+		return NUM2INT(object);
+	}
+
+	if (!FILE_P(object))
+		object = rb_convert_type(object, T_FILE, "IO", "to_io");
+
+	GetOpenFile(object, io);
+	if ((fd = FPTR_TO_FD(io)) < 0)
+		rb_raise(rb_eIOError, "closed stream");
+
+	return fd;
+}
+
+static inline VALUE
+magic_path(VALUE object)
+{
+	if (STRING_P(object))
+		return object;
+
+	if (rb_respond_to(object, rb_intern("to_path")))
+		return rb_funcall(object, rb_intern("to_path"), 0, Qundef);
+
+	if (rb_respond_to(object, rb_intern("path")))
+		return rb_funcall(object, rb_intern("path"), 0, Qundef);
+
+	if (rb_respond_to(object, rb_intern("to_s")))
+		return rb_funcall(object, rb_intern("to_s"), 0, Qundef);
+
+	return Qnil;
+}
+
+static inline void
+magic_check_type(VALUE object, int type)
+{
+	VALUE boolean = Qundef;
+
+	boolean = rb_obj_is_kind_of(object, T_INTEGER);
+	if (type == T_FIXNUM && !RVAL2CBOOL(boolean))
+		MAGIC_ARGUMENT_TYPE_ERROR(object, rb_class2name(T_INTEGER));
+
+	Check_Type(object, type);
+}
+
+static inline void
+magic_check_type_array_of_strings(VALUE object)
+{
+	VALUE value = Qundef;
+
+	for (int i = 0; i < RARRAY_LEN(object); i++) {
+		value = RARRAY_AREF(object, (long)i);
+		if (NIL_P(value) || !STRING_P(value))
+			rb_raise(rb_eTypeError,
+				 error(E_ARGUMENT_TYPE_ARRAY_STRINGS),
+				 CLASS_NAME(value));
+	}
+}
+
+RUBY_EXTERN ID id_at_flags;
+RUBY_EXTERN ID id_at_paths;
+
+RUBY_EXTERN VALUE rb_cMagic;
+
+RUBY_EXTERN VALUE rb_mgc_eError;
+RUBY_EXTERN VALUE rb_mgc_eMagicError;
+RUBY_EXTERN VALUE rb_mgc_eLibraryError;
+RUBY_EXTERN VALUE rb_mgc_eParameterError;
+RUBY_EXTERN VALUE rb_mgc_eFlagsError;
+RUBY_EXTERN VALUE rb_mgc_eNotImplementedError;
+
+RUBY_EXTERN VALUE rb_mgc_get_do_not_auto_load_global(VALUE object);
+RUBY_EXTERN VALUE rb_mgc_set_do_not_auto_load_global(VALUE object,
+						     VALUE value);
+
+RUBY_EXTERN VALUE rb_mgc_get_do_not_stop_on_error_global(VALUE object);
+RUBY_EXTERN VALUE rb_mgc_set_do_not_stop_on_error_global(VALUE object,
+							 VALUE value);
+
+RUBY_EXTERN VALUE rb_mgc_initialize(VALUE object, VALUE arguments);
+
+RUBY_EXTERN VALUE rb_mgc_get_do_not_stop_on_error(VALUE object);
+RUBY_EXTERN VALUE rb_mgc_set_do_not_stop_on_error(VALUE object, VALUE value);
+
+RUBY_EXTERN VALUE rb_mgc_open_p(VALUE object);
+RUBY_EXTERN VALUE rb_mgc_close(VALUE object);
+RUBY_EXTERN VALUE rb_mgc_close_p(VALUE object);
+
+RUBY_EXTERN VALUE rb_mgc_get_paths(VALUE object);
+
+RUBY_EXTERN VALUE rb_mgc_get_parameter(VALUE object, VALUE tag);
+RUBY_EXTERN VALUE rb_mgc_set_parameter(VALUE object, VALUE tag, VALUE value);
+
+RUBY_EXTERN VALUE rb_mgc_get_flags(VALUE object);
+RUBY_EXTERN VALUE rb_mgc_set_flags(VALUE object, VALUE value);
+
+RUBY_EXTERN VALUE rb_mgc_load(VALUE object, VALUE arguments);
+RUBY_EXTERN VALUE rb_mgc_load_buffers(VALUE object, VALUE arguments);
+RUBY_EXTERN VALUE rb_mgc_load_p(VALUE object);
+
+RUBY_EXTERN VALUE rb_mgc_compile(VALUE object, VALUE arguments);
+RUBY_EXTERN VALUE rb_mgc_check(VALUE object, VALUE arguments);
+
+RUBY_EXTERN VALUE rb_mgc_file(VALUE object, VALUE value);
+RUBY_EXTERN VALUE rb_mgc_buffer(VALUE object, VALUE value);
+RUBY_EXTERN VALUE rb_mgc_descriptor(VALUE object, VALUE value);
+
+RUBY_EXTERN VALUE rb_mgc_version(VALUE object);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* _RUBY_MAGIC_H */

data/kwilczynski-public.pem

@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIEIDCCAoigAwIBAgIBATANBgkqhkiG9w0BAQsFADAdMRswGQYDVQQDDBJrdy9E
+Qz1saW51eC9EQz1jb20wHhcNMjEwMTAxMDAwOTU0WhcNMjYwMTAxMDAwOTU0WjAd
+MRswGQYDVQQDDBJrdy9EQz1saW51eC9EQz1jb20wggGiMA0GCSqGSIb3DQEBAQUA
+A4IBjwAwggGKAoIBgQCv02+pOrAMVUipLY7qjNLx8OMfMjnVCBH21SsWn8gyIHE9
+BtQ+tlsJU8nWNjlr++7SKIV5vQmyYsC2UY0cdcFASdoV0A3Lc2Z0makfvPgcIlpL
+5THqQtP11tJfhjQ3MSFJYRG2D6m6GNqA+WTTsvJbPIxy5PHv5xb+79LLzcVxB9Op
+C0ervTOF8W6Ye4EDvhQ5tppOr/d26UQV+8zRuxjxx5uZSPfUrE9u/gIIdeROoB3T
+cnjAfzvjIzampLQppvhUnT4Vf5Rum2LohZ5GosKLy7tM65vr1eLyI2ndvS1MXWrU
+05sFKm5CSqORD+TVkR1jd3z5HdPgO1KwadccxFixoI8kEIt/iixWTzbka2T2iJoq
+5DeNMEMYYAZKuAGBzBcgvgPccCeAXFVF9AHjfaGRUMmYNHKK2HD6AdgNdhcE18V+
+CJxFtggCJFYc1ygFOsHZPTbKo9+3ybSQhAswtDosWt26utUT1JOc2Bkj1sgQ0Yrk
+orANsdYz2ee3JFkzx08CAwEAAaNrMGkwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
+HQYDVR0OBBYEFME41mMBb/XAHgjhlX4kE8xnXxewMBcGA1UdEQQQMA6BDGt3QGxp
+bnV4LmNvbTAXBgNVHRIEEDAOgQxrd0BsaW51eC5jb20wDQYJKoZIhvcNAQELBQAD
+ggGBAF/2ryrSgTpf0+wYG46Oi6V3p9A3uMxxbGsh0ZmlLQT1Z1ozclR+xzxzyIFC
+i7YWYyR085brDBnYNXgnUT9Nm4iAYx58MaPD28IFrcX0XA3DJE6Wkx4MmMV0chiJ
+kf5ASikfGtFtf9qDmpLQB4louB6HpKNq1MwsQo8zwY93t77HCiV5f0g43rcZfGTn
+wfBhpT7oOVWgfTLeBD811aS52VUCWclmnz+f01GdTeMwqsgc6oJaPSvg4JCMN94O
+wcBlxus69rhM8PeTJNhwLxzRCNnZ69t9k2cU+4lTmQQIB8gnEFJxY9gZdgQ6pej0
+HXUIut+6pp5BRYF2mTZ3fnxhWyIZaeB7lla2gI6rV2GXDbp4kVplGEuQ975YklJw
+i4y7bz2Es4Hkly2Nc/J2L0+uMoBhMWMY3Xl0XDdkZYtBdnSB5g7NacChaAsukEkd
+Ozt6vfXxSzW/KfodB+0ELjlHWiFbI8w7c8Kt7/ceZGVsXTxD/f4tVWy8MmxFy3pY
+Cpe8Kg==
+-----END CERTIFICATE-----

data/lib/magic.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require_relative 'magic/magic'
+require_relative 'magic/version'
+require_relative 'magic/core/file'
+require_relative 'magic/core/string'
+
+#
+# File _Magic_ in Ruby.
+#
+# Simple interface to _libmagic_ for Ruby Programming Language.
+#
+class Magic
+  #
+  # call-seq:
+  #    magic.inspect -> string
+  #
+  # Example:
+  #
+  #    magic = Magic.new
+  #    magic.inspect     #=> "#<Magic:0x007fd5258a1108 @flags=0, @paths=[\"/etc/magic\", \"/usr/share/misc/magic\"]>"
+  #    magic.close
+  #    magic.inspect     #=> "#<Magic:0x007fd5258a1108 @flags=0, @paths=[\"/etc/magic\", \"/usr/share/misc/magic\"] (closed)>"
+  #
+  def inspect
+    super.insert(-2, self.closed? ? ' (closed)' : '')
+  end
+
+  #
+  # call-seq:
+  #    magic.flags_list( boolean ) -> array
+  #
+  # See also: Magic#flags and Magic#flags_names
+  #
+  def flags_list(names = false)
+    raise LibraryError, 'Magic library is not open' if closed?
+    return [names ? 'NONE' : 0] if @flags.zero?
+
+    n, i = 0, @flags
+    flags = []
+
+    @@flags_map ||= flags_as_map if names
+
+    while i > 0
+      n = 2 ** (Math.log(i) / Math.log(2)).to_i
+      i = i - n
+      flags.insert(0, names ? @@flags_map[n] : n)
+    end
+
+    flags
+  end
+
+  alias_method :flags_to_a, :flags_list
+
+  # call-seq:
+  #    magic.flags_names -> array
+  #
+  # See also: Magic#flags and Magic#flags_list
+  #
+  def flags_names
+    flags_list(true)
+  end
+
+  class << self
+    #
+    # call-seq:
+    #    Magic.open( integer )                  -> self
+    #    Magic.open( integer ) {|magic| block } -> string or array
+    #
+    # See also: Magic::mime, Magic::type, Magic::encoding, Magic::compile and Magic::check
+    #
+    def open(flags = Magic::NONE)
+      magic = Magic.new
+      magic.flags = flags
+
+      if block_given?
+        begin
+          yield magic
+        ensure
+          magic.close
+        end
+      else
+        magic
+      end
+    end
+
+    #
+    # call-seq:
+    #    Magic.mime                  -> self
+    #    Magic.mime {|magic| block } -> string or array
+    #
+    # See also: Magic::open, Magic::type, Magic::encoding, Magic::compile and Magic::check
+    #
+    def mime(&block)
+      open(Magic::MIME, &block)
+    end
+
+    #
+    # call-seq:
+    #    Magic.type                  -> self
+    #    Magic.type {|magic| block } -> string or array
+    #
+    # See also: Magic::open, Magic::mime, Magic::encoding, Magic::compile and Magic::check
+    #
+    def type(&block)
+      open(Magic::MIME_TYPE, &block)
+    end
+
+    #
+    # call-seq:
+    #    Magic.encoding                  -> self
+    #    Magic.encoding {|magic| block } -> string or array
+    #
+    # See also: Magic::open, Magic::mime, Magic::type, Magic::compile and Magic::check
+    #
+    def encoding(&block)
+      open(Magic::MIME_ENCODING, &block)
+    end
+
+    #
+    # call-seq:
+    #    Magic.compile( string, ... ) -> true
+    #    Magic.compile( array )       -> true
+    #
+    # See also: Magic::open, Magic::mime, Magic::type, Magic::encoding, and Magic::check
+    #
+    def compile(*paths)
+      open {|m| m.compile(paths) }
+    end
+
+    #
+    # call-seq:
+    #    Magic.check( string, ... ) -> true or false
+    #    Magic.check( array )       -> true or false
+    #
+    # See also: Magic::open, Magic::mime, Magic::type, Magic::encoding and Magic::compile
+    #
+    def check(*paths)
+      open {|m| m.check(paths) }
+    end
+
+    #
+    # call-seq:
+    #    Magic.file( object )          -> string or array
+    #    Magic.file( string )          -> string or array
+    #    Magic.file( string, integer ) -> string or array
+    #
+    # See also:
+    #
+    def file(path, flags = Magic::MIME)
+      open(flags).file(path)
+    end
+
+    #
+    # call-seq:
+    #    Magic.buffer( string )          -> string or array
+    #    Magic.buffer( string, integer ) -> string or array
+    #
+    # See also:
+    #
+    def buffer(buffer, flags = Magic::MIME)
+      open(flags).buffer(buffer)
+    end
+
+    #
+    # call-seq:
+    #    Magic.descriptor( object )           -> string or array
+    #    Magic.descriptor( integer )          -> string or array
+    #    Magic.descriptor( integer, integer ) -> string or array
+    #
+    # See also:
+    #
+    def descriptor(fd, flags = Magic::MIME)
+      open(flags).descriptor(fd)
+    end
+
+    alias_method :fd, :descriptor
+  end
+
+  private
+
+  def power_of_two?(number)
+    number > 0 && Math.log2(number) % 1 == 0
+  end
+
+  def flags_as_map
+    klass = self.class
+
+    klass.constants.each_with_object({}) do |constant, flags|
+      constant = constant.to_s
+
+      next if constant.start_with?('PARAM_')
+
+      value = klass.const_get(constant)
+
+      if value.is_a?(Integer) && power_of_two?(value)
+        flags[value] = constant
+      end
+    end
+  end
+end
+
+FileMagic = Magic