magikku 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Eric Monti
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,18 @@
+= ruby-magic
+
+Ruby bindings for libmagic(3)
+
+Includes FFI bindings as well as native ruby bindings (the latter is coming soon)..
+
+== Synopsis
+
+(coming soon)
+
+== Installation
+
+  (sudo)? gem install ruby-magic
+
+
+== Copyright
+
+Copyright (c) 2011 Eric Monti. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "magikku"
+    gem.summary = "Ruby bindings for the libmagic(3) library"
+    gem.description = "Ruby bindings to the libmagic(3) library for identifying unknown files and data contents"
+    gem.email = "esmonti@gmail.com"
+    gem.homepage = "http://github.com/emonti/magikku"
+    gem.authors = ["Eric Monti"]
+    gem.add_development_dependency "ffi", ">= 0.5.0"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new("magikku_native")
+
+CLEAN.include("doc")
+CLEAN.include("rdoc")
+CLEAN.include("coverage")
+CLEAN.include("tmp")
+CLEAN.include("lib/*.bundle")
+CLEAN.include("lib/*.so")
+
+task :spec => [:check_dependencies, :compile]
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "magikku #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('ext/**/*.c')
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/ext/magikku_native/extconf.rb

@@ -0,0 +1,32 @@
+#  yara-ruby - Ruby bindings for the yara malware analysis library.
+#  Eric Monti
+#  Copyright (C) 2011 Trustwave Holdings
+#  
+#  This program is free software: you can redistribute it and/or modify it 
+#  under the terms of the GNU General Public License as published by the 
+#  Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#  
+#  This program is distributed in the hope that it will be useful, but 
+#  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+#  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+#  for more details.
+#  
+#  You should have received a copy of the GNU General Public License along
+#  with this program. If not, see <http://www.gnu.org/licenses/>.
+#  
+
+require 'mkmf'
+require 'rbconfig'
+
+extension_name = "magikku_native"
+
+dir_config(extension_name)
+
+unless have_library("magic") and
+       find_header("magic.h", "/usr/local/include")
+  raise "You must install the libmagic library"
+end
+
+create_makefile(extension_name)
+

data/ext/magikku_native/magikku_native.c

