libmagic_rb 0.1.0.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba9f8adbdc49d3228f29e2678aef99bdd015a2134a57f9dbeb630b2e81118797
+  data.tar.gz: b13bab746fa7c6daf2baa5dd7e17531a17588c27c9accf6229e92de7d412d4b4
+SHA512:
+  metadata.gz: 6ac39fbc412c0d45774b78d6d2ef0a44f7b9632b6dc58b4afa140e04868a8abd0caa279cd53c73d9648a4256b2e95ca656d4cd24fa96e3d127e1ee58ec300bb2
+  data.tar.gz: 48e98649e0e24ea017f0234e5771ddf63303316815c2ee59eec9aef6ee659ca563766ee9ca708a2fa9d483b4f09051a321744bae7ebec3ddc9e58c43fdc3f299

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Cybergizer
+
+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.md

@@ -0,0 +1,188 @@
+# LibmagicRb
+Adds ability to check mime-type of a file using the libmagic ([magic(4)](https://man7.org/linux/man-pages/man4/magic.4.html)).
+It uses native extensions and it's quite performant.
+
+## Pre-Installation
+On Linux, you need to install libmagic.
+
+##### Arch
+
+```
+# pacman -S file gcc make
+```
+
+#### Debian / Ubuntu / Linux Mint / Kali / ParrotOS / RaspberryPi OS
+
+```
+# apt install libmagic-dev ruby-dev gcc make
+```
+
+#### Fedora
+
+```
+# yum install file-devel ruby-devel gcc make
+```
+
+#### OpenSUSE
+
+```
+zypper in ruby ruby-devel file-devel gcc make
+```
+
+Mac is currently not supported but may support in the future.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'libmagic_rb'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install libmagic_rb
+```
+
+## Usage
+The target of this gem is to add mime-type checking easily.
+
+Using the LibmagicRb class we can check the mime type, EXIF data and other information of a file.
+
+To check a file, you need to pass a hash argument to the FilemagicRb.new():
+
+1. db: Path to the Database (String)
+2. file: A file to check (String)
+3. mode: Modes of the file (Integer) (Optional, defaults to `LibmagicRb::MAGIC_MIME | LibmagicRb::MAGIC_CHECK | LibmagicRb::MAGIC_SYMLINK`)
+
+### Example 1:
+
+```
+require 'libmagic_rb'
+
+cookie = LibmagicRb.new(
+    file: '/usr/share/backgrounds/myimage.webp',
+    mode: LibmagicRb::MAGIC_MIME | LibmagicRb::MAGIC_CHECK | LibmagicRb::MAGIC_SYMLINK
+)
+
+p cookie # =>    #<LibmagicRb:0x000055cf96d8f868 @db="/home/sourav/.gem/ruby/3.0.0/gems/libmagic_rb-0.1.0/data/magic.mgc", @file="/usr/share/backgrounds/myimage.webp", @mode=1106, @closed=false>
+
+# In case The file path needs to be changed
+cookie.file = '/usr/share/backgrounds/vienna-5164602.jpg'
+
+p cookie.file    # => "/usr/share/backgrounds/vienna-5164602.jpg"
+p cookie.db    # => nil
+
+cookie.check()    # => image/jpeg; charset=binary
+cookie.close()    # => #<LibmagicRb:0x000055fa77699818 @closed=true, @db="/home/sourav/.gem/ruby/3.0.0/gems/libmagic_rb-0.1.0/data/magic.mgc", @file="/usr/share/backgrounds/vienna-5164602.jpg", @mode=1106>
+cookie.closed?() # => true
+```
+
+When the `db:` key is `nil`, it will use NULL as the database file - which gets the database automatically from the system.
+You can omit `db: nil` as well for a nil value.
+
+### Example 2:
+```
+require 'libmagic_rb'
+
+cookie = LibmagicRb.new(
+    db: '/usr/share/file/magic.mgc',
+    file: '/usr/share/backgrounds/vienna-5164602.jpg',
+    mode: LibmagicRb::NONE
+)
+
+cookie.check()    # => "JPEG image data, JFIF standard 1.01, resolution (DPI), density 300x300, segment length 16, Exif Standard: [TIFF image data, big-endian, direntries=4, manufacturer=NIKON CORPORATION, model=NIKON D5300], baseline, precision 8, 5959x3973, components 3""
+cookie.close()    # => #<LibmagicRb:0x000055fa77699818 @closed=true, @db="/home/sourav/.gem/ruby/3.0.0/gems/libmagic_rb-0.1.0/data/magic.mgc", @file="/usr/share/backgrounds/vienna-5164602.jpg", @mode=1106>
+cookie.closed?() # => true
+```
+Surely, you can automatically get db path if you pass nil to it.  But If you happen to remove the database file or you are unsure, `db: nil` will not work (so will linux's file command).
+Specifying the path gives you the privilege to pass a locally stored database.
+
+Do note that there should be version match for the magic files, otherwise it will raise `LibmagicRb::InvalidDBError`.
+
+### Example 3:
+LibmagicRb also provides a handy singleton method `:check`. You just need to pass the filename and modes:
+
+```
+require 'libmagic_rb'
+
+LibmagicRb.check(file: '/dev/zero', mode: LibmagicRb::MAGIC_NONE)    #=> "character special (1/5)"
+LibmagicRb.check(file: '/', mode: LibmagicRb::MAGIC_NONE)    # => "directory"
+LibmagicRb.check(file: '/')    # => "inode/directory; charset=binary"
+```
+
+Optional:
++ You can use the db: keyword for a custom path. By default it's set to nil. And as mentioned above, nil = automatically find the db from the system.
++ The `mode:` key is optional, by default it's set to `LibmagicRb::MAGIC_MIME | LibmagicRb::MAGIC_CHECK | LibmagicRb::MAGIC_SYMLINK`.
+
+Notes:
++ It's really **mandatory** to close the cookie (`cookie.close()`) when you are done with the cookie. Otherwise, you rely on the GC and that can cause various problems.
+  You can't also use the file after it's closed.
++ You can change the file and db on the fly. But you can't change the mode. The mode can be assigned only with LibmagicRb.new(db: ..., file: ..., mode: ...)
++ To list all the modes, please refer to the [man page](https://man7.org/linux/man-pages/man3/magic_getflags.3.html).
+
+### Open Modes
+Files can be opened in various modes. You can use this short hand to see the supported modes:
+
+```
+LibmagicRb.lsmodes    # => {:MAGIC_NONE=>0, :MAGIC_DEBUG=>1, :MAGIC_SYMLINK=>2, :MAGIC_COMPRESS=>4, :MAGIC_DEVICES=>8, :MAGIC_MIME_TYPE=>16, :MAGIC_MIME_ENCODING=>1024, :MAGIC_MIME=>1040, :MAGIC_CONTINUE=>32, :MAGIC_CHECK=>64, :MAGIC_PRESERVE_ATIME=>128, :MAGIC_RAW=>256, :MAGIC_ERROR=>512, :MAGIC_APPLE=>2048, :MAGIC_EXTENSION=>16777216, :MAGIC_COMPRESS_TRANSP=>33554432, :MAGIC_NO_CHECK_APPTYPE=>32768, :MAGIC_NO_CHECK_CDF=>262144, :MAGIC_NO_CHECK_COMPRESS=>4096, :MAGIC_NO_CHECK_ELF=>65536, :MAGIC_NO_CHECK_ENCODING=>2097152, :MAGIC_NO_CHECK_SOFT=>16384, :MAGIC_NO_CHECK_TAR=>8192, :MAGIC_NO_CHECK_TEXT=>131072, :MAGIC_NO_CHECK_TOKENS=>1048576, :MAGIC_NO_CHECK_CSV=>524288, :MAGIC_NO_CHECK_JSON=>4194304}
+```
+
+Note:
++ Some keys can be missing or can have modified values, depending on your libmagic version.
+
+### Parameters
+
+#### Listing parameters
+
+```
+LibmagicRb.lsparams    # => {:MAGIC_PARAM_INDIR_MAX=>0, :MAGIC_PARAM_NAME_MAX=>1, :MAGIC_PARAM_ELF_NOTES_MAX=>4, :MAGIC_PARAM_ELF_PHNUM_MAX=>2, :MAGIC_PARAM_ELF_SHNUM_MAX=>3, :MAGIC_PARAM_REGEX_MAX=>5, :MAGIC_PARAM_BYTES_MAX=>6}
+```
+
+Note:
++ Some keys can be missing or can have modified values, depending on your libmagic version.
+
+#### Getting parameters
+
+```
+cookie.getparam(LibmagicRb::MAGIC_PARAM_REGEX_MAX) # => 8192; but can differ. Returns nil on error.
+```
+
+#### Setting parameters
+```
+cookie.setparam(LibmagicRb::MAGIC_PARAM_REGEX_MAX, 2 ** 14) # => 16384; but can differ. Returns nil on error.
+```
+
+#### Notes:
+
++ To get the parameters, you can refer to the [man page](https://man7.org/linux/man-pages/man3/magic_getflags.3.html).
++ Cookie setparam returns the value after getting the param as well. So you don't need to confirm by calling getparam() again.
++ The maximum size depends on the parameter. But the value that can be passed should not be more than 2 ** 32.
+
+## Errors
+The following errors are implemented and raised on appropriate situation:
+
+1. LibmagicRb::FileNotFound: When the file is not found.
+2. LibmagicRb::FileUnreadable: When the file is unreadable.
+3. LibmagicRb::InvalidDBError: When the database given is invalid.
+4. LibmagicRb::IsDirError: When the database path is a directory.
+5. LibmagicRb::FileClosedError: When the file is already closed (closed?()) but you are trying to access the cookie.
+
+## Development
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/cybergizer-hq/LibmagicRb](https://github.com/cybergizer-hq/LibmagicRb) This project is intended to be a safe, welcoming space for collaboration.
+
+## License
+
+The gem is available as open-source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+begin
+	require "libmagic_rb"
+rescue LoadError
+	abort <<~EOF
+		Can't load `libmagic_rb'.
+		Please make sure to install this gem before loading this into irb!
+	EOF
+end
+
+require "irb"
+puts ":: Loaded LibmagicRb Version: #{LibmagicRb::VERSION}"
+
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/libmagic/definitions.h

@@ -0,0 +1,4 @@
+#define RB_UNWRAP(cookie) \
+	magic_t *cookie ; \
+	TypedData_Get_Struct(self, magic_t, &fileType, cookie) ; \
+	if(!*cookie) rb_raise(rb_eFileClosedError, "Magic cookie already closed") ;

data/ext/libmagic/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+$LDFLAGS << ' -lmagic'
+$CFLAGS << ' -Os'
+
+abort "\e[1;31m*** Can't find magic.h ***\e[0m" unless have_header('magic.h')
+abort "\e[1;31m*** Can't find magic_open() in magic.h ***\e[0m" unless have_library('magic', 'magic_open')
+
+create_makefile 'libmagic_rb/main'

data/ext/libmagic/func.h

@@ -0,0 +1,111 @@
+VALUE _closeGlobal_(volatile VALUE self) {
+	RB_UNWRAP(cookie) ;
+
+	magic_close(*cookie) ;
+	*cookie = NULL ;
+	rb_ivar_set(self, rb_intern("@closed"), Qtrue) ;
+	return self ;
+}
+
+VALUE _loadGlobal_(volatile VALUE self, volatile VALUE dbPath) {
+	char *databasePath = NULL ;
+
+	if (RB_TYPE_P(dbPath, T_STRING)) {
+		databasePath = StringValuePtr(dbPath) ;
+		rb_iv_set(self, "@db", dbPath) ;
+	} else if(RB_TYPE_P(dbPath, T_STRING)) {
+		rb_iv_set(self, "@db", Qnil) ;
+	}
+
+	// Check if the database is a valid file or not
+	// Raises ruby error which will return.
+	RB_UNWRAP(cookie) ;
+
+	if(databasePath) magic_validate_db(*cookie, databasePath) ;
+	magic_load(*cookie, databasePath) ;
+
+	return self ;
+}
+
+VALUE _checkGlobal_(volatile VALUE self) {
+	RB_UNWRAP(cookie) ;
+
+	// Database path
+	VALUE db = rb_iv_get(self, "@db") ;
+
+	char *database = NULL ;
+	if(RB_TYPE_P(db, T_STRING)) {
+		database = StringValuePtr(db) ;
+	}
+
+	// File path
+	VALUE f = rb_iv_get(self, "@file") ;
+	char *file = StringValuePtr(f) ;
+
+	if(database) magic_validate_db(*cookie, database) ;
+	magic_load(*cookie, database) ;
+
+	fileReadable(file) ;
+	const char *mt = magic_file(*cookie, file) ;
+
+	return mt ? rb_str_new_cstr(mt) : Qnil ;
+}
+
+VALUE _getParamGlobal_(volatile VALUE self, volatile VALUE param) {
+	RB_UNWRAP(cookie) ;
+
+	unsigned int _param = NUM2UINT(param) ;
+	unsigned long value ;
+
+	int status = magic_getparam(*cookie, _param, &value) ;
+	if (status) return Qnil ;
+	return ULONG2NUM(value) ;
+}
+
+VALUE _setParamGlobal_(volatile VALUE self, volatile VALUE param, volatile VALUE paramVal) {
+	unsigned int _param = NUM2UINT(param) ;
+	unsigned long _paramVal = NUM2ULONG(paramVal) ;
+
+	RB_UNWRAP(cookie) ;
+
+	unsigned long value ;
+	magic_setparam(*cookie, _param, &_paramVal) ;
+
+	int status = magic_getparam(*cookie, _param, &value) ;
+
+	if (status) return Qnil ;
+	return ULONG2NUM((int)value) ;
+}
+
+VALUE _bufferGlobal_(volatile VALUE self, volatile VALUE string) {
+	RB_UNWRAP(cookie) ;
+
+	char *buffer = StringValuePtr(string) ;
+	const char *buf = magic_buffer(*cookie, buffer, sizeof(buffer)) ;
+
+	return rb_str_new_cstr(buf) ;
+}
+
+VALUE _listGlobal_(volatile VALUE self) {
+	RB_UNWRAP(cookie) ;
+
+	VALUE db = rb_iv_get(self, "@db") ;
+	char *database = StringValuePtr(db) ;
+
+	int status = magic_list(*cookie, database) ;
+	return INT2FIX(status) ;
+}
+
+VALUE _setflagsGlobal_(volatile VALUE self, volatile VALUE flags) {
+	unsigned int flag = NUM2UINT(flags) ;
+
+	RB_UNWRAP(cookie) ;
+	int status = magic_setflags(*cookie, flag) ;
+
+	if (status) {
+		return Qnil ;
+	} else {
+		rb_ivar_set(self, rb_intern("@mode"), flags) ;
+		return flags ;
+	}
+}

data/ext/libmagic/magic.c

@@ -0,0 +1,232 @@
+#include <magic.h>
+#include <stdio.h>
+#include <unistd.h>
+#include "ruby.h"
+
+/*
+* LibmagicRB Header files
+*/
+#include "modes.h"
+#include "params.h"
+#include "definitions.h"
+
+/*
+* Errors
+*/
+VALUE rb_eFileNotFoundError ;
+VALUE rb_eFileNotReadableError ;
+VALUE rb_eInvalidDBError ;
+VALUE rb_eIsDirError ;
+VALUE rb_eFileClosedError ;
+
+// Garbage collect
+void file_free(void **data) {
+	if(*data) {
+		magic_close(*data) ;
+		*data = NULL ;
+	}
+
+	free(data) ;
+}
+
+// Filetype
+static rb_data_type_t fileType = {
+	.wrap_struct_name = "file",
+
+	.function = {
+		.dmark = NULL,
+		.dfree = file_free,
+	},
+
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+} ;
+
+#include "validations.h"
+#include "func.h"
+
+VALUE _check_(volatile VALUE obj, volatile VALUE args) {
+	if(!RB_TYPE_P(args, T_HASH)) {
+		rb_raise(rb_eArgError, "Expected hash as argument.") ;
+	}
+
+	// Database Path
+	VALUE argDBPath = rb_hash_aref(args, ID2SYM(rb_intern("db"))) ;
+
+	char *databasePath ;
+	if (RB_TYPE_P(argDBPath, T_NIL)) {
+		databasePath = NULL ;
+	} else if (!RB_TYPE_P(argDBPath, T_STRING)) {
+		rb_raise(rb_eArgError, "Database name must be an instance of String.") ;
+	} else {
+		databasePath = StringValuePtr(argDBPath) ;
+	}
+
+	// File path
+	VALUE argFilePath = rb_hash_aref(args, ID2SYM(rb_intern("file"))) ;
+	if (RB_TYPE_P(argFilePath, T_NIL)) {
+		rb_raise(rb_eArgError, "Expected `file:\" key as a string, got nil instead") ;
+	} else if (!RB_TYPE_P(argFilePath, T_STRING)) {
+		rb_raise(rb_eArgError, "Filename must be an instance of String.") ;
+	}
+	char *checkPath = StringValuePtr(argFilePath) ;
+
+	// Modes
+	VALUE argModes = rb_hash_aref(args, ID2SYM(rb_intern("mode"))) ;
+	unsigned int modes ;
+	if(RB_TYPE_P(argModes, T_NIL)) {
+		modes = MAGIC_MIME | MAGIC_CHECK | MAGIC_SYMLINK ;
+	} else if (!RB_TYPE_P(argModes, T_FIXNUM)) {
+		rb_raise(rb_eArgError, "Modes must be an instance of Integer. Check LibmagicRb.constants() or LibmagicRb.lsmodes().") ;
+	} else {
+		modes = FIX2UINT(argModes) ;
+	}
+
+	// Checks
+	struct magic_set *magic = magic_open(modes) ;
+
+	// Check if the database is a valid file or not
+	// Raises ruby error which will return.
+	fileReadable(checkPath) ;
+
+	if(databasePath) {
+		magic_validate_db(magic, databasePath) ;
+	}
+
+	magic_load(magic, databasePath) ;
+
+	const char *mt = magic_file(magic, checkPath) ;
+
+	VALUE retVal = mt ? rb_str_new_cstr(mt) : Qnil ;
+	magic_close(magic) ;
+
+	return retVal ;
+}
+
+VALUE rb_libmagicRb_initialize(volatile VALUE self, volatile VALUE args) {
+	// Database Path
+	if(!RB_TYPE_P(args, T_HASH)) {
+		rb_raise(rb_eArgError, "Expected hash as argument.") ;
+	}
+
+	VALUE argDBPath = rb_hash_aref(args, ID2SYM(rb_intern("db"))) ;
+
+	char *databasePath ;
+	if (RB_TYPE_P(argDBPath, T_NIL)) {
+		databasePath = NULL ;
+		rb_ivar_set(self, rb_intern("@db"), Qnil) ;
+	} else if (!RB_TYPE_P(argDBPath, T_STRING)) {
+		rb_raise(rb_eArgError, "Database name must be an instance of String.") ;
+	} else {
+		databasePath = StringValuePtr(argDBPath) ;
+		rb_ivar_set(self, rb_intern("@db"), argDBPath) ;
+	}
+
+	// File path
+	VALUE argFilePath = rb_hash_aref(args, ID2SYM(rb_intern("file"))) ;
+	if (RB_TYPE_P(argFilePath, T_NIL)) {
+		rb_raise(rb_eArgError, "Expected `file:\" key as a string, got nil instead") ;
+	} else if (!RB_TYPE_P(argFilePath, T_STRING)) {
+		rb_raise(rb_eArgError, "Filename must be an instance of String.") ;
+	}
+	rb_ivar_set(self, rb_intern("@file"), argFilePath) ;
+
+	// Modes
+	VALUE argModes = rb_hash_aref(args, ID2SYM(rb_intern("mode"))) ;
+	unsigned int modes ;
+	if(RB_TYPE_P(argModes, T_NIL)) {
+		modes = MAGIC_MIME | MAGIC_CHECK | MAGIC_SYMLINK ;
+	} else if (!RB_TYPE_P(argModes, T_FIXNUM)) {
+		rb_raise(rb_eArgError, "Modes must be an instance of Integer. Check LibmagicRb.constants() or LibmagicRb.lsmodes().") ;
+	} else {
+		modes = FIX2UINT(argModes) ;
+	}
+	rb_ivar_set(self, rb_intern("@mode"), UINT2NUM(modes)) ;
+
+	rb_ivar_set(self, rb_intern("@closed"), Qfalse) ;
+
+	RB_UNWRAP(cookie) ;
+	magic_setflags(*cookie, modes) ;
+
+	return self ;
+}
+
+VALUE initAlloc(volatile VALUE self) {
+	magic_t *cookie ;
+	cookie = malloc(sizeof(*cookie)) ;
+	*cookie = magic_open(0) ;
+
+	return TypedData_Wrap_Struct(self, &fileType, cookie) ;
+}
+
+void Init_main() {
+	rb_global_variable(&rb_eFileNotFoundError) ;
+	rb_global_variable(&rb_eFileNotReadableError) ;
+	rb_global_variable(&rb_eInvalidDBError) ;
+	rb_global_variable(&rb_eIsDirError) ;
+	rb_global_variable(&rb_eFileClosedError) ;
+
+	/*
+	* Libmagic Errors
+	*/
+	VALUE cLibmagicRb = rb_define_class("LibmagicRb", rb_cObject) ;
+
+	rb_eFileNotFoundError = rb_define_class_under(cLibmagicRb, "FileNotFound", rb_eRuntimeError) ;
+	rb_eFileNotReadableError = rb_define_class_under(cLibmagicRb, "FileUnreadable", rb_eRuntimeError) ;
+	rb_eInvalidDBError = rb_define_class_under(cLibmagicRb, "InvalidDBError", rb_eRuntimeError) ;
+	rb_eIsDirError = rb_define_class_under(cLibmagicRb, "IsDirError", rb_eRuntimeError) ;
+	rb_eFileClosedError = rb_define_class_under(cLibmagicRb, "FileClosedError", rb_eRuntimeError) ;
+
+	/*
+	* Constants
+	*/
+	modes(cLibmagicRb) ;
+	params(cLibmagicRb) ;
+
+	char version[6] ;
+	sprintf(version, "%0.2f", magic_version() / 100.0) ;
+	rb_define_const(cLibmagicRb, "MAGIC_VERSION", rb_str_new_cstr(version)) ;
+
+	/*
+	* Singleton Methods
+	*/
+	rb_define_singleton_method(cLibmagicRb, "check", _check_, 1) ;
+	rb_define_singleton_method(cLibmagicRb, "lsmodes", lsmodes, 0) ;
+	rb_define_singleton_method(cLibmagicRb, "lsparams", lsparams, 0) ;
+
+	/*
+	* Instance Methods
+	*/
+	rb_define_alloc_func(cLibmagicRb, initAlloc) ;
+
+	// LibmagicRb.new()
+	rb_define_method(cLibmagicRb, "initialize", rb_libmagicRb_initialize, 1) ;
+
+	// Attributes
+	rb_define_attr(cLibmagicRb, "closed", 1, 0) ;
+	rb_define_attr(cLibmagicRb, "mode", 1, 0) ;
+	rb_define_attr(cLibmagicRb, "file", 1, 1) ;
+	rb_define_attr(cLibmagicRb, "db", 1, 1) ;
+
+	// Close database
+	rb_define_method(cLibmagicRb, "close", _closeGlobal_, 0) ;
+	rb_define_alias(cLibmagicRb, "closed?", "closed") ;
+
+	// Load database
+	rb_define_method(cLibmagicRb, "load", _loadGlobal_, 1) ;
+
+	// Check for file mimetype
+	rb_define_method(cLibmagicRb, "check", _checkGlobal_, 0) ;
+
+	// Get and set params
+	rb_define_method(cLibmagicRb, "getparam", _getParamGlobal_, 1) ;
+	rb_define_method(cLibmagicRb, "setparam", _setParamGlobal_, 2) ;
+
+	// Set modes dynamically
+	rb_define_method(cLibmagicRb, "setflags", _setflagsGlobal_, 1) ;
+	rb_define_method(cLibmagicRb, "mode=", _setflagsGlobal_, 1) ;
+
+	// Miscellaneous
+	rb_define_method(cLibmagicRb, "magic_buffer", _bufferGlobal_, 1) ;
+	rb_define_method(cLibmagicRb, "magic_list", _listGlobal_, 0) ;
+}

data/ext/libmagic/modes.h

@@ -0,0 +1,77 @@
+// In the older versions, there were some missing constants. Don't define them at compile time.
+
+void modes(volatile VALUE rb_klass) {
+	rb_define_const(rb_klass, "MAGIC_NONE", INT2FIX(MAGIC_NONE)) ;
+	rb_define_const(rb_klass, "MAGIC_DEBUG", INT2FIX(MAGIC_DEBUG)) ;
+	rb_define_const(rb_klass, "MAGIC_SYMLINK", INT2FIX(MAGIC_SYMLINK)) ;
+	rb_define_const(rb_klass, "MAGIC_COMPRESS", INT2FIX(MAGIC_COMPRESS)) ;
+	rb_define_const(rb_klass, "MAGIC_DEVICES", INT2FIX(MAGIC_DEVICES)) ;
+	rb_define_const(rb_klass, "MAGIC_MIME_TYPE", INT2FIX(MAGIC_MIME_TYPE)) ;
+	rb_define_const(rb_klass, "MAGIC_MIME_ENCODING", INT2FIX(MAGIC_MIME_ENCODING)) ;
+	rb_define_const(rb_klass, "MAGIC_MIME", INT2FIX(MAGIC_MIME)) ;
+	rb_define_const(rb_klass, "MAGIC_CONTINUE", INT2FIX(MAGIC_CONTINUE)) ;
+	rb_define_const(rb_klass, "MAGIC_CHECK", INT2FIX(MAGIC_CHECK)) ;
+	rb_define_const(rb_klass, "MAGIC_PRESERVE_ATIME", INT2FIX(MAGIC_PRESERVE_ATIME)) ;
+	rb_define_const(rb_klass, "MAGIC_RAW", INT2FIX(MAGIC_RAW)) ;
+	rb_define_const(rb_klass, "MAGIC_ERROR", INT2FIX(MAGIC_ERROR)) ;
+	rb_define_const(rb_klass, "MAGIC_APPLE", INT2FIX(MAGIC_APPLE)) ;
+	rb_define_const(rb_klass, "MAGIC_EXTENSION", INT2FIX(MAGIC_EXTENSION)) ;
+	rb_define_const(rb_klass, "MAGIC_COMPRESS_TRANSP", INT2FIX(MAGIC_COMPRESS_TRANSP)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_APPTYPE", INT2FIX(MAGIC_NO_CHECK_APPTYPE)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_CDF", INT2FIX(MAGIC_NO_CHECK_CDF)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_COMPRESS", INT2FIX(MAGIC_NO_CHECK_COMPRESS)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_ELF", INT2FIX(MAGIC_NO_CHECK_ELF)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_ENCODING", INT2FIX(MAGIC_NO_CHECK_ENCODING)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_SOFT", INT2FIX(MAGIC_NO_CHECK_SOFT)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_TAR", INT2FIX(MAGIC_NO_CHECK_TAR)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_TEXT", INT2FIX(MAGIC_NO_CHECK_TEXT)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_TOKENS", INT2FIX(MAGIC_NO_CHECK_TOKENS)) ;
+
+	#ifdef MAGIC_NO_CHECK_JSON
+		rb_define_const(rb_klass, "MAGIC_NO_CHECK_JSON", INT2FIX(MAGIC_NO_CHECK_JSON)) ;
+	#endif
+
+	#ifdef MAGIC_NO_CHECK_CSV
+		rb_define_const(rb_klass, "MAGIC_NO_CHECK_CSV", INT2FIX(MAGIC_NO_CHECK_CSV)) ;
+	#endif
+}
+
+VALUE lsmodes(volatile VALUE obj) {
+	VALUE hash = rb_hash_new() ;
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NONE")), INT2FIX(MAGIC_NONE)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_DEBUG")), INT2FIX(MAGIC_DEBUG)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_SYMLINK")), INT2FIX(MAGIC_SYMLINK)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_COMPRESS")), INT2FIX(MAGIC_COMPRESS)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_DEVICES")), INT2FIX(MAGIC_DEVICES)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_MIME_TYPE")), INT2FIX(MAGIC_MIME_TYPE)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_MIME_ENCODING")), INT2FIX(MAGIC_MIME_ENCODING)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_MIME")), INT2FIX(MAGIC_MIME)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_CONTINUE")), INT2FIX(MAGIC_CONTINUE)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_CHECK")), INT2FIX(MAGIC_CHECK)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PRESERVE_ATIME")), INT2FIX(MAGIC_PRESERVE_ATIME)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_RAW")), INT2FIX(MAGIC_RAW)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_ERROR")), INT2FIX(MAGIC_ERROR)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_APPLE")), INT2FIX(MAGIC_APPLE)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_EXTENSION")), INT2FIX(MAGIC_EXTENSION)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_COMPRESS_TRANSP")), INT2FIX(MAGIC_COMPRESS_TRANSP)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_APPTYPE")), INT2FIX(MAGIC_NO_CHECK_APPTYPE)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_CDF")), INT2FIX(MAGIC_NO_CHECK_CDF)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_COMPRESS")), INT2FIX(MAGIC_NO_CHECK_COMPRESS)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_ELF")), INT2FIX(MAGIC_NO_CHECK_ELF)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_ENCODING")), INT2FIX(MAGIC_NO_CHECK_ENCODING)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_SOFT")), INT2FIX(MAGIC_NO_CHECK_SOFT)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_TAR")), INT2FIX(MAGIC_NO_CHECK_TAR)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_TEXT")), INT2FIX(MAGIC_NO_CHECK_TEXT)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_TOKENS")), INT2FIX(MAGIC_NO_CHECK_TOKENS)) ;
+
+	#ifdef  MAGIC_NO_CHECK_CSV
+		rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_CSV")), INT2FIX(MAGIC_NO_CHECK_CSV)) ;
+	#endif
+
+	#ifdef  MAGIC_NO_CHECK_CSV
+		rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_JSON")), INT2FIX(MAGIC_NO_CHECK_JSON)) ;
+	#endif
+
+	return hash ;
+}