@@ -0,0 +1,412 @@
+#include "ruby.h"
+#include <magic.h>
+#include <sys/stat.h>
+#include <string.h>
+
+VALUE c_magic = Qnil;
+VALUE m_flags = Qnil;
+
+VALUE e_MagikkuError = Qnil;
+VALUE e_InitFatal = Qnil;
+VALUE e_DbLoadError = Qnil;
+VALUE e_CompileError = Qnil;
+VALUE e_FlagError = Qnil;
+VALUE e_ClosedError = Qnil;
+
+
+
+
+/* Internal function to check whether a handle is already closed */
+magic_t 
+_check_closed(VALUE self) {
+  magic_t ret = NULL;
+  if (rb_iv_get(self, "@closed") != Qtrue) 
+    Data_Get_Struct(self, void, ret);
+  return (magic_t) ret;
+}
+
+/* internal MACRO to check for the existence of a file */
+#define _confirm_file_exists(_filename) \
+{ struct stat st;\
+  if(stat(_filename, &st) < 0) rb_sys_fail(_filename); }
+
+#define CLOSED_ERR_MSG "This magic cookie is closed and can no longer be used"
+
+/* call-seq: Magikku.path() -> "default_magic_db"
+ *
+ * @return String Returns the default magic database path.
+ */
+VALUE 
+rb_magic_s_path(VALUE klass) {
+  return rb_str_new2(magic_getpath(NULL, 0));
+}
+
+/* call-seq: Magikku.new(params={})
+ *
+ * Instantiates a new Magikku cookie which we can use to load magic databases,
+ * compile new databases, and identify files and string buffers.
+ *
+ * @param Hash params
+ *      A hash of optional parameters to pass to the initializer.
+ *
+ * @option params String :db
+ *      One or more magic databases to load on initialization. If nothing
+ *      is specified, the default database will be used.
+ *
+ * @option params Fixnum :flags
+ *      Initialization flags to configure libmagic. 
+ *
+ * @see Magikku::Flags and libmagic(3)
+ *
+ * @raise Magikku::DbLoadError
+ *      An error is raised if the database cannot be loaded.
+ *
+ * @raise Magikku::InitFatal
+ *      An error is raised if an unknown error is encountered initializing
+ *      the cookie with libmagic.
+ */
+VALUE 
+rb_magic_initialize(int argc, VALUE *argv, VALUE klass) {
+  VALUE params = Qnil;
+  VALUE flags_val, db_val;
+  magic_t cookie; 
+  int flags = 0;
+  char *magicf = NULL;
+  const char *error=NULL;
+
+  rb_scan_args(argc, argv, "01", &params);
+
+  if (params != Qnil) {
+    Check_Type(params, T_HASH);
+
+    flags_val=rb_hash_aref(params, ID2SYM(rb_intern("flags")));
+    if (flags_val != Qnil) {
+      Check_Type(flags_val, T_FIXNUM);
+      flags = NUM2INT(flags_val);
+    }
+
+    db_val=rb_hash_aref(params, ID2SYM(rb_intern("db")));
+    if (db_val != Qnil) {
+      Check_Type(db_val, T_STRING);
+      magicf = RSTRING_PTR(db_val);
+    }
+  }
+
+  if ((cookie=magic_open(flags))==NULL)
+    rb_raise(e_InitFatal, "magic_open(%i) returned a null pointer", flags);
+
+  if (magic_load(cookie, magicf) != 0) {
+    error = magic_error(cookie);
+    magic_close(cookie);
+    rb_raise(e_DbLoadError, "Error loading db \"%s\": %s", magicf, error);
+  }
+
+  return Data_Wrap_Struct(klass, NULL, NULL, cookie);
+}
+
+
+/* call-seq: dbload(magicfiles) -> true
+ *
+ * Used to load one or more magic databases.
+ * 
+ * @param String magicfiles
+ *   One or more filenames seperated by colons. If nil, the default database
+ *   is loaded.
+ *   If uncompiled magic files are specified, they are compiled on the fly
+ *   but they do not generate new .mgc files as with the compile method.
+ *   Multiple files be specified by seperating them with colons.
+ *
+ * @raise DbLoadError if an error occurred loading the database(s)
+ *
+ * @raise Magikku::CloseError 
+ *      Raises an error if the Magikku object has been closed.
+ */
+VALUE 
+rb_magic_dbload(VALUE self, VALUE magicf_val) {
+  magic_t cookie = _check_closed(self);
+  char *magicf = NULL;
+
+  if(!cookie)             rb_raise(e_ClosedError, CLOSED_ERR_MSG);
+  if(magicf_val != Qnil){
+    Check_Type(magicf_val, T_STRING);
+    magicf = RSTRING_PTR(magicf_val);
+  }
+
+  Data_Get_Struct(self, void, cookie);
+
+  if (magic_load(cookie, magicf) != 0)
+    rb_raise(e_DbLoadError, "Error loading db \"%s\": %s", magicf, magic_error(cookie));
+
+  return Qtrue;
+}
+
+/* call-seq: close() -> nil
+ *
+ * Close the libmagic data scanner handle when you are finished with it
+ *
+ * Note that magic handles are never closed automatically, even when
+ * garbage collection occurs.
+ */
+VALUE 
+rb_magic_close(VALUE self) {
+  magic_t cookie = _check_closed(self);
+
+  if(cookie) magic_close(cookie);
+  rb_iv_set(self, "@closed", Qtrue);
+
+  return Qnil;
+}
+
+/* call-seq: closed? -> true|false
+ *
+ * Indicates whether the magic cookie has been closed
+ *
+ * @return true,false
+ */
+VALUE 
+rb_magic_is_closed(VALUE self) {
+  VALUE ret = rb_iv_get(self, "@closed");
+  if (ret == Qnil) ret = Qfalse;
+  return ret;
+}
+
+/* call-seq: file(filename) -> String
+ *
+ * Identifies file contents using the magicfile database.
+ *
+ * @param String filename
+ *      The path to the file to analyze
+ *
+ * @return String
+ *      A textual description of the contents of the file
+ *
+ * @raise Magikku::CloseError 
+ *      Raises an error if the Magikku object has been closed.
+ */
+VALUE 
+rb_magic_file(VALUE self, VALUE filename) {
+  magic_t cookie = _check_closed(self);
+  if (cookie) {
+    char * fname;
+    struct stat st;
+
+    Check_Type(filename, T_STRING);
+    fname = RSTRING_PTR(filename);
+
+    if(stat(fname, &st) < 0) 
+      rb_sys_fail(fname);
+
+    return rb_str_new2(magic_file(cookie, fname));
+
+  } else {
+    rb_raise(e_ClosedError, CLOSED_ERR_MSG);
+  }
+      
+}
+
+/* call-seq: string(buf) -> String
+ *
+ * Identifies string contents using the magicfile database.
+ *
+ * @param String buf
+ *      The string to analyze.
+ *
+ * @return String
+ *      A textual description of the contents of the string
+ *
+ * @raise Magikku::CloseError 
+ *      Raises an error if the Magikku object has been closed.
+ */
+VALUE rb_magic_string(VALUE self, VALUE string) {
+  const char *ret;
+  magic_t cookie = _check_closed(self);
+  if (!cookie)          rb_raise(e_ClosedError, CLOSED_ERR_MSG);
+  Check_Type(string, T_STRING);
+
+  ret=magic_buffer(cookie, RSTRING_PTR(string), RSTRING_LEN(string));
+  return rb_str_new2(ret);
+}
+
+/* call-seq: compile(filename=nil)
+ *
+ * Can be used to compile magic files. This does not load files, however. You must
+ * use dbload for that.
+ *
+ * Note: Errors and warnings may be displayed on stderr.
+ *
+ * @param String,nil filename
+ *   A colon seperated list of filenames or a single filename. 
+ *   The compiled files created are generated in the current directory using 
+ *   the basename(1) of each file argument with ".mgc" appended to it.
+ *   Directory names can be compiled, in which case the contents of the 
+ *   directory will be compiled together as a single .mgc file.
+ *   nil compiles the default database.
+ *
+ * @return true if everything went well.
+ *
+ * @raise CompileError if an error occurred.
+ */
+VALUE rb_magic_compile(VALUE self, VALUE magicf) {
+  char *_magicf;
+  magic_t cookie = _check_closed(self);
+
+  if (!cookie)          rb_raise(e_ClosedError, CLOSED_ERR_MSG);
+  if (magicf != Qnil)   Check_Type(magicf, T_STRING);
+
+  _magicf = RSTRING_PTR(magicf);
+
+  if (magic_compile(cookie, _magicf) == 0) return Qtrue;
+  else rb_raise(e_CompileError, 
+        "Error compiling \"%s\": %s", _magicf, magic_error(cookie));
+}
+
+/* call-seq: magic.check_syntax("some_magic_db") -> (true|false)
+ *
+ * Can be used to check the validity of magic files before compiling them.
+ * This is basically a dry-run that can be used before compiling magicfile 
+ * databases.
+ *
+ * Note: Errors and warnings may be displayed on stderr.
+ *
+ * @param String,nil filename
+ *   A colon seperated list of filenames or a single file. nil checks the
+ *   default database.
+ *
+ * @return true,false Indicates whether the check was successful.
+*/
+VALUE rb_magic_check_syntax(VALUE self, VALUE rb_magicf) {
+  magic_t cookie = _check_closed(self);
+  char * magicf = NULL;
+
+  if (!cookie) rb_raise(e_ClosedError, CLOSED_ERR_MSG);
+  if (rb_magicf != Qnil) {
+    Check_Type(rb_magicf, T_STRING);
+    magicf = RSTRING_PTR(rb_magicf);
+  }
+
+  if (magic_check(cookie, magicf) == 0) return Qtrue;
+  else return Qfalse;
+}
+
+/* call-seq: magic.flags = (Magikku::Flags::MIME | Magikku::Flags::DEBUG)
+ *
+ * Sets libmagic flags on the object. See Magikku::Flags
+ *
+ * @raise Magikku::CloseError 
+ *      Raises an error if the Magikku object has been closed.
+ */
+VALUE rb_magic_set_flags(VALUE self, VALUE flags) {
+  magic_t cookie = _check_closed(self);
+
+  Check_Type(flags, T_FIXNUM);
+  
+  if(magic_setflags(cookie, NUM2INT(flags)) < 0)
+    rb_raise(e_FlagError, magic_error(cookie));
+
+  return flags;
+}
+
+void Init_magikku_native() {
+/* The Magikku class is both our interface to libmagic functionality
+   as well as the top-level namespace */
+  c_magic = rb_define_class("Magikku", rb_cObject);
+  rb_define_singleton_method(c_magic, "path", rb_magic_s_path, 0);
+//  rb_define_singleton_method(c_magic, "compile", rb_magic_s_compile, 1);
+//  rb_define_singleton_method(c_magic, "check_syntax", rb_magic_s_check_syntax, 1);
+
+  rb_define_singleton_method(c_magic, "new", rb_magic_initialize, -1);
+
+  rb_define_method(c_magic, "close", rb_magic_close, 0);
+  rb_define_method(c_magic, "closed?", rb_magic_is_closed, 0);
+  rb_define_method(c_magic, "compile", rb_magic_compile, 1);
+  rb_define_method(c_magic, "check_syntax", rb_magic_check_syntax, 1);
+  rb_define_method(c_magic, "file", rb_magic_file, 1);
+  rb_define_method(c_magic, "string", rb_magic_string, 1);
+  rb_define_method(c_magic, "flags=", rb_magic_set_flags, 1);
+  rb_define_method(c_magic, "dbload", rb_magic_dbload, 1);
+
+/* Defines various flags that can be passed when creating a magic scanning
+ * object using Magikku.new with the :flags parameter or after instantiation
+ * using Magikku.flags= .
+ *
+ * Available flags are as follows:
+ *
+ *    NONE                  No flags
+ *    DEBUG                 Turn on debugging
+ *    SYMLINK               Follow symlinks
+ *    COMPRESS              Check inside compressed files
+ *    DEVICES               Look at the contents of devices
+ *    MIME_TYPE             Return the MIME type
+ *    CONTINUE              Return all matches
+ *    CHECK                 Print warnings to stderr
+ *    PRESERVE_ATIME        Restore access time on exit
+ *    RAW                   Don't translate unprintable chars
+ *    ERROR                 Handle ENOENT etc as real errors
+ *    MIME_ENCODING         Return the MIME encoding
+ *    MIME                  Alias for (MIME_TYPE|MIME_ENCODING)
+ *    APPLE                 Return the Apple creator and type
+ *    NO_CHECK_COMPRESS     Don't check for compressed files
+ *    NO_CHECK_TAR          Don't check for tar files
+ *    NO_CHECK_SOFT         Don't check magic entries
+ *    NO_CHECK_APPTYPE      Don't check application type
+ *    NO_CHECK_ELF          Don't check for elf details
+ *    NO_CHECK_TEXT         Don't check for text files
+ *    NO_CHECK_CDF          Don't check for cdf files
+ *    NO_CHECK_TOKENS       Don't check tokens
+ *    NO_CHECK_ENCODING     Don't check text encodings
+ *    NO_CHECK_ASCII        Alias for NO_CHECK_TEXT
+ *
+ * @see libmagic(3)
+ *
+ */
+  m_flags = rb_define_module_under(c_magic, "Flags");
+  rb_define_const(m_flags, "NONE", INT2FIX(MAGIC_NONE));
+  rb_define_const(m_flags, "DEBUG", INT2FIX(MAGIC_DEBUG));
+  rb_define_const(m_flags, "SYMLINK", INT2FIX(MAGIC_SYMLINK));
+  rb_define_const(m_flags, "COMPRESS", INT2FIX(MAGIC_COMPRESS));
+  rb_define_const(m_flags, "DEVICES", INT2FIX(MAGIC_DEVICES));
+  rb_define_const(m_flags, "MIME_TYPE", INT2FIX(MAGIC_MIME_TYPE));
+  rb_define_const(m_flags, "CONTINUE", INT2FIX(MAGIC_CONTINUE));
+  rb_define_const(m_flags, "CHECK", INT2FIX(MAGIC_CHECK));
+  rb_define_const(m_flags, "PRESERVE_ATIME", INT2FIX(MAGIC_PRESERVE_ATIME));
+  rb_define_const(m_flags, "RAW", INT2FIX(MAGIC_RAW));
+  rb_define_const(m_flags, "ERROR", INT2FIX(MAGIC_ERROR));
+  rb_define_const(m_flags, "MIME_ENCODING", INT2FIX(MAGIC_MIME_ENCODING));
+  rb_define_const(m_flags, "MIME", INT2FIX(MAGIC_MIME));
+  rb_define_const(m_flags, "APPLE", INT2FIX(MAGIC_APPLE));
+  rb_define_const(m_flags, "NO_CHECK_COMPRESS", INT2FIX(MAGIC_NO_CHECK_COMPRESS));
+  rb_define_const(m_flags, "NO_CHECK_TAR", INT2FIX(MAGIC_NO_CHECK_TAR));
+  rb_define_const(m_flags, "NO_CHECK_SOFT", INT2FIX(MAGIC_NO_CHECK_SOFT));
+  rb_define_const(m_flags, "NO_CHECK_APPTYPE", INT2FIX(MAGIC_NO_CHECK_APPTYPE));
+  rb_define_const(m_flags, "NO_CHECK_ELF", INT2FIX(MAGIC_NO_CHECK_ELF));
+  rb_define_const(m_flags, "NO_CHECK_TEXT", INT2FIX(MAGIC_NO_CHECK_TEXT));
+  rb_define_const(m_flags, "NO_CHECK_CDF", INT2FIX(MAGIC_NO_CHECK_CDF));
+  rb_define_const(m_flags, "NO_CHECK_TOKENS", INT2FIX(MAGIC_NO_CHECK_TOKENS));
+  rb_define_const(m_flags, "NO_CHECK_ENCODING", INT2FIX(MAGIC_NO_CHECK_ENCODING));
+  rb_define_const(m_flags, "NO_CHECK_ASCII", INT2FIX(MAGIC_NO_CHECK_ASCII));
+
+  /* define our exception classes... */
+
+/* A base class for other Magikku error types */
+  e_MagikkuError = rb_define_class_under(c_magic, "MagikkuError", rb_eStandardError);
+
+/* InitFatal is raised for unexpected errors initializing Magikku */
+  e_InitFatal = rb_define_class_under(c_magic, "InitFatal", e_MagikkuError);
+
+/* DbLoadError is raised when an error occurs loading a magic database */
+  e_DbLoadError = rb_define_class_under(c_magic, "DbLoadError", e_MagikkuError);
+
+/* CompileError is raised when an error occurs compiling a magic database */
+  e_CompileError = rb_define_class_under(c_magic, "CompileError", e_MagikkuError);
+
+/* FlagError is raised when an error occurs compiling setting flags
+ *
+ * This is only known to happen on systems that don't support utime(2), or
+ * utimes(2) when Magikku::Flag::PRESERVE_ATIME is set
+ */
+  e_FlagError = rb_define_class_under(c_magic, "FlagError", e_MagikkuError);
+
+/* ClosedError is raised if an operation is called on a closed Magikku object */
+  e_ClosedError = rb_define_class_under(c_magic, "ClosedError", e_MagikkuError);
+
+}