data/ext/libmagic/params.h

@@ -0,0 +1,29 @@
+void params(volatile VALUE rb_klass) {
+	rb_define_const(rb_klass, "MAGIC_PARAM_INDIR_MAX", UINT2NUM(MAGIC_PARAM_INDIR_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_NAME_MAX", UINT2NUM(MAGIC_PARAM_NAME_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_ELF_NOTES_MAX", UINT2NUM(MAGIC_PARAM_ELF_NOTES_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_ELF_PHNUM_MAX", UINT2NUM(MAGIC_PARAM_ELF_PHNUM_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_ELF_SHNUM_MAX", UINT2NUM(MAGIC_PARAM_ELF_SHNUM_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_REGEX_MAX", UINT2NUM(MAGIC_PARAM_REGEX_MAX)) ;
+
+	#ifdef MAGIC_PARAM_BYTES_MAX
+		rb_define_const(rb_klass, "MAGIC_PARAM_BYTES_MAX", UINT2NUM(MAGIC_PARAM_BYTES_MAX)) ;
+	#endif
+}
+
+VALUE lsparams(volatile VALUE obj) {
+	VALUE hash = rb_hash_new() ;
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_INDIR_MAX")), UINT2NUM(MAGIC_PARAM_INDIR_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_NAME_MAX")), UINT2NUM(MAGIC_PARAM_NAME_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_ELF_NOTES_MAX")), UINT2NUM(MAGIC_PARAM_ELF_NOTES_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_ELF_PHNUM_MAX")), UINT2NUM(MAGIC_PARAM_ELF_PHNUM_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_ELF_SHNUM_MAX")), UINT2NUM(MAGIC_PARAM_ELF_SHNUM_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_REGEX_MAX")), UINT2NUM(MAGIC_PARAM_REGEX_MAX)) ;
+
+	#ifdef MAGIC_PARAM_BYTES_MAX
+		rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_BYTES_MAX")), UINT2NUM(MAGIC_PARAM_BYTES_MAX)) ;
+	#endif
+
+	return hash ;
+}