data/lib/ffi/libmagic.rb

@@ -0,0 +1,46 @@
+require 'ffi'
+
+module FFI
+  module Libmagic
+    extend FFI::Library
+    ffi_lib 'magic'
+
+    typedef :pointer, :magic_t
+
+    # magic_t magic_open(int flags);
+    attach_function :magic_open, [:int], :magic_t
+
+    # void magic_close(magic_t cookie);
+    attach_function :magic_close, [:magic_t], :void
+
+    #  const char * magic_error(magic_t cookie);
+    attach_function :magic_error, [:magic_t], :string
+
+    #  int magic_errno(magic_t cookie);
+    attach_function :magic_errno, [:magic_t], :int
+
+    #  const char * magic_file(magic_t cookie, const char *filename);
+    attach_function :magic_file, [:magic_t, :string], :string
+
+    #  const char * magic_buffer(magic_t cookie, const void *buffer, size_t length);
+    attach_function :magic_buffer, [:magic_t, :pointer, :size_t], :string
+
+    #  int magic_setflags(magic_t cookie, int flags);
+    attach_function :magic_setflags, [:magic_t, :int], :int
+
+    #  int magic_check(magic_t cookie, const char *filename);
+    attach_function :magic_check, [:magic_t, :string], :int
+
+    #  int magic_compile(magic_t cookie, const char *filename);
+    attach_function :magic_compile, [:magic_t, :string], :int
+
+    #  int magic_load(magic_t cookie, const char *filename);
+    attach_function :magic_load, [:magic_t, :string], :int
+
+    # NOTE magic_getpath not doc'd in libmagic(3), 
+    #      not available in earlier versions?
+    #
+    # const char * int magic_getpath(const char *magicfile, int action)
+    attach_function :magic_getpath, [:string, :int], :string
+  end
+end

data/lib/magikku/convenience.rb

@@ -0,0 +1,82 @@
+
+module MagikkuHelpers
+  # A convenience method for checking syntax of magicdb files.
+  #
+  # Note: syntax errors and warnings may be displayed on stderr.
+  #
+  # @param String fname
+  #   Filename or directory to compile
+  #
+  # @param Hash params
+  #   A hash of parameters to Magikku.new()
+  #
+  # @return true,false
+  def check_syntax(fname, params={})
+    m=new(params)
+    begin
+      return m.check_syntax(fname)
+    ensure
+      m.close()
+    end
+  end
+
+  # A convenience method for compiling magicdb files.
+  #
+  # @param String fname
+  #   Filename or directory to compile
+  #
+  # @param Hash params
+  #   A hash of parameters to Magikku.new()
+  #
+  # @return true
+  #
+  # @raise Magikku::CompileError if an error occurs
+  def compile(fname, params={})
+    m=new(params)
+    begin
+      return m.compile(fname)
+    ensure
+      m.close()
+    end
+  end
+
+  # A convenience method for identifying file contents
+  #
+  # @param String fname
+  #   Filename to identify
+  #
+  # @param Hash params
+  #   A hash of parameters to Magikku.new()
+  #
+  # @return String
+  #   Identification of the file contents.
+  def file(fname, params={})
+    m=new(params)
+    begin
+      return m.file(fname)
+    ensure
+      m.close()
+    end
+  end
+
+  # A convenience method for identifying string contents
+  #
+  # @param String buf
+  #   String contents to identify
+  #
+  # @param Hash params
+  #   A hash of parameters to Magikku.new()
+  #
+  # @return String
+  #   Identification of the string.
+  def string(buf, params={})
+    m=new(params)
+    begin
+      return m.string(buf)
+    ensure
+      m.close()
+    end
+  end
+end
+
+

data/lib/magikku.rb

@@ -0,0 +1,12 @@
+
+require 'magikku/convenience'
+
+#begin
+  require 'magikku_native'
+  Magikku.class_eval{ extend(MagikkuHelpers) }
+#rescue LoadError
+#  require 'magikku_ffi'
+#  Magikku = MagikkuFFI
+#end
+
+