data/ext/libmagic/validations.h

@@ -0,0 +1,23 @@
+void fileReadable(char *filePath) {
+	if(access(filePath, F_OK)) rb_raise(rb_eFileNotFoundError, "%s", filePath) ;
+	if(access(filePath, R_OK)) rb_raise(rb_eFileNotReadableError, "%s", filePath) ;
+}
+
+void magic_validate_db(magic_t cookie, char *databasePath) {
+	struct stat statbuf ;
+
+	if (stat(databasePath, &statbuf) != 0)
+		rb_raise(rb_eFileNotFoundError, "%s", databasePath) ;
+
+	if(S_ISDIR(statbuf.st_mode))
+		rb_raise(rb_eIsDirError, "%s", databasePath) ;
+
+	if(access(databasePath, R_OK)) rb_raise(rb_eFileNotReadableError, "%s", databasePath) ;
+
+	int validFile = magic_check(cookie, databasePath) ;
+
+	if (validFile != 0) {
+		const char *err = magic_error(cookie) ;
+		rb_raise(rb_eInvalidDBError, "%s (%s is not a valid magic file)", err, databasePath) ;
+	}
+}

data/lib/libmagic_rb.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "libmagic_rb/version"
+require "libmagic_rb/main"

data/lib/libmagic_rb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class LibmagicRb
+  VERSION = "0.1.0-alpha"
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: libmagic_rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.alpha
+platform: ruby
+authors:
+- Cybergizer
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-08-19 00:00:00.000000000 Z
+dependencies: []
+description: Check filetype with libmagic
+email:
+- sourav.goswami@cybergizer.com
+executables: []
+extensions:
+- ext/libmagic/extconf.rb
+extra_rdoc_files:
+- README.md
+files:
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/setup
+- ext/libmagic/definitions.h
+- ext/libmagic/extconf.rb
+- ext/libmagic/func.h
+- ext/libmagic/magic.c
+- ext/libmagic/modes.h
+- ext/libmagic/params.h
+- ext/libmagic/validations.h
+- lib/libmagic_rb.rb
+- lib/libmagic_rb/version.rb
+homepage: https://github.com/Cybergizer-hq/libmagic_rb/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: Check filetype with libmagic
+test_files: